¿Cómo puedo generar una contraseña aleatoria en el idioma de un usuario?

Question

Mi aplicación debe ser compatible con I18N. Uno de los requisitos es que la contraseña inicial que genero debe estar en el idioma elegido por el usuario. ¿Qué API en Java puedo usar para lograr esto? Tengo el idioma del usuario y necesito obtener algunos caracteres aleatorios del conjunto Unicode de ese idioma.

Editar: Gracias por las respuestas hasta el momento. Algunas aclaraciones: esto es para una aplicación basada en la web. Por razones de seguridad, no podemos mantener un stock de caracteres/palabras en diferentes idiomas.

Editar 2: En respuesta a los comentarios y algunas respuestas: Esta aplicación se implementará en varias geografías & No quiero que tengan que trabajar para configurar contraseñas en cualquier idioma que implementen. Eso y seguridad son las razones por las que aún no acepté la respuesta más popular.

Answer 1

Aunque no estoy seguro de establecimiento de una contraseña por defecto es una acción deseable (la gente a menudo no saben cómo cambiarlo y luego olvidarse de él) si estuviera haciendo esto, me gustaría tener una carga de listas de palabras en varios idiomas y elija quizás dos palabras aleatorias, concatenar y usar eso como la contraseña.

Significa que tendrás que hacer un gran trabajo para encontrar las listas de palabras pero debería ser un proceso bastante simple una vez que las tienes.

Editar: Si solo está haciendo cadenas aleatorias, se vuelve mucho más simple: solo almacena un archivo de caracteres disponibles para cada idioma. Abra el derecho cuando llegue a generar y luego elija letras al azar. Bish bash bosh. Hecho.

Editar 2: Como comentó correctamente Marcelo, podría encontrarse con el problema de generar alguna contraseña obscena para el usuario. También puede valer la pena conservar las cadenas localizadas en la lista negra para comprobar su contraseña. Si alguna de las cadenas aparece en la contraseña (solo en ella, no en todo), genere una contraseña diferente. Esto significa que nunca generará una contraseña lo suficientemente inocente como scunthorpe, pero también significa que no obtendrá cosas como assclown deslizándose a través de cualquiera.

Como puede haber reunido, esto está empezando a parecerse mucho trabajo:

• obtener todos los caracteres válidos para todos los idiomas que va a apoyar
• conseguir todas las palabras obscenas para cada idioma va a apoyar
• generar una contraseña basada en las letras
• Comprobar ninguno de ellos contiene una mala palabra
• Recuerde que algunas palabras obscenas son adoptadas por otros idiomas, pero mi No aparece en las listas negras específicas del idioma, así que mantén una lista negra internacional también.

Usted puede encontrar que el establecimiento de una frase de Transmisión el uso de palabras limpias conocidos de cada idioma (por mi respuesta original) funciona mejor.

Si todo parece demasiado estresante, sería mejor volver a adjudicar la razón para establecer una contraseña aleatoria en primer lugar. Si se trata de un dispositivo de verificación de correo electrónico, existen otros métodos más fáciles de usar. Por ejemplo: el envío de un enlace único que se hizo clic

---

Editar: números estaría bien?Son un lote más seguro, no necesitan peinado, son internacionales y pueden ser lo suficientemente largos como para ser únicos, son raramente memorables. Si son trabajos únicos de copiar y pegar, deberían hacerlo bien.

Si necesita que sean cortos pero muy singular (y necesita un montón) tal vez los números mezclando con letras en patrones predecibles como (= a carta, n = número) annn-annn da 676,000,000 combinaciones. Incluso cosas simples como annn dan lo suficiente como para no ser adivinadas (26000 combos) si no necesitan ser únicas ... Si estas son contraseñas, no hay nada de malo en que dos sean iguales.

Answer 2

Si desea tener palabras significativas en todos los idiomas, puede utilizar un conjunto de palabras traducidas al inglés (por ejemplo, mediante el traductor de Google).

Luego puede envolverlos con números y caracteres especiales para la seguridad de la contraseña.

Y por supuesto, en su lugar, le diría al usuario que cambie inmediatamente cualquier contraseña inicial que proporcione a algo de su elección.

Answer 3

La base de datos de caracteres Unicode y el depósito de datos de configuración regional común Unicode contienen mucha información sobre idiomas y scripts. Puede acceder a la información utilizando, por ejemplo, IBM ICU (una biblioteca I18N/L10N más completa que las configuraciones regionales de Java).

En particular, puede obtener un conjunto de caracteres de ejemplo, usando LocaleData.getExemplarSet. Sin embargo, tenga en cuenta que el CLDR está lejos de completarse, debe esperar datos faltantes.

Answer 4

Eche un vistazo a http://thedailywtf.com/Articles/The-Automated-Curse-Generator.aspx donde se describe algo similar. las palabras clave que debe buscar parecen ser "cadenas de markov".

Editar: acaba de darse cuenta de que dan04 ya ha mencionado ese enlace.

Answer 5

El JDK incluye los nombres de país de la pantalla, el idioma de visualización y el texto de visualización de cada configuración regional, almacenados en todas las configuraciones regionales disponibles. Puede usar esto para crear un conjunto de caracteres inicial para cada configuración regional y usar Character.toUpperCaseCharacter.toLowerCase para obtener también variantes de casos.

