Java équivalent pour PHP mysql_real_escape_string()
Est-il un Java équivalent à PHP mysql_real_escape_string() ?
C'est pour échapper à l'injection SQL tentatives avant de les transmettre à l'état.execute().
Je sais que je peux utiliser PreparedStatement au lieu de cela, mais supposons que ce sont des one shot pour la préparation, vous aurez une baisse de rendement. J'ai déjà changé le code pour utiliser PreparedStatement, mais étant donné la manière dont le code existant a été structurée, une fonction escape() rendrait le code des changements beaucoup plus simples à l'examen et à entretenir; je préfère facile pour la maintenance du code, sauf s'il existe une raison impérieuse pour la supplémentaire de complexité. Aussi PreparedStatements sont traités différemment par la base de données, ce qui pourrait nous exposer à des bugs dans la base de données que nous n'avons pas rencontré avant, exigeant plus de tests avant de le relâcher à la production.
Apache StringEscapeUtils escapeSQL() s'échappe uniquement des guillemets simples.
Postscript:
Il y a beaucoup de subtilités dans l'environnement, j'ai hérité que j'ai délibérément évité dans ma question.
Deux points à considérer:
1) les requêtes Préparées ne sont pas une panacée et ne fournissent pas une protection à 100% contre les injections SQL. Certains pilotes de base de données à instancier de paramétrer des requêtes à l'aide dangereux de concaténation de chaîne, plutôt que de pré-compilation de la requête à une forme binaire. Aussi, si votre SQL s'appuie sur des procédures stockées, vous devez vous assurer que les procédures stockées ne sont pas eux-mêmes de créer des requêtes de manière non sécurisée.
2) la Plupart de l'instruction préparée de mise en œuvre de lier l'état de la connexion à la base de la déclaration a été instancié. Si vous utilisez la connexion de base de données de mise en commun, vous avez besoin d'être prudent afin d'
utiliser l'instruction préparée référence uniquement à la connexion, il a été préparé. Certains mécanismes de mise en commun de ne mettre en œuvre ce de manière transparente. Sinon, vous pourriez piscine les déclarations préparées ou (plus simple, mais plus de surcharge) créer une nouvelle instruction préparée pour chaque requête.
Compte tenu de la façon dont le code existant (que je n'ai pas l'écrire), c'est, oui, il serait plus facile à maintenir.
la baisse de rendement peut être plus attrayant que le risque de sécurité. la sécurité de la pénalité peut juste être trop élevé. Préparez vos déclarations dans la demande de l'initialisation du code et de la peine ne peut être sensible (dépend de l'application, bien sûr).
OriginalL'auteur Kieran Tully | 2009-06-19
Vous devez vous connecter pour publier un commentaire.
Autant que je sache, il n'y a pas de "standard" à la façon de le faire.
Je vous suggérons d'utiliser les requêtes préparées en dépit de vos préoccupations actuelles. L'impact de la performance va être négligeable -, nous avons une situation similaire avec plusieurs milliers d'instructions par seconde - pour la plupart des one-shots.
La sécurité de gain doit être pesé beaucoup plus élevé qu'un problème de performances vous n'avez même pas encore vu. À mon avis, c'est une situation claire de "Ne pas optimiser prématurément".
En aucun cas devriez-vous vraiment découvrir plus tard que vous rencontrez des problèmes de performances, assurez-vous que les requêtes préparées sont vraiment la cause par le profilage attentivement, puis chercher des alternatives. Jusqu'alors vous devriez vous épargner les tracas d'essayer d'obtenir la trajectoire de la droite.
Cela est encore plus important que je en déduire que vous développez une sorte de site internet - applications internes sont rarement suffisamment de trafic à être préoccupés par la performance de toute façon.
Vous êtes les bienvenus 🙂
OriginalL'auteur
Voici un code qui permet d'obtenir ce que vous cherchez. À l'origine, sur la Vnet de l'Édition du wiki.
https://web.archive.org/web/20131202082741/http://wiki.vnetpublishing.com/Java_Mysql_Real_Escape_String
le code vérifie si il y a des dangereux caractères dans une chaîne. Si ce n'est pas que la chaîne est retournée sans traitement. Le code vérifie ensuite si s'échapper de la chaîne supprime normalement tout peut-être dangereux personnages. Si de sorte que la chaîne est renvoyée dans l'échappé de la forme. Enfin, l'échappé de la chaîne est envoyée à MySQL être échappés par la fonction de CITATION qui est spécifiquement conçu pour échapper à cordes.
le lien ne fonctionne plus
V. H. désolé, le site a été inaccessible pendant un certain temps donc je l'ai posté le code d'origine à la place.
OriginalL'auteur
Ne présumez pas que PreparedStatements sont plus lents. L'essayer, de le mesurer, et ensuite d'en juger.
PreparedStatements devrait toujours être utilisé de préférence à l'état, à peu près sans exception, surtout lorsque les attaques par injection SQL sont ce que vous essayez d'éviter.
OriginalL'auteur
La seule façon raisonnable d'éviter l'injection SQL consiste à utiliser préparé/des instructions paramétrées.
Par exemple le PreparedStatement que vous essayez d'éviter, pour une raison quelconque. Si vous ne one-shot déclarations, le temps devrait être négligeable ("one-shot" et "la performance est critique" est une contradiction, à mon humble avis). Si vous faites les choses dans une boucle, les instructions préparées même causer des performances à la hausse.
OriginalL'auteur
org.apache.commons.lang.StringEscapeUtils.class dans commons-lang.jar pourrait résoudre votre problème!
OriginalL'auteur
Selon Daniel Schneller, il n'existe pas de méthode standard pour traiter de PHP mysql_real_escape_string() en Java
Ce que j'ai fait était de la chaîne d'replaceAll méthode pour gérer tous les aspects qui peuvent être nécessaires pour éviter toute exception à la règle. Voici mon exemple de code:
public void saveExtractedText(String group,String content)
{
try {
content = content.replaceAll("\\", "\\\\")
.replaceAll("\n","\\n")
.replaceAll("\r", "\\r")
.replaceAll("\t", "\\t")
.replaceAll("\00", "\\0")
.replaceAll("'", "\\'")
.replaceAll("\\"", "\\\"");
OriginalL'auteur