Come posso generare una password casuale nella lingua di un utente?

Question

La mia applicazione deve essere conforme a I18N. Uno dei requisiti è che la password iniziale che ho generato dovrebbe essere nella lingua scelta dall'utente. Quali API in Java posso utilizzare per ottenere questo risultato? Ho la lingua dell'utente e avrò bisogno di ottenere alcuni caratteri casuali dal set unicode di quella lingua.

Modifica: Grazie per le risposte finora. Alcuni chiarimenti: questo è per un'applicazione basata sul web. Per motivi di sicurezza, non possiamo mantenere una scorta di caratteri/parole in lingue diverse.

Modifica 2: In risposta ai commenti e alcune risposte: Questa applicazione verrà distribuita in varie aree geografiche & Non voglio che debbano lavorare per impostare le password in qualsiasi lingua distribuisca. Quella e la sicurezza sono le ragioni per cui non ho ancora accettato la risposta più popolare.

Answer 1

Mentre non sono sicuro che l'impostazione di una password predefinita è un'azione desiderabile (le persone spesso non sanno come cambiarlo e poi lo dimenticano) se lo facessi, otterrei un carico di liste di parole in varie lingue e scegli forse due parole a caso, concatena e usa quella come password.

Significa che dovrete fare un po 'di lavoro per trovare le liste di parole ma dovrebbe essere una procedura abbastanza semplice una volta che li avrete.

Modifica: se si creano stringhe casuali, è molto più semplice: è sufficiente memorizzare un file di caratteri disponibili per ciascuna lingua. Apri quello giusto quando arrivi a generare e poi scegli lettere casuali. Bish bash bosh. Fatto.

Modifica 2: come ha correttamente commentato Marcelo, è possibile incontrare il problema di generare password oscena per l'utente. Potrebbe anche valere la pena di mantenere stringhe localizzate nella blacklist per verificare la password. Se una qualsiasi delle stringhe appare nella password (solo in esso, non nel suo complesso), genera una password diversa. Questo significa che non genererai mai una password abbastanza innocente come scunthorpe ma significa che non otterrai neanche cose come lo assclown.

Come avrete capito, questo sta cominciando a sembrare un sacco di lavoro:

• ottenere tutti i caratteri validi per ogni lingua si prevede di supportare
• ottenere tutti le parole oscene per ogni lingua si prevede di supportare
• generare una password sulla base delle lettere
• controllare nessuno di essi contengono una parolaccia
• Ricordate che alcuni parole oscene sono adottate da altre lingue, ma mi non sono presenti su blacklist specifiche della lingua, quindi mantieni una lista nera internazionale.

Si potrebbe scoprire che l'impostazione di un pass frase utilizzando note parole puliti da ogni lingua (per la mia risposta originale) funziona meglio.

Se tutto ciò sembra troppo stressante, potrebbe essere meglio rimandare il motivo per l'impostazione di una password casuale in primo luogo. Se si tratta di un dispositivo di verifica della posta elettronica, esistono altri metodi più semplici da utilizzare. Ad esempio: l'invio di un collegamento unico a essere cliccato

---

Edit: numeri sarebbe d'accordo?Si tratta di un molto più sicuro, non hanno bisogno di pettinatura, sono internazionali e può essere abbastanza a lungo per essere unico, sono solo raramente memorabile. Se sono lavori one-off di copia e incolla, dovrebbero farti bene.

Se avete bisogno di loro di essere breve, ma molto singolare (e bisogno di un sacco) forse mescolando numeri con le lettere in schemi prevedibili come (a = lettera, n = numero) annn-annn dà 676,000,000 combinazioni. Anche cose semplici come annn danno abbastanza per non essere indovinato (26000 combo) se non hanno bisogno di essere uniche ... Se queste sono password, non c'è niente di sbagliato con due sono uguali.

Answer 2

Se si desidera avere parole significative in ogni lingua, è possibile utilizzare un insieme di parole in inglese tradotto (tramite google traduttore per esempio).

Quindi puoi avvolgerli con numeri e caratteri speciali per la password.

E, naturalmente, al tuo posto, vorrei chiedere all'utente di modificare immediatamente qualsiasi password iniziale che fornisci a qualcosa di sua scelta.

Answer 3

Unicode Character Database e Unicode Common Locale Repository di dati contiene molte informazioni su lingue e script. È possibile accedere alle informazioni utilizzando, ad esempio, IBM ICU (una libreria I18N/L10N più completa delle impostazioni locali di Java).

In particolare, è possibile ottenere una serie di personaggi esemplari, utilizzando LocaleData.getExemplarSet. Si noti tuttavia che il CLDR è lontano per il completamento, è necessario aspettarsi dati mancanti.

Answer 4

Dai un'occhiata alla http://thedailywtf.com/Articles/The-Automated-Curse-Generator.aspx in cui è descritto qualcosa di simile. le parole chiave da cercare sembrano essere "catene markov".

Modifica: appena notato che dan04 già menzionato quel collegamento.

Answer 5

Il JDK include i nomi dei paesi di visualizzazione, la lingua di visualizzazione e il testo visualizzato per ogni locale, memorizzati in tutte le impostazioni locali disponibili. È possibile utilizzarlo per creare un set di caratteri iniziale per ogni locale e utilizzare Character.toUpperCaseCharacter.toLowerCase per ottenere anche varianti di caso.

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

Mentre questo non elenca in modo esauriente ogni singolo carattere possibile, l'intento è che elenca quelli che sono comunemente utilizzati.

Answer 6

1. Utilizzare un dizionario latino con selezione di parole casuali in CammelCase fino a della lunghezza desiderata.
2. Se si desidera ottenere la fantasia Unicode, provare lo UN UDHR. Basta grattalo con un po 'di regex. A causa della dimensione del dizionario minore potresti avere bisogno di password più lunghe, ma a chi importa.

Answer 7

Forse questo suona un po 'complicato. Ma puoi tenere un sacco di parole in un database. E traducili con qualche strumento di traduzione nella lingua dell'utente. (Forse Google, ma non so se Google lo consente)
Un po 'come fa reCHAPTA. Hanno un sacco di tekst (come Lorem Ipsum) dove scelgono due parole.

È possibile combinare due o tre parole (con una lunghezza massima) con un numero. Forse con il simbolo del loro paese di fronte. Così si ottiene cose come:

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

Answer 8

forse u può creare una parola inglese, e tradurlo con google tradurlo

Answer 9

Questa è una domanda davvero interessante che mi ha fatto riflettere, e ho immerso le mie mani nella terra. Qui è il mio processo di pensiero

1. Prendi il locale (in genere standard per la condivisione di lingua, facoltativo se avete la lingua già) lingua
2. ottenere dal locale
3. Ottenere script per la lingua
4. ottenere i caratteri (caratteri unicode) per lo script
5. Genera password casuale.
6. Facoltativamente, il tempo-avvolgere il processo

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

Problemi noti con il codice:

1. Gestisce unicodes semplici (4 caratteri) solo- Si può essere estesa a gestire anche altri caratteri Unicode, se necessario
2. A partire da ora, dipende dalla gamma di caratteri rs in una sceneggiatura. Se alcuni caratteri vengono aggiunti in seguito, o se non rientrano nell'intervallo, il codice non li coprirà. Se alcuni personaggi nell'intervallo definito appartengono ad altri script, sarebbero fuorvianti. Questo può essere risolto migliorando i caratteri relativi a uno script.