String getCharsForLocale(Locale locale) { 
     Locale[] allLocales = Locale.getAvailableLocales(); 
     StringBuilder buf = new StringBuilder(); 
     for (Locale l: allLocales) { 
      buf.append(l.getDisplayName(locale).toLowerCase()) 
      .append(l.getDisplayName(locale).toUpperCase()) 
      .append(l.getDisplaycountry(locale).toLowerCase()) 
      .append(l.getDisplayCountry(locale).toUpperCase()) 
      .append(l.getDisplayLanguage(locale).toLowerCase()) 
      .append(l.getDisplayLanguage(locale).toUpperCase()); 
     } 
     // add other chars, such as decimals 
     DecimalFormatSymbols decimals = DecimalFormatSymbols.getInstance(locale); 
     buf.append(decimals.getMinusSign()) 
     .append(decimals.getPercent()) 
     .append(decimals.getDecimalSeparator()); 
     // etc.. 

     // now remove dupicates 
     char[] chars = new char[buf.length()]; 
     buf.getChars(0, chars.length, chars, 0); 
     Arrays.sort(chars); 
     buf = new StringBuilder(); 
     char last = '\0'; 
     for (char c: chars) { 
      if (c!=last) buf.append(c); 
      last = c; 
     } 
     return buf.toString(); 
    } 

Si bien esto no enumera exhaustivamente todos y cada uno de los caracteres posibles, la intención es que enumere los que se utilizan comúnmente.

Answer 6

1. usar un diccionario latino con recogiendo palabras al azar en CammelCase hasta son de la longitud deseada.
2. Si insistes en obtener el lujo de Unicode, prueba el UN UDHR. Solo raspe con un poco de regex simple. Debido al tamaño más pequeño del diccionario es posible que necesite contraseñas más largas, pero a quién le importa.

Answer 7

Quizás esto suene un poco complicado. Pero puede mantener muchas palabras en una base de datos. Y tradúzcalos con alguna herramienta de traducción al idioma del usuario. (Tal vez Google, pero no sé si Google lo permite)
Un poco como reCHAPTA hace. Tienen mucho tekst (como Lorem Ipsum) donde eligen dos palabras.

Puede combinar dos o tres palabras (con una longitud máxima) con un número. Tal vez con el símbolo de su país en el frente. Para que pueda obtener cosas como:

• BE_VogelHuis9751
• FR_ChienVoiture3104
• ES_GatoEdificio9554
• D_BrustTausend9672
• ...

Answer 8

quizá u puede crear una palabra en Inglés, y traducirlo con Google traducirlo

Answer 9

Esta es una pregunta realmente interesante que me hizo pensar, y sumergí mis manos en la tierra. Aquí es mi proceso de pensamiento

1. Obtener la configuración regional (generalmente estándar para el intercambio de idioma, opcional si usted tiene la lengua ya)
2. Get idioma desde la configuración regional
3. Get escritura para la lengua
4. Obtener caracteres (caracteres unicode) para el script
5. Generar contraseña aleatoria.
6. Opcionalmente, el tiempo-envolver el proceso

Here is the gist

import java.security.SecureRandom; 
import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Locale; 
import java.util.Map; 

public class LocaleSpecificPasswordGenerator { 

    public static void main(String[] args) { 
     // 1. get locale : en_US/ es_US/ hi_IN/ud_PK 
     // 2. get language from locale 
     // 3. get script for language 
     // 4. get charset 
     // 5. get script characters from charset 
     // 6. generate random password 
     // 7. time wrap the password generation process 
     Locale lo = Locale.ENGLISH; 
     int passwordLength = 10; 
     String password = timeWrappedPasswordGeneration(lo, passwordLength); 
     System.out.println(password); 
    } 

    private static String timeWrappedPasswordGeneration(Locale lo, 
      int passwordLength) { 
     long curr = System.currentTimeMillis(); 
     String password = null; 
     while (System.currentTimeMillis() - curr < 50) { 
      password = generateRandomPassword(
        getCharListForScript(getScriptFromLanguage(lo.getLanguage())), 
        passwordLength); 
     } 
     return password; 
    } 

