Dove posso trovare un elenco di caratteri di escape richiesti per il mio tipo di ritorno ajax JSON?

Ho un’azione ASP.NET MVC che restituisce un object JSON.

Il JSON:

{status: "1", message:"", output:"
User generated text, so can be anything
"}

Attualmente il mio HTML lo sta violando. Ci sarà un testo generato dall’utente nel campo di output, quindi devo assicurarmi di sfuggire TUTTE le cose che devono essere sfuggite.

Qualcuno ha una lista di tutte le cose di cui ho bisogno per fuggire?

Non sto usando nessuna libreria JSON, ma costruisco la stringa da solo.

    Dai un’occhiata a http://json.org/ . Presenta una lista un po ‘diversa di personaggi sfuggiti rispetto a quelli proposti da Chris.

     \" \\ \/ \b \f \n \r \t \u four-hex-digits 

    Ecco un elenco di caratteri speciali che puoi sfuggire durante la creazione di una stringa letterale per JSON:

     \ b Backspace (codice ASCII 08)
     \ f Avanzamento pagina (codice ASCII 0C)
     \ n Nuova linea
     Ritorno a capo
     \ t Tab
     \ v scheda verticale
     \ 'Apostrofo o singola citazione
     \ "Doppia citazione
     \\ carattere barra rovesciata
    

    Riferimento: stringhe letterali

    Alcuni di questi sono più opzionali di altri. Ad esempio, la stringa dovrebbe essere perfettamente valida se si sfugge al carattere di tabulazione o se si lascia un letterale di tabulazione. Dovresti certamente maneggiare la barra rovesciata e citare i caratteri, comunque.

    Come spiegato nella sezione 9 della specifica ufficiale ECMA ( http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf ) in JSON, i seguenti caratteri devono essere sottoposti a escape:

    • U+0022 ( " , il segno di virgolette)
    • U+005C ( \ , il backslash o reverse solidus)
    • U+0000 a U+001F (i caratteri di controllo ASCII)

    Inoltre, al fine di incorporare in modo sicuro JSON in HTML, è necessario che i seguenti caratteri siano sfuggiti:

    • U+002F ( / )
    • U+0027 ( ' )
    • U+003C ( < )
    • U+003E ( > )
    • U+0026 ( & )
    • U+0085 (riga successiva)
    • U+2028 (separatore di linea)
    • U+2029 (separatore paragrafi)

    Alcuni dei caratteri precedenti possono essere sfuggiti con le seguenti sequenze di escape brevi definite nello standard:

    • \" rappresenta il carattere di virgolette (U + 0022).
    • \\ rappresenta il carattere solidus inverso (U + 005C).
    • \/ rappresenta il carattere solido (U + 002F).
    • \b rappresenta il carattere backspace (U + 0008).
    • \f rappresenta il carattere di avanzamento del modulo (U + 000C).
    • \n rappresenta il carattere di avanzamento riga (U + 000A).
    • \r rappresenta il carattere di ritorno a capo (U + 000D).
    • \t rappresenta il carattere di tabulazione del carattere (U + 0009).

    Gli altri caratteri che devono essere sfuggiti useranno la notazione \uXXXX , che è seguita dalle quattro cifre esadecimali che codificano il punto di codice.

    È ansible utilizzare \uXXXX posto della sequenza di escape breve o, facoltativamente, per sfuggire a qualsiasi altro carattere dal Basic Plilingual Plane (BMP).

    Subito, posso dire che almeno le doppie virgolette nei tag HTML saranno un problema. Questi sono probabilmente tutto ciò di cui hai bisogno per fuggire affinché sia ​​valido JSON; basta sostituire

     " 

    con

     \" 

    Per quanto riguarda l’output del testo di input dell’utente, devi assicurarti di eseguirlo tramite HttpUtility.HtmlEncode () per evitare attacchi XSS e per assicurarti che non rovini la formattazione della tua pagina.

    Dalla specifica :

    Tutti i caratteri possono essere inseriti tra virgolette, ad eccezione dei caratteri che devono essere sfuggiti: virgolette (U + 0022), reverse solidus [backslash] (U + 005C) e i caratteri di controllo da U + 0000 a U + 001F

    Solo perché ad es. Bell (U + 0007) non ha un codice di escape a carattere singolo non significa che non è necessario evitarlo. Utilizza la sequenza di escape Unicode \u0007 .

    Il riferimento JSON afferma:

      any-Unicode-caratteri-
          salvo - "- oppure - \\ - o-
          carattere di controllo
    

    Quindi elenca i codici di escape standard:

       \ "Citazione standard JSON
       \\ Backslash (escape char)
       \/ Barra
       \ b Backspace (codice ASCII 08)
       \ f Avanzamento forma (codice ascii 0C)
       \ n Newline
       Ritorno a capo
       \ t Scheda orizzontale
       \ u caratteri a quattro cifre esadecimali
    

    Da questo ho assunto che avevo bisogno di sfuggire a tutti quelli elencati e tutti gli altri sono opzionali. È ansible scegliere di codificare tutti i caratteri in \uXXXX se lo si desidera, oppure è ansible eseguire solo caratteri ASCII a 7 bit non stampabili o caratteri con valore Unicode non compreso nell’intervallo \u0020 <= x <= \u007E (32 - 126) . Preferibilmente, prima i caratteri standard per codici di escape più brevi e quindi una migliore leggibilità e prestazioni.

    Inoltre è ansible leggere il punto 2.5 (stringhe) da RFC 4627 .

    È ansible (o meno) voler (ulteriormente) sfuggire altri caratteri a seconda di dove si incorpora quella stringa JSON, ma questo è al di fuori dello scopo di questa domanda.