Générer des mots de passe aléatoires

Lorsqu’un utilisateur sur notre site perd son mot de passe et se dirige vers la page Mot de passe perdu, nous devons lui donner un nouveau mot de passe temporaire. Cela ne me dérange pas à quel point c’est aléatoire, ou s’il correspond à toutes les règles de mot de passe “nécessaires”, tout ce que je veux faire, c’est leur donner un mot de passe qu’ils pourront changer plus tard.

L’application est une application Web écrite en C #. alors je pensais être méchant et aller dans la voie facile d’utiliser une partie d’un Guid. c’est à dire

Guid.NewGuid().ToSsortingng("d").Subssortingng(1,8) 

Des suggestions? pensées?

Il y a toujours System.Web.Security.Membership.GeneratePassword(int length, int numberOfNonAlphanumericCharacters ) .

 public ssortingng CreatePassword(int length) { const ssortingng valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"; SsortingngBuilder res = new SsortingngBuilder(); Random rnd = new Random(); while (0 < length--) { res.Append(valid[rnd.Next(valid.Length)]); } return res.ToString(); } 

Cela présente l'avantage de pouvoir choisir parmi une liste de caractères disponibles pour le mot de passe généré (par exemple, uniquement les chiffres, uniquement les majuscules ou les minuscules, etc.).

Les principaux objectives de mon code sont:

  1. La dissortingbution des cordes est presque uniforme (peu importe les écarts mineurs, tant qu’ils sont petits)
  2. Il génère plus de quelques milliards de chaînes pour chaque ensemble d’arguments. Générer une chaîne de 8 caractères (environ 47 bits d’entropie) n’a pas de sens si votre PRNG ne génère que 2 milliards (31 bits d’entropie) de valeurs différentes.
  3. C’est sécurisé, car je m’attends à ce que les gens l’utilisent pour des mots de passe ou d’autres jetons de sécurité.

La première propriété est obtenue en prenant une valeur de 64 bits modulo la taille de l’alphabet. Pour les petits alphabets (tels que les 62 caractères de la question), cela entraîne un biais négligeable. Les deuxième et troisième propriétés sont obtenues à l’aide de RNGCryptoServiceProvider au lieu de System.Random .

 using System; using System.Security.Cryptography; public static ssortingng GetRandomAlphanumericSsortingng(int length) { const ssortingng alphanumericCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789"; return GetRandomSsortingng(length, alphanumericCharacters); } public static ssortingng GetRandomSsortingng(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); } 

(Ceci est une copie de ma réponse à Comment puis-je générer des chaînes alphanumériques de 8 caractères aléatoires en C #? )

Voici comment je génère des jetons aléatoires:

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

Il a été noté que comme cela retourne une chaîne de base 64, la longueur de sortie est toujours un multiple de 4, l’espace supplémentaire utilisant = comme caractère de remplissage. Le paramètre length spécifie la longueur du tampon d’octets, pas la chaîne de sortie (et n’est donc peut-être pas le meilleur nom pour ce paramètre, maintenant j’y pense). Cela contrôle combien d’octets d’ entropie le mot de passe aura. Cependant, comme la base 64 utilise un bloc de 4 caractères pour encoder chaque 3 octets d’entrée, si vous demandez une longueur qui n’est pas un multiple de 3, il y aura un “espace” supplémentaire, et cela utilisera = pour remplir l’extra.

Si vous n’aimez pas utiliser des chaînes de base 64 pour quelque raison que ce soit, vous pouvez remplacer l’appel Convert.ToBase64Ssortingng() par une conversion en chaîne régulière ou par l’une des méthodes de Encoding ; par exemple. Encoding.UTF8.GetSsortingng(tokenBuffer) – assurez-vous simplement de choisir un jeu de caractères pouvant représenter toute la gamme de valeurs provenant du RNG, et produisant des caractères compatibles avec l’endroit où vous les envoyez ou les stockez. Utiliser Unicode, par exemple, a tendance à donner beaucoup de caractères chinois. L’utilisation de base-64 garantit un ensemble de caractères largement compatible, et les caractéristiques d’une telle chaîne ne devraient pas la rendre moins sûre tant que vous utilisez un algorithme de hachage correct.

C’est beaucoup plus grand, mais je pense que cela semble un peu plus complet: 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 ssortingng PASSWORD_CHARS_LCASE = "abcdefgijkmnopqrstwxyz"; private static ssortingng PASSWORD_CHARS_UCASE = "ABCDEFGHJKLMNPQRSTWXYZ"; private static ssortingng PASSWORD_CHARS_NUMERIC= "23456789"; private static ssortingng 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 ssortingng 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 ssortingng 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 ssortingng 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(ssortingng[] 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 /////////////////////////////////////////////////////////////////////////////// 

Je sais que c’est un vieux sujet, mais j’ai une solution assez simple à utiliser pour quelqu’un. Facile à mettre en œuvre, facile à comprendre et à valider.

Considérez l’exigence suivante:

J’ai besoin d’un mot de passe aléatoire à générer qui comporte au moins 2 lettres minuscules, 2 lettres majuscules et 2 chiffres. Le mot de passe doit également comporter au moins 8 caractères.

L’expression régulière suivante peut valider ce cas:

 ^(?=\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,}$ 

C’est hors de la scope de cette question – mais la regex est basée sur lookahead / lookbehind et lookaround .

Le code suivant créera un ensemble aléatoire de caractères correspondant à cette exigence:

 public static ssortingng GeneratePassword(int lowercase, int uppercase, int numerics) { ssortingng lowers = "abcdefghijklmnopqrstuvwxyz"; ssortingng uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; ssortingng number = "0123456789"; Random random = new Random(); ssortingng 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); } 

Pour répondre à l'exigence ci-dessus, appelez simplement ce qui suit:

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

Le code commence par un caractère non valide ( "!" ) - de sorte que la chaîne a une longueur dans laquelle de nouveaux caractères peuvent être injectés.

Il passe ensuite en boucle de 1 au nombre de minuscules requirejs, et à chaque itération, récupère un élément aléatoire de la liste des minuscules et l'injecte à un emplacement aléatoire dans la chaîne.

Il répète ensuite la boucle pour les lettres majuscules et pour les chiffres.

Cela vous donne des chaînes de longueur = lowercase + uppercase + numerics dans lesquels les caractères minuscules, majuscules et numériques du compte que vous voulez ont été placés dans un ordre aléatoire.

Pour ce type de mot de passe, j’ai tendance à utiliser un système susceptible de générer plus facilement des mots de passe «utilisés». Bref, souvent constitué de fragments prononçables et de quelques nombres, et sans ambiguïté entre les caractères (est-ce un 0 ou un O? A 1 ou un I?). Quelque chose comme

 ssortingng[] words = { 'bur', 'ler', 'meh', 'ree' }; ssortingng 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; 

(Tapez directement dans le navigateur, utilisez donc uniquement comme guide. Ajoutez également d'autres mots).

Je n’aime pas les mots de passe créés par Membership.GeneratePassword (), car ils sont trop laids et contiennent trop de caractères spéciaux.

Ce code génère un mot de passe de 10 chiffres pas trop moche.

 ssortingng password = Guid.NewGuid().ToSsortingng("N").ToLower() .Replace("1", "").Replace("o", "").Replace("0","") .Subssortingng(0,10); 

Bien sûr, je pourrais utiliser un Regex pour faire tous les remplacements, mais c’est plus lisible et maintenable IMO.

J’ai créé cette classe qui utilise RNGCryptoServiceProvider et qui est flexible. Exemple:

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

J’ai créé cette méthode similaire à celle disponible dans le fournisseur d’adhésion. Cela est utile si vous ne souhaitez pas append la référence Web dans certaines applications.

Cela fonctionne très bien.

 public static ssortingng GeneratePassword(int Length, int NonAlphaNumericChars) { ssortingng allowedChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789"; ssortingng 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; } 

J’ai toujours été très satisfait du générateur de mots de passe intégré à KeePass. Comme KeePass est un programme .Net et open source, j’ai décidé de creuser un peu le code. J’ai fini par recréer KeePass.exe, la copie fournie dans l’installation standard de l’application, comme référence dans mon projet et en écrivant le code ci-dessous. Vous pouvez voir à quel point c’est flexible grâce à KeePass. Vous pouvez spécifier la longueur, les caractères à inclure / non, etc.

 using KeePassLib.Cryptography.PasswordGenerator; using KeePassLib.Security; public static ssortingng GeneratePassword(int passwordLength, bool lowerCase, bool upperCase, bool digits, bool punctuation, bool brackets, bool specialAscii, bool excludeLookAlike) { var ps = new ProtectedSsortingng(); 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.ReadSsortingng(); } 

J’aime regarder la génération de mots de passe, tout comme la génération de clés de logiciel. Vous devriez choisir parmi un éventail de caractères qui suivent une bonne pratique. Prenez ce que @ Radu094 a répondu et modifiez-le pour suivre les bonnes pratiques. Ne mettez pas chaque lettre dans le tableau de caractères. Certaines lettres sont plus difficiles à dire ou à comprendre par téléphone.

Vous devez également envisager d’utiliser une sum de contrôle sur le mot de passe généré pour vous assurer qu’il a été généré par vous. Un bon moyen pour y parvenir est d’utiliser l’ algorithme LUHN .

Voici ce que je rassemble rapidement.

  public ssortingng GeneratePassword(int len) { ssortingng 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.ToSsortingng() : ""; }))(rnd); return res; } 
  Generate random password of specified length with - Special characters - Number - Lowecase - Uppercase public static ssortingng CreatePassword(int length = 12) { const ssortingng lower = "abcdefghijklmnopqrstuvwxyz"; const ssortingng upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; const ssortingng number = "1234567890"; const ssortingng special = "!@#$%^&*"; var middle = length / 2; SsortingngBuilder res = new SsortingngBuilder(); 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(); } 

C’est court et ça marche très bien pour moi.

 public static ssortingng GenerateRandomCode(int length) { Random rdm = new Random(); SsortingngBuilder sb = new SsortingngBuilder(); for(int i = 0; i < length; i++) sb.Append(Convert.ToChar(rdm.Next(101,132))); return sb.ToString(); } 

Sur mon site j’utilise cette méthode:

  //Symb array private const ssortingng _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(); } 

Editez la chaîne _SymbolsAll pour votre liste de tableaux.

Ajout d’un code supplémentaire à la réponse acceptée. Il améliore les réponses en utilisant simplement Aléatoire et permet certaines options de mot de passe. J’ai également aimé certaines options de la réponse de KeePass mais je ne voulais pas inclure l’exécutable dans ma solution.

 private ssortingng 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"); ssortingng 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 (ssortingng r in remove) passwordSsortingng = passwordSsortingng.Replace(r, ssortingng.Empty); } if (!includeLookAlikes) { var remove = new ssortingng[] { "(", ")", "0", "O", "o", "1", "i", "I", "l", "|", "!", ":", ";" }; foreach (ssortingng r in remove) passwordSsortingng = passwordSsortingng.Replace(r, ssortingng.Empty); } return passwordSsortingng; } 

C’était le premier lien lorsque j’ai cherché à générer des mots de passe aléatoires et ce qui suit est hors de scope pour la question actuelle, mais pourrait être important à considérer.

  • Basé sur l’hypothèse que System.Web.Security.Membership.GeneratePassword est sécurisé sur le plan cryptographique, avec un minimum de 20% de caractères non alphanumériques.
  • Vous ne savez pas si supprimer des caractères et append des chaînes est considéré comme une bonne pratique dans ce cas et fournit suffisamment d’entropie.
  • Peut-être voudrez-vous envisager d’implémenter d’une manière ou d’une autre avec SecureSsortingng un stockage sécurisé des mots de passe en mémoire.

validChars peut être n’importe quelle construction, mais j’ai décidé de sélectionner en fonction des plages de code ascii la suppression des caractères de contrôle. Dans cet exemple, il s’agit d’une chaîne de 12 caractères.

 ssortingng validChars = Ssortingng.Join("", Enumerable.Range(33, (126 - 33)).Where(i => !(new int[] { 34, 38, 39, 44, 60, 62, 96 }).Contains(i)).Select(i => { return (char)i; })); ssortingng.Join("", Enumerable.Range(1, 12).Select(i => { return validChars[(new Random(Guid.NewGuid().GetHashCode())).Next(0, validChars.Length - 1)]; })) 
 public static ssortingng GeneratePassword(int passLength) { var chars = "abcdefghijklmnopqrstuvwxyz@#$&ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; var random = new Random(); var result = new ssortingng( 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; 

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; ssortingng possible = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"; ssortingng 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 ssortingng 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; } ssortingng 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; }