Comment puis-je m'assurer qu'une chaîne est propre pour l'insertion dans javascript Alert ('message d'erreur')

Question

J'essaie d'afficher une erreur à l'utilisateur d'une page web en utilisant un popup javascript, j'ai actuellement le code suivant pour nettoyer la chaîne d'erreur:

errorMessage.Replace("'", "\'") 

Mais cela ne suffit pas que certains caractères illégaux ne sont pas enlevés, est-il une méthode statique, quelque part dans le cadre qui forme ma chaîne pour insertion propre en html?

Mise à jour: Ma question initiale était légèrement ambiguë. la chaîne doit être valide comme dans alert ('ceci est un' texte illégal 'qui ne fera pas de popup'); Je vais essayer Server.HtmlEncode, j'espère que ça va faire l'affaire.

Answer 1

Vous voulez éviter les vulnérabilités XSS, ce qui est bien. La feuille de triche ci-dessous devrait vous aider (et contient également une référence au code pour échapper à la chaîne):

http://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet

Answer 2

Pour échapper à une chaîne pour insertion propre dans la méthode HTML, vous pouvez utiliser HttpUtility.HtmlEncode. Je ne suis pas sûr que cela vous aide avec le javascript.

http://msdn.microsoft.com/en-us/library/73z22y6h.aspx

Answer 3

Si vous avez un regard sur le module AntiXSS dans le Web Protection Library, vous constaterez qu'il a une méthode JavaScriptEncode(string) juste pour ce genre de chose.

Answer 4

Si vous utilisez ASP.NET 4, vous pouvez utiliser la nouvelle syntaxe <%:%> pour HtmlEncode la chaîne générée ET remplacer l'encodeur par défaut par AntiXSS, ou toute autre bibliothèque que vous préférez. Phil Haack explique comment faire cela dans Using AntiXss as the default encoder for ASP.NET

De cette façon, vous pouvez écrire une alerte comme ceci:

alert('<%: this.ErrorMessage %>'); 

Dans les versions précédentes, vous pouvez utiliser ce que d'autres ont suggéré, que ce soit HtmlEncode ou AntiXSS comme ceci:

alert('<%= HttpUtility.HtmlEncode(this.ErrorMessage) %>'); 

ou

alert('<%= AntiXss.HtmlEncode(this.ErrorMessage) %>'); 

Answer 5

HttpUtility.HtmlEncode ne codera pas une seule citation (') et ne convient pas à l'encodage d'une chaîne à utiliser comme message d'alerte. Personnellement, je le fais comme ceci:

public static string EscapeAlertMessage(string value) 
{ 
    value = value.Replace("\\", "\\\\"); 
    value = value.Replace("'", "\\'"); 
    value = value.Replace("\"", "\\\""); 
    return value; 
} 

Si votre message contient plusieurs lignes, vous pouvez les remplacer par « \ n » - par exemple si les lignes sont séparées par Environment.NewLine:

value = value.Replace(Environment.NewLine, "\\n"); 

Ou si vous ne savez pas ce que les séparateurs sont (\ r \ n \ n ou \ r uniquement) vous pouvez utiliser:

value = value.Replace("\r", "\\r"); 
value = value.Replace("\n", "\\n"); 

Answer 6

Merci pour l'aide mais aucune des réponses présentées m'a donné la solution complète.

La réponse de Joe était la plus proche, mais elle ne tenait pas compte de \ r \ n newline.Je ne pouvais pas trouver un moyen de traduire C# newline en un équivalent javascript.

public static string EscapeAlertMessage(string value) 
{ 
    value = value.Replace("\\", "\\\\"); 
    value = value.Replace("'", "\\'"); 
    value = value.Replace("\"", "\\\""); 
    value = value.Replace(Environment.NewLine, "--"); 

    return value; 
} 

Answer 7

Il y a une solution simple ... utiliser la DataContractJsonSerializer et "serialize" la valeur de la chaîne. En sérialisant la chaîne en JSON, vous êtes par définition en train de vous assurer que cela fonctionnera bien dans une déclaration d'alerte.

Answer 8

J'utilise la fonction suivante dans mes projets. Il escpaes tous les caractères possibles pour Javascript:

/// <summary> 
    /// Encodes a string to be represented as a string literal. The format 
    /// is essentially a JSON string. 
    /// 
    /// Example Output: Hello \"Rick\"!\r\nRock on 
    /// </summary> 
    /// <param name="s"></param> 
    /// <returns></returns> 
    public static string EncodeJsString(string s) 
    { 
     StringBuilder sb = new StringBuilder(); 
     foreach (char c in s) 
     { 
      switch (c) 
      { 
       case '\"': 
        sb.Append("\\\""); 
        break; 
       case '\\': 
        sb.Append("\\\\"); 
        break; 
       case '\b': 
        sb.Append("\\b"); 
        break; 
       case '\f': 
        sb.Append("\\f"); 
        break; 
       case '\n': 
        sb.Append("\\n"); 
        break; 
       case '\r': 
        sb.Append("\\r"); 
        break; 
       case '\t': 
        sb.Append("\\t"); 
        break; 
       case '\'': 
        sb.Append("\\'"); 
        break; 
       default: 
        int i = (int)c; 
        if (i < 32 || i > 127) 
        { 
         sb.AppendFormat("\\u{0:X04}", i); 
        } 
        else 
        { 
         sb.Append(c); 
        } 
        break; 
      } 
     } 

     return sb.ToString(); 
    }