    private static String getScriptFromLanguage(String languageCode) { 
     String script = ""; 
     switch (languageCode) { 
     case "ar": 
      script = "Arabic"; 
      break; 
     case "as": 
      script = "Bengali and Assamese"; 
      break; 
     case "be": 
      script = "Cyrillic"; 
      break; 
     case "bg": 
      script = "Cyrillic"; 
      break; 
     case "bn": 
      script = "Bengali and Assamese"; 
      break; 
     case "ca": 
      script = "Latin"; 
      break; 
     case "cs": 
      script = "Latin"; 
      break; 
     case "da": 
      script = "Latin"; 
      break; 
     case "de": 
      script = "Latin"; 
      break; 
     case "el": 
      script = "Greek"; 
      break; 
     case "en": 
      script = "Latin"; 
      break; 
     case "es": 
      script = "Latin"; 
      break; 
     case "et": 
      script = "Latin"; 
      break; 
     case "fi": 
      script = "Latin"; 
      break; 
     case "fr": 
      script = "Latin"; 
      break; 
     case "ga": 
      script = "Latin"; 
      break; 
     case "gu": 
      script = "Gujarati"; 
      break; 
     case "he": 
      script = "Samaritan"; 
      break; 
     case "hi": 
      script = "Devanagari"; 
      break; 
     case "hr": 
      script = "Latin"; 
      break; 
     case "hu": 
      script = "Old Hungarian"; 
      break; 
     case "hy": 
      script = "Armenian"; 
      break; 
     case "in": 
      script = "Latin"; 
      break; 
     case "is": 
      script = "Latin"; 
      break; 
     case "it": 
      script = "Latin"; 
      break; 
     case "iw": 
      script = "Hebrew"; 
      break; 
     case "ja": 
      script = "Katakana"; 
      break; 
     case "ka": 
      script = "Georgian"; 
      break; 
     case "kn": 
      script = "Kannada"; 
      break; 
     case "ko": 
      script = "Hangul Jamo"; 
      break; 
     case "lt": 
      script = "Latin"; 
      break; 
     case "lv": 
      script = "Latin"; 
      break; 
     case "mk": 
      script = "Cyrillic"; 
      break; 
     case "ml": 
      script = "Malayalam"; 
      break; 
     case "mn": 
      script = "Mongolian"; 
      break; 
     case "ms": 
      script = "Latin"; 
      break; 
     case "mt": 
      script = "Latin"; 
      break; 
     case "ne": 
      script = "Limbu"; 
      break; 
     case "nl": 
      script = "Latin"; 
      break; 
     case "no": 
      script = "Latin"; 
      break; 
     case "or": 
      script = "Oriya"; 
      break; 
     case "pa": 
      script = "Gurmukhi"; 
      break; 
     case "pa-IN": 
      script = "Gurmukhi"; 
      break; 
     case "pl": 
      script = "Latin"; 
      break; 
     case "pt": 
      script = "Latin"; 
      break; 
     case "ro": 
      script = "Latin"; 
      break; 
     case "ru": 
      script = "Cyrillic"; 
      break; 
     case "sk": 
      script = "Latin"; 
      break; 
     case "sl": 
      script = "Latin"; 
      break; 
     case "sq": 
      script = "Caucasian Albanian"; 
      break; 
     case "sr": 
      script = "Cyrillic"; 
      break; 
     case "sv": 
      script = "Latin"; 
      break; 
     case "ta": 
      script = "Tamil"; 
      break; 
     case "te": 
      script = "Telugu"; 
      break; 
     case "th": 
      script = "Thai"; 
      break; 
     case "tr": 
      script = "Latin"; 
      break; 
     case "uk": 
      script = "Cyrillic"; 
      break; 
     case "vi": 
      script = "Latin"; 
      break; 
     case "zh": 
      script = "CJK Unified Ideographs (Han)"; 
      break; 
     default: 
      script = "Latin"; 
     } 
     return script; 
    } 

    private static String generateRandomPassword(List<Character> charlist, 
      int length) { 
     StringBuilder sb = new StringBuilder(); 
     if (charlist.size() > 0) { 
      while (sb.length() < length) { 
       SecureRandom random = new SecureRandom(); 
       int charAt = random.nextInt(charlist.size()); 

       sb.append(charlist.get(charAt)); 
      } 
     } 
     return sb.toString(); 
    } 

    private static List<Character> getCharListForScript(String script) { 
     Map<String, Character> initialMap = new HashMap<String, Character>(); 
     Map<String, Character> finalMap = new HashMap<String, Character>(); 
     initialMap.put("Armenian", '\u0530'); 
     finalMap.put("Armenian", '\u058F'); 
     initialMap.put("Armenian Ligatures", '\uFB13'); 
     finalMap.put("Armenian Ligatures", '\uFB17'); 
     // initialMap.put("Caucasian Albanian",'\u10530'); 
     // finalMap.put("Caucasian Albanian",'\u1056F'); 
     // initialMap.put("Cypriot Syllabary",'\u10800'); 
     // finalMap.put("Cypriot Syllabary",'\u1083F'); 
     initialMap.put("Cyrillic", '\u0400'); 
     finalMap.put("Cyrillic", '\u04FF'); 
     initialMap.put("Cyrillic Supplement", '\u0500'); 
     finalMap.put("Cyrillic Supplement", '\u052F'); 
     initialMap.put("Cyrillic Extended-A", '\u2DE0'); 
     finalMap.put("Cyrillic Extended-A", '\u2DFF'); 
     initialMap.put("Cyrillic Extended-B", '\uA640'); 
     finalMap.put("Cyrillic Extended-B", '\uA69F'); 
     // initialMap.put("Elbasan",'\u10500'); 
     // finalMap.put("Elbasan",'\u1052F'); 
     initialMap.put("Georgian", '\u10A0'); 
     finalMap.put("Georgian", '\u10FF'); 
     initialMap.put("Georgian Supplement", '\u2D00'); 
     finalMap.put("Georgian Supplement", '\u2D2F'); 
     initialMap.put("Glagolitic", '\u2C00'); 
     finalMap.put("Glagolitic", '\u2C5F'); 
     // initialMap.put("Gothic",'\u10330'); 
     // finalMap.put("Gothic",'\u1034F'); 
     initialMap.put("Greek", '\u0370'); 
     finalMap.put("Greek", '\u03FF'); 
     initialMap.put("Greek Extended", '\u1F00'); 
     finalMap.put("Greek Extended", '\u1FFF'); 
     // initialMap.put("Ancient Greek Numbers",'\u10140'); 
     // finalMap.put("Ancient Greek Numbers",'\u1018F'); 
     initialMap.put("Latin", '\u0020'); 
     finalMap.put("Latin", '\u007E'); 
     initialMap.put("Basic Latin (ASCII)", '\u0000'); 
     finalMap.put("Basic Latin (ASCII)", '\u007F'); 
     initialMap.put("Latin-1 Supplement", '\u0080'); 
     finalMap.put("Latin-1 Supplement", '\u00FF'); 
     initialMap.put("Latin Extended-A", '\u0100'); 
     finalMap.put("Latin Extended-A", '\u017F'); 
     initialMap.put("Latin Extended-B", '\u0180'); 
     finalMap.put("Latin Extended-B", '\u024F'); 
     initialMap.put("Latin Extended-C", '\u2C60'); 
     finalMap.put("Latin Extended-C", '\u2C7F'); 
     initialMap.put("Latin Extended-D", '\uA720'); 
     finalMap.put("Latin Extended-D", '\uA7FF'); 
     initialMap.put("Latin Extended-E", '\uAB30'); 
     finalMap.put("Latin Extended-E", '\uAB6F'); 
     initialMap.put("Latin Extended Additional", '\u1E00'); 
     finalMap.put("Latin Extended Additional", '\u1EFF'); 
     initialMap.put("Latin Ligatures", '\uFB00'); 
     finalMap.put("Latin Ligatures", '\uFB06'); 
     initialMap.put("Fullwidth Latin Letters", '\uFF00'); 
     finalMap.put("Fullwidth Latin Letters", '\uFF5E'); 
     initialMap.put("IPA Extensions", '\u0250'); 
     finalMap.put("IPA Extensions", '\u02AF'); 
     initialMap.put("Phonetic Extensions", '\u1D00'); 
     finalMap.put("Phonetic Extensions", '\u1D7F'); 
     initialMap.put("Phonetic Extensions Supplement", '\u1D80'); 
     finalMap.put("Phonetic Extensions Supplement", '\u1DBF'); 
     // initialMap.put("Linear A",'\u10600'); 
     // finalMap.put("Linear A",'\u1077F'); 
     // initialMap.put("Linear B Syllabary",'\u10000'); 
     // finalMap.put("Linear B Syllabary",'\u1007F'); 
     // initialMap.put("Linear B Ideograms",'\u10080'); 
     // finalMap.put("Linear B Ideograms",'\u100FF'); 
     // initialMap.put("Aegean Numbers",'\u10100'); 
     // finalMap.put("Aegean Numbers",'\u1013F'); 
     initialMap.put("Ogham", '\u1680'); 
     finalMap.put("Ogham", '\u169F'); 
     // initialMap.put("Old Hungarian",'\u10C80'); 
     // finalMap.put("Old Hungarian",'\u10CFF'); 
     // initialMap.put("Old Italic",'\u10300'); 
     // finalMap.put("Old Italic",'\u1032F'); 
     // initialMap.put("Old Permic",'\u10350'); 
     // finalMap.put("Old Permic",'\u1037F'); 
     // initialMap.put("Phaistos Disc",'\u101D0'); 
     // finalMap.put("Phaistos Disc",'\u101FF'); 
     initialMap.put("Runic", '\u16A0'); 
     finalMap.put("Runic", '\u16FF'); 
     // initialMap.put("Shavian",'\u10450'); 
     // finalMap.put("Shavian",'\u1047F'); 
     initialMap.put("Modifier Tone Letters", '\uA700'); 
     finalMap.put("Modifier Tone Letters", '\uA71F'); 
     initialMap.put("Spacing Modifier Letters", '\u02B0'); 
     finalMap.put("Spacing Modifier Letters", '\u02FF'); 
     initialMap.put("Superscripts and Subscripts", '\u2070'); 
     finalMap.put("Superscripts and Subscripts", '\u209F'); 
     initialMap.put("Combining Diacritical Marks", '\u0300'); 
     finalMap.put("Combining Diacritical Marks", '\u036F'); 
     initialMap.put("Combining Diacritical Marks Extended", '\u1AB0'); 
     finalMap.put("Combining Diacritical Marks Extended", '\u1AFF'); 
     initialMap.put("Combining Diacritical Marks Supplement", '\u1DC0'); 
     finalMap.put("Combining Diacritical Marks Supplement", '\u1DFF'); 
     initialMap.put("Combining Diacritical Marks for Symbols", '\u20D0'); 
     finalMap.put("Combining Diacritical Marks for Symbols", '\u20FF'); 
     initialMap.put("Combining Half Marks", '\uFE20'); 
     finalMap.put("Combining Half Marks", '\uFE2F'); 
     initialMap.put("Bamum", '\uA6A0'); 
     finalMap.put("Bamum", '\uA6FF'); 
     // initialMap.put("Bamum Supplement",'\u16800'); 
     // finalMap.put("Bamum Supplement",'\u16A3F'); 
     // initialMap.put("Bassa Vah",'\u16AD0'); 
     // finalMap.put("Bassa Vah",'\u16AFF'); 
     initialMap.put("Coptic", '\u2C80'); 
     finalMap.put("Coptic", '\u2CFF'); 
     initialMap.put("Coptic in Greek block", '\u03E2'); 
     finalMap.put("Coptic in Greek block", '\u03EF'); 
     // initialMap.put("Coptic Epact Numbers",'\u102E0'); 
     // finalMap.put("Coptic Epact Numbers",'\u102FF'); 
     // initialMap.put("Egyptian Hieroglyphs",'\u13000'); 
     // finalMap.put("Egyptian Hieroglyphs",'\u1342F'); 
     initialMap.put("Ethiopic", '\u1200'); 
     finalMap.put("Ethiopic", '\u137F'); 
     initialMap.put("Ethiopic Supplement", '\u1380'); 
     finalMap.put("Ethiopic Supplement", '\u139F'); 
     initialMap.put("Ethiopic Extended", '\u2D80'); 
     finalMap.put("Ethiopic Extended", '\u2DDF'); 
     initialMap.put("Ethiopic Extended-A", '\uAB00'); 
     finalMap.put("Ethiopic Extended-A", '\uAB2F'); 
     // initialMap.put("Mende Kikakui",'\u1E800'); 
     // finalMap.put("Mende Kikakui",'\u1E8DF'); 
     // initialMap.put("Meroitic Cursive",'\u109A0'); 
     // finalMap.put("Meroitic Cursive",'\u109FF'); 
     // initialMap.put("Meroitic Hieroglyphs",'\u10980'); 
     // finalMap.put("Meroitic Hieroglyphs",'\u1099F'); 
     initialMap.put("N&#39;Ko", '\u07C0'); 
     finalMap.put("N&#39;Ko", '\u07FF'); 
     // initialMap.put("Osmanya",'\u10480'); 
     // finalMap.put("Osmanya",'\u104AF'); 
     initialMap.put("Tifinagh", '\u2D30'); 
     finalMap.put("Tifinagh", '\u2D7F'); 
     initialMap.put("Vai", '\uA500'); 
     finalMap.put("Vai", '\uA63F'); 
     // initialMap.put("Anatolian Hieroglyphs",'\u14400'); 
     // finalMap.put("Anatolian Hieroglyphs",'\u1467F'); 
     initialMap.put("Arabic", '\u0600'); 
     finalMap.put("Arabic", '\u06FF'); 
     initialMap.put("Arabic Supplement", '\u0750'); 
     finalMap.put("Arabic Supplement", '\u077F'); 
     initialMap.put("Arabic Extended-A", '\u08A0'); 
     finalMap.put("Arabic Extended-A", '\u08FF'); 
     initialMap.put("Arabic Presentation Forms-A", '\uFB50'); 
     finalMap.put("Arabic Presentation Forms-A", '\uFDFF'); 
     initialMap.put("Arabic Presentation Forms-B", '\uFE70'); 
     finalMap.put("Arabic Presentation Forms-B", '\uFEFF'); 
     // initialMap.put("Aramaic, Imperial",'\u10840'); 
     // finalMap.put("Aramaic, Imperial",'\u1085F'); 
     // initialMap.put("Avestan",'\u10B00'); 
     // finalMap.put("Avestan",'\u10B3F'); 
     // initialMap.put("Carian",'\u102A0'); 
     // finalMap.put("Carian",'\u102DF'); 
     // initialMap.put("Cuneiform",'\u12000'); 
     // finalMap.put("Cuneiform",'\u123FF'); 
     // initialMap.put("Cuneiform Numbers and Punctuation",'\u12400'); 
     // finalMap.put("Cuneiform Numbers and Punctuation",'\u1247F'); 
     // initialMap.put("Early Dynastic Cuneiform",'\u12480'); 
     // finalMap.put("Early Dynastic Cuneiform",'\u1254F'); 
     // initialMap.put("Old Persian",'\u103A0'); 
     // finalMap.put("Old Persian",'\u103DF'); 
     // initialMap.put("Ugaritic",'\u10380'); 
     // finalMap.put("Ugaritic",'\u1039F'); 
     // initialMap.put("Hatran",'\u108E0'); 
     // finalMap.put("Hatran",'\u108FF'); 
     initialMap.put("Hebrew", '\u0590'); 
     finalMap.put("Hebrew", '\u05FF'); 
     initialMap.put("Hebrew Presentation Forms", '\uFB1D'); 
     finalMap.put("Hebrew Presentation Forms", '\uFB4F'); 
     // initialMap.put("Lycian",'\u10280'); 
     // finalMap.put("Lycian",'\u1029F'); 
     // initialMap.put("Lydian",'\u10920'); 
     // finalMap.put("Lydian",'\u1093F'); 
     initialMap.put("Mandaic", '\u0840'); 
     finalMap.put("Mandaic", '\u085F'); 
     // initialMap.put("Nabataean",'\u10880'); 
     // finalMap.put("Nabataean",'\u108AF'); 
     // initialMap.put("Old North Arabian",'\u10A80'); 
     // finalMap.put("Old North Arabian",'\u10A9F'); 
     // initialMap.put("Old South Arabian",'\u10A60'); 
     // finalMap.put("Old South Arabian",'\u10A7F'); 
     // initialMap.put("Pahlavi, Inscriptional",'\u10B60'); 
     // finalMap.put("Pahlavi, Inscriptional",'\u10B7F'); 
     // initialMap.put("Pahlavi, Psalter",'\u10B80'); 
     // finalMap.put("Pahlavi, Psalter",'\u10BAF'); 
     // initialMap.put("Palmyrene",'\u10860'); 
     // finalMap.put("Palmyrene",'\u1087F'); 
     // initialMap.put("Parthian, Inscriptional",'\u10B40'); 
     // finalMap.put("Parthian, Inscriptional",'\u10B5F'); 
     // initialMap.put("Phoenician",'\u10900'); 
     // finalMap.put("Phoenician",'\u1091F'); 
     initialMap.put("Samaritan", '\u0800'); 
     finalMap.put("Samaritan", '\u083F'); 
     initialMap.put("Syriac", '\u0700'); 
     finalMap.put("Syriac", '\u074F'); 
     // initialMap.put("Manichaean",'\u10AC0'); 
     // finalMap.put("Manichaean",'\u10AFF'); 
     initialMap.put("Mongolian", '\u1800'); 
     finalMap.put("Mongolian", '\u18AF'); 
     // initialMap.put("Old Turkic",'\u10C00'); 
     // finalMap.put("Old Turkic",'\u10C4F'); 
     // initialMap.put("Phags-Pa",'\u10C00'); 
     // finalMap.put("Phags-Pa",'\u10C4F'); 
     initialMap.put("Tibetan", '\u0F00'); 
     finalMap.put("Tibetan", '\u0FFF'); 
     // initialMap.put("Ahom",'\u11700'); 
     // finalMap.put("Ahom",'\u1173F'); 
     initialMap.put("Bengali and Assamese", '\u0980'); 
     finalMap.put("Bengali and Assamese", '\u09FF'); 
     // initialMap.put("Brahmi",'\u11000'); 
     // finalMap.put("Brahmi",'\u1107F'); 
     // initialMap.put("Chakma",'\u11100'); 
     // finalMap.put("Chakma",'\u1114F'); 
     initialMap.put("Devanagari", '\u0900'); 
     finalMap.put("Devanagari", '\u097F'); 
     initialMap.put("Devanagari Extended", '\uA8E0'); 
     finalMap.put("Devanagari Extended", '\uA8FF'); 
     // initialMap.put("Grantha",'\u11300'); 
     // finalMap.put("Grantha",'\u1137F'); 
     initialMap.put("Gujarati", '\u0A80'); 
     finalMap.put("Gujarati", '\u0AFF'); 
     initialMap.put("Gurmukhi", '\u0A05'); 
     finalMap.put("Gurmukhi", '\u0A71'); 
     // initialMap.put("Kaithi",'\u11080'); 
     // finalMap.put("Kaithi",'\u110CF'); 
     initialMap.put("Kannada", '\u0C80'); 
     finalMap.put("Kannada", '\u0CFF'); 
     // initialMap.put("Kharoshthi",'\u10A00'); 
     // finalMap.put("Kharoshthi",'\u10A5F'); 
     // initialMap.put("Khojki",'\u11200'); 
     // finalMap.put("Khojki",'\u1124F'); 
     // initialMap.put("Khudawadi",'\u112B0'); 
     // finalMap.put("Khudawadi",'\u112FF'); 
     initialMap.put("Lepcha", '\u1C00'); 
     finalMap.put("Lepcha", '\u1C4F'); 
     initialMap.put("Limbu", '\u1900'); 
     finalMap.put("Limbu", '\u194F'); 
     // initialMap.put("Mahajani",'\u11150'); 
     // finalMap.put("Mahajani",'\u1117F'); 
     initialMap.put("Malayalam", '\u0D00'); 
     finalMap.put("Malayalam", '\u0D7F'); 
     initialMap.put("Meetei Mayek", '\uABC0'); 
     finalMap.put("Meetei Mayek", '\uABFF'); 
     initialMap.put("Meetei Mayek Extensions", '\uAAE0'); 
     finalMap.put("Meetei Mayek Extensions", '\uAAFF'); 
     // initialMap.put("Modi",'\u11600'); 
     // finalMap.put("Modi",'\u1165F'); 
     // initialMap.put("Mro",'\u16A40'); 
     // finalMap.put("Mro",'\u16A6F'); 
     // initialMap.put("Multani",'\u11280'); 
     // finalMap.put("Multani",'\u112AF'); 
     initialMap.put("Ol Chiki", '\u1C50'); 
     finalMap.put("Ol Chiki", '\u1C7F'); 
     initialMap.put("Oriya (Odia)", '\u0B00'); 
     finalMap.put("Oriya (Odia)", '\u0B7F'); 
     initialMap.put("Saurashtra", '\uA880'); 
     finalMap.put("Saurashtra", '\uA8DF'); 
     // initialMap.put("Sharada",'\u11180'); 
     // finalMap.put("Sharada",'\u111DF'); 
     // initialMap.put("Siddham",'\u11580'); 
     // finalMap.put("Siddham",'\u115FF'); 
     initialMap.put("Sinhala", '\u0D80'); 
     finalMap.put("Sinhala", '\u0DFF'); 
     // initialMap.put("Sinhala Archaic Numbers",'\u111E0'); 
     // finalMap.put("Sinhala Archaic Numbers",'\u111FF'); 
     // initialMap.put("Sora Sompeng",'\u110D0'); 
     // finalMap.put("Sora Sompeng",'\u110FF'); 
     initialMap.put("Syloti Nagri", '\uA800'); 
     finalMap.put("Syloti Nagri", '\uA82F'); 
     // initialMap.put("Takri",'\u11680'); 
     // finalMap.put("Takri",'\u116CF'); 
     initialMap.put("Tamil", '\u0B80'); 
     finalMap.put("Tamil", '\u0BFF'); 
     initialMap.put("Telugu", '\u0C00'); 
     finalMap.put("Telugu", '\u0C7F'); 
     initialMap.put("Thaana", '\u0780'); 
     finalMap.put("Thaana", '\u07BF'); 
     // initialMap.put("Tirhuta",'\u11480'); 
     // finalMap.put("Tirhuta",'\u114DF'); 
     initialMap.put("Vedic Extensions", '\u1CD0'); 
     finalMap.put("Vedic Extensions", '\u1CFF'); 
     // initialMap.put("Warang Citi",'\u118A0'); 
     // finalMap.put("Warang Citi",'\u118FF'); 
     initialMap.put("Cham", '\uAA00'); 
     finalMap.put("Cham", '\uAA5F'); 
     initialMap.put("Kayah Li", '\uA900'); 
     finalMap.put("Kayah Li", '\uA92F'); 
     initialMap.put("Khmer", '\u1780'); 
     finalMap.put("Khmer", '\u17FF'); 
     initialMap.put("Khmer Symbols", '\u19E0'); 
     finalMap.put("Khmer Symbols", '\u19FF'); 
     initialMap.put("Lao", '\u0E80'); 
     finalMap.put("Lao", '\u0EFF'); 
     initialMap.put("Myanmar", '\u1000'); 
     finalMap.put("Myanmar", '\u109F'); 
     initialMap.put("Myanmar Extended-A", '\uAA60'); 
     finalMap.put("Myanmar Extended-A", '\uAA7F'); 
     initialMap.put("Myanmar Extended-B", '\uA9E0'); 
     finalMap.put("Myanmar Extended-B", '\uA9FF'); 
     initialMap.put("New Tai Lue", '\u1980'); 
     finalMap.put("New Tai Lue", '\u19DF'); 
     // initialMap.put("Pahawh Hmong",'\u16B00'); 
     // finalMap.put("Pahawh Hmong",'\u16B8F'); 
     // initialMap.put("Pau Cin Hau",'\u11AC0'); 
     // finalMap.put("Pau Cin Hau",'\u11AFF'); 
     initialMap.put("Tai Le", '\u1950'); 
     finalMap.put("Tai Le", '\u197F'); 
     initialMap.put("Tai Tham", '\u1A20'); 
     finalMap.put("Tai Tham", '\u1AAF'); 
     initialMap.put("Tai Viet", '\uAA80'); 
     finalMap.put("Tai Viet", '\uAADF'); 
     initialMap.put("Thai", '\u0E00'); 
     finalMap.put("Thai", '\u0E7F'); 
     initialMap.put("Balinese", '\u1B00'); 
     finalMap.put("Balinese", '\u1B7F'); 
     initialMap.put("Batak", '\u1BC0'); 
     finalMap.put("Batak", '\u1BFF'); 
     initialMap.put("Buginese", '\u1A00'); 
     finalMap.put("Buginese", '\u1A1F'); 
     initialMap.put("Buhid", '\u1740'); 
     finalMap.put("Buhid", '\u175F'); 
     initialMap.put("Hanunoo", '\u1720'); 
     finalMap.put("Hanunoo", '\u173F'); 
     initialMap.put("Javanese", '\uA980'); 
     finalMap.put("Javanese", '\uA9DF'); 
     initialMap.put("Rejang", '\uA930'); 
     finalMap.put("Rejang", '\uA95F'); 
     initialMap.put("Sundanese", '\uA930'); 
     finalMap.put("Sundanese", '\uA95F'); 
     initialMap.put("Sundanese Supplement", '\u1CC0'); 
     finalMap.put("Sundanese Supplement", '\u1CCF'); 
     initialMap.put("Tagalog", '\u1700'); 
     finalMap.put("Tagalog", '\u171F'); 
     initialMap.put("Tagbanwa", '\u1760'); 
     finalMap.put("Tagbanwa", '\u177F'); 
     initialMap.put("Bopomofo", '\u3100'); 
     finalMap.put("Bopomofo", '\u312F'); 
     initialMap.put("Bopomofo Extended", '\u31A0'); 
     finalMap.put("Bopomofo Extended", '\u31BF'); 
     initialMap.put("CJK Unified Ideographs (Han)", '\u4E00'); 
     finalMap.put("CJK Unified Ideographs (Han)", '\u9FFF'); 
     initialMap.put("CJK Extension-A", '\u3400'); 
     finalMap.put("CJK Extension-A", '\u4DBF'); 
     // initialMap.put("CJK Extension B",'\u20000'); 
     // finalMap.put("CJK Extension B",'\u2A6DF'); 
     // initialMap.put("CJK Extension C",'\u2A700'); 
     // finalMap.put("CJK Extension C",'\u2B73F'); 
     // initialMap.put("CJK Extension D",'\u2B740'); 
     // finalMap.put("CJK Extension D",'\u2B81F'); 
     // initialMap.put("CJK Extension E",'\u2B820'); 
     // finalMap.put("CJK Extension E",'\u2CEAF'); 
     initialMap.put("CJK Compatibility Ideographs", '\uF900'); 
     finalMap.put("CJK Compatibility Ideographs", '\uFAFF'); 
     // initialMap.put("CJK Compatibility Ideographs Supplement",'\u2F800'); 
     // finalMap.put("CJK Compatibility Ideographs Supplement",'\u2FA1F'); 
     initialMap.put("CJK Radicals/KangXi Radicals", '\u2F00'); 
     finalMap.put("CJK Radicals/KangXi Radicals", '\u2FDF'); 
     initialMap.put("CJK Radicals Supplement", '\u2E80'); 
     finalMap.put("CJK Radicals Supplement", '\u2EFF'); 
     initialMap.put("CJK Strokes", '\u31C0'); 
     finalMap.put("CJK Strokes", '\u31EF'); 
     initialMap.put("Ideographic Description Characters", '\u2FF0'); 
     finalMap.put("Ideographic Description Characters", '\u2FFF'); 
     initialMap.put("Hangul Jamo", '\u1100'); 
     finalMap.put("Hangul Jamo", '\u11FF'); 
     initialMap.put("Hangul Jamo Extended-A", '\uA960'); 
     finalMap.put("Hangul Jamo Extended-A", '\uA97F'); 
     initialMap.put("Hangul Jamo Extended-B", '\uD7B0'); 
     finalMap.put("Hangul Jamo Extended-B", '\uD7FF'); 
     initialMap.put("Hangul Compatibility Jamo", '\u3130'); 
     finalMap.put("Hangul Compatibility Jamo", '\u318F'); 
     initialMap.put("Halfwidth Jamo", '\uFFA0'); 
     finalMap.put("Halfwidth Jamo", '\uFFDC'); 
     initialMap.put("Hangul Syllables", '\uAC00'); 
     finalMap.put("Hangul Syllables", '\uD7AF'); 
     initialMap.put("Hiragana", '\u3040'); 
     finalMap.put("Hiragana", '\u309F'); 
     initialMap.put("Katakana", '\u30A0'); 
     finalMap.put("Katakana", '\u30FF'); 
     initialMap.put("Katakana Phonetic Extensions", '\u31F0'); 
     finalMap.put("Katakana Phonetic Extensions", '\u31FF'); 
     // initialMap.put("Kana Supplement",'\u1B000'); 
     // finalMap.put("Kana Supplement",'\u1B0FF'); 
     initialMap.put("Halfwidth Katakana", '\uFF65'); 
     finalMap.put("Halfwidth Katakana", '\uFF9F'); 
     initialMap.put("Kanbun", '\u3190'); 
     finalMap.put("Kanbun", '\u319F'); 
     initialMap.put("Lisu", '\uA4D0'); 
     finalMap.put("Lisu", '\uA4FF'); 
     // initialMap.put("Miao",'\u16F00'); 
     // finalMap.put("Miao",'\u16F9F'); 
     initialMap.put("Yi Syllables", '\uA000'); 
     finalMap.put("Yi Syllables", '\uA48F'); 
     initialMap.put("Yi Radicals", '\uA490'); 
     finalMap.put("Yi Radicals", '\uA4CF'); 
     initialMap.put("Cherokee", '\u13A0'); 
     finalMap.put("Cherokee", '\u13FF'); 
     initialMap.put("Cherokee Supplement", '\uAB70'); 
     finalMap.put("Cherokee Supplement", '\uABBF'); 
     // initialMap.put("Deseret",'\u10400'); 
     // finalMap.put("Deseret",'\u1044F'); 
     initialMap.put("Unified Canadian Aboriginal Syllabics", '\u1400'); 
     finalMap.put("Unified Canadian Aboriginal Syllabics", '\u167F'); 
     initialMap.put("UCAS Extended", '\u18B0'); 
     finalMap.put("UCAS Extended", '\u18FF'); 
     initialMap.put("Alphabetic Presentation Forms", '\uFB00'); 
     finalMap.put("Alphabetic Presentation Forms", '\uFB4F'); 
     initialMap.put("ASCII Characters", '\u0000'); 
     finalMap.put("ASCII Characters", '\u007F'); 
     initialMap.put("Halfwidth and Fullwidth Forms", '\uFF00'); 
     finalMap.put("Halfwidth and Fullwidth Forms", '\uFFEF'); 

     Character ab = initialMap.get(script.trim()); 
     Character b = finalMap.get(script.trim()); 
     List<Character> reqCharList = new ArrayList<Character>(); 
     if (ab != null) { 
      while (!ab.equals(b)) { 
       reqCharList.add(ab); 
       ab++; 
      } 
     } 
     return reqCharList; 
    } 
} 

Problemas conocidos de código:

1. Maneja unicodes simples (4 caracteres) solamente- Se puede extender a manejar otros caracteres Unicode también, si es necesario
2. A partir de ahora, depende del rango de caracteres rs en un script. Si se agregan pocos caracteres más tarde o están fuera de rango, el código no los cubrirá. Si algunos caracteres en un rango definido pertenecen a otros scripts, serían engañosos. Esto puede resolverse mejorando los caracteres relacionados con un script.