Cet article fouille dans les aspects plus techniques de la sécurité dans le code employé pour mettre en application une application, et fournit des directives pour développer un procédé d'application pour l'exécution bloquée. Le potentiel pour des vulnérabilités dans une application est réduit par une conception forte, mais l'exécution des joints d'application son destin. Le travail dur versé dans une conception bloquée devient sans importance si l'exécution est mal faite. Il est également important de comprendre que l'inclusion des technologies ou des méthodes de conception sécurité-connexes nécessairement n'implique ou ne garantit pas aucun niveau de sécurité dans une application. L'exécution d'une application et de n'importe quelle technologie de sécurité utilisées est l'un des composants finals qui apporte un niveau élevé de fiabilité.
L'analyse dans la phase d'exécution est la responsabilité des lotisseurs et des directeurs de développement. Les réalisateurs sont responsables de mettre en application la conception bien, tandis que les directeurs sont responsables de déterminer le processus qui assure une bonne exécution. Ceci peut être fait par l'intermédiaire des procédures normalisées qui incluent des revues documentées de développement et de normes, de conception et de code de codage, et de la formation de réalisateur en ce qui concerne la sécurité dans le développement d'application. Ces procédures bénéficient les réalisateurs et les applications indépendamment dont des langues sont employées ou le type d'application sont développés.
Les langues le plus généralement utilisées sont aujourd'hui le langage de programmation de C, le Java, et les langues scripting telles que le Perl et les coquilles d'UNIX. Chacun de ces langues et environnements peut être employé incorrectement pour compromettre la sécurité d'une application et du système sur lesquels elle fonctionne. Cependant, cet article n'est pas une liste de contrôle pour que les réalisateurs suivent. Au lieu de cela, le développement d'un processus sécurité-focalisé de pensée tient compte d'une pratique en matière discutablement plus forte de codage.
Les langages de programmation de C, qui incluent C, C++, et objet-C, sont les langues le plus généralement utilisées et peuvent être dangereux dans des mains incertaines. Ils procurent au réalisateur de manoeuvrer et accéder à beaucoup de pièces du système, telles que la mémoire, de dossiers et de dispositifs. C'est une grande force des langues de C, mais le danger surgit quand le réalisateur fait des erreurs. C fournit un niveau élevé de l'accès au logiciel d'exploitation fondamental, et il y a peu de contrôles et équilibres pour protéger le réalisateur. Si le lotisseur écrit de manière erronée des données à l'endroit faux de dispositif ou de mémoire, le programme C Fera celui que le lotisseur écrive, indépendamment des données ou de la destination.
|
|
Le premier secteur vulnérable souvent lié à C est le débordement d'amortisseur. Le code suivant d'échantillon démontre un débordement très de base :
char string[10 ] ;strcpy(string, "AAAAAAAAAAAAAAA") ; / * 15 "caractères de A"
Ici, 15 "des caractères de A" sont copiés dans la zone de mémoire pour une corde variable, qui est déclarée pour être une rangée à 10 caractères statique. La fonction de strcpy() fait exactement comme dirigé sans le respect pour la taille des données étant copiées ou de l'endroit auxquels elle va. Un débordement d'amortisseur se produit quand le 11ème élément est copié dans l'endroit de mémoire, juste après l'endroit du 10ème élément de la corde variable. Appliquez-vous maintenant ce principe à n'importe quelles données d'entrée qui viennent d'une source extérieure, remplaçant la corde des caractères de "A". Ceci permet à des attaquants de commander les effets du débordement.
La fonction de strcpy() est l'une de plusieurs fonctions en C qui n'exécutent aucune limite vérifiant et ne permettent pas aux amortisseurs arbitrairement classés d'être copiés. D'autres fonctions à éviter sont gets(), strcat(), sprintf(), et la famille de scanf() des fonctions. Il y a des versions mises à jour de certaines de ces fonctions qui laissent les longueurs copiées pour être indiqué. Ce sont strncpy(), strncat(), snprintf(), et fgets(). Ceux-ci ont modifié des fonctions copient seulement jusqu'au nombre de caractères indiqués par le paramètre de longueur. Tout au plus, des caractères de longueur sont copiés de la source dans la destination:
strncpy(destination, source, longueur) ;
Bout
En utilisant les versions de "n" du strncpy() de fonctions de la modification—de chaîne de caractères, le strncat(), le snprintf(), et le fgets()—soient sûrs que la longueur n'est pas plus grande que la corde de destination, plutôt que la corde de source. L'amortisseur peut être débordé si la valeur de longueur est plus grande que la taille de l'amortisseur de destination.
En utilisant des indicateurs aux amortisseurs, au lieu des amortisseurs statiquement avoués, vous devez assigner assez de mémoire pour stocker les valeurs étant copiées. Employez les fonctions de manipulation de mémoire, qui vous permettent d'indiquer la longueur.
Bout
En assignant la mémoire pour des données de corde, n'oubliez pas d'additionner 1 à toute la longueur, afin de s'adapter pour le caractère de terminaison NUL. Sans terminateur NUL, les données dans la mémoire directement après que le dernier caractère de la corde pourrait être considéré une partie de la corde.
Ces fonctions ne sont pas les seuls endroits où les débordements d'amortisseur se produisent. Soyez sûr de vérifier que l'information a lu, copié, ou écrit à n'importe quel endroit de mémoire ou assigné à une variable s'adaptera, ou que la destination assignée a assez d'espace mémoire.
Bout
Pour éviter des débordements d'amortisseur en votre code, soyez sûr de valider l'entrée. Vérifiez la taille des données et de l'endroit de stockage et employez les fonctions de manipulation qui produisent des quantités de l'information réalisateur-indiquées au lieu arbitrairement longtemps des gros morceaux des données.
Les états de course ajoutent un niveau de complexité à employer le code de C. Des états de course peuvent être exploités dans deux aspects de l'ordonnancement et de la protection—de création de code de C.
L'ordonnancement se rapporte à l'ordre dans lequel les événements se produisent dans une application. Les états de course peuvent résulter d'ordonnancer des variations entre les événements dépendants, quand aucune vérification n'est faite entre les événements. Ceci signifie souvent une imperfection dans toutes les routines de contrôle d'erreurs et de validation utilisées. Si deux fonctions fonctionnent normalement séquentiellement et la deuxième fonction suppose que les résultats du premier sont valides, alors la possibilité pour un état de course existe. Les privilèges élevés sont souvent des cibles d'attaque. L'organisation, combinée avec la vérification d'ordonnancement et d'erreurs, réduit au minimum la possibilité pour des états de course.
C'est une mauvaise exécution qui crée un état de course :
increase_privs() ;...valeur = special_app_function() ; / * exige * de privilèges/other_unreleted_function() ; / * n'exige pas * de privilèges/other_unreleated_function2() ; / * idem */special_dependent_function(value) ; / * exige * de privilèges/...exit() ;
Ici, un couple des pratiques peu sûres se produit. Les privilèges de l'application sont élevés tôt dans l'application, mais pas employés jusqu'à plus tard. Ils ne sont également jamais abandonnés, ainsi la plupart de fonctionnalité s'exécute avec les niveaux haut-que-nécessaires de privilège. En conclusion, l'état de course est créé par l'organisation faible—les fonctions que dépendantes ne se produisent pas près de l'un l'autre. Un exemple qui résout ces problèmes est
increase_privs() ;valeur = special_app_function ; / * exige * de privilèges/si (!validate_function(value)/* assurez la sûreté du * de valeur/{do_error_processing(value) ; / * faites quelque chose de intelligent avec * d'erreur/}special_dependent_function(value) ; / * exige * de privilèges/decrease_privs() ; / * n'ayez besoin plus du * de privilèges/other_unreleted_function() ; / * n'exige pas * de privilèges/other_unreleated_function2() ; / * idem */
Notez les routines spéciales de validation et de traitement des erreurs qui sont employées avant de passer la valeur à une autre fonction.
Bout
Organisez la fonctionnalité et combinez-l'avec la validation pour s'assurer que l'information prévue n'est pas compromise entre les événements dépendants.
Beaucoup d'états de course existent comme résultat d'utilisation faible de fichier temporaire. Quand ces dossiers sont créés, ils devraient être protégés contre l'attaque externe lors du fonctionnement. UNIX et Windows permettent au lotisseur de placer le peu de permission et les drapeaux opérationnels en créant un dossier. Permissions si rejetez l'accès à n'importe qui mais le propriétaire du processus. En créant le dossier en utilisant l'appel d'open(), placez les drapeaux d'O_EXCL et d'O_CREAT, qui font renvoyer la fonction une erreur si le dossier que vous essayez de créer déjà existe. Puisque c'est un fichier temporaire, il ne devrait pas exister avant le besoin de lui. Si le dossier existe, c'est un signe possible d'attaque. En utilisant ces méthodes, il est également important de vérifier les valeurs de retour des fonctions et de nettoyer tous les dossiers en cas des conditions d'erreur. L'exemple suivant montre que la syntaxe ouvrait un dossier—ou créer un, s'il n'existe pas déjà—avec les permissions qui permettent seulement au créateur de lire, écrivez-, et exécutez-l'employant le macro de mode de S_IRWXU.
open("filename", O_CREAT | O_EXCL | O_WRONLY, S_IRWXU) ;
L'appel échouera au cas où le dossier existerait déjà en raison du drapeau d'O_EXCL. En outre, notez le nom de fichier d'unsecure. La convention d'appellation statique utilisée augmente le risque d'attaque considérablement parce qu'un composant de l'attaque est déjà fourni.
En raison de la plus grande présence des états de course de fichier temporaire et des insécurités associées, plusieurs logiciels d'exploitation ont des fonctions spécifiques pour créer les fichiers temporaires d'une façon bloquée.
Les réalisateurs peuvent également employer les possibilités defermeture intégrées d'un logiciel d'exploitation pour commander l'accès aux dossiers. Ces méthodes commandent l'accès dans les composants fondamentaux de grain.
Bout
En utilisant les fichiers temporaires, randomisez les noms de fichier, placez les permissions fortes, et organisez la création, l'utilisation, et le déplacement des dossiers de réduire au minimum la possibilité d'attaque.
Un autre composant qui augmente la fiabilité et peut influencer la sécurité d'une application est la valeur de retour. Tandis qu'il pourrait sembler évident, il est important de soumettre à une contrainte la nécessité de valider les valeurs de retour des fonctions. Les fonctions s'exécutent souvent en série et se fondent sur les résultats ou les données d'une fonction précédente. En vérifiant la valeur de retour des fonctions précédentes, la fonction dépendante est protégée contre l'exécution avec des données inadmissibles. Même lorsque les événements ne sont pas des attaques, la récupération des conditions anormales augmente la robustesse de l'application.
Cet exemple démontre une exécution faible qui ne vérifie pas les valeurs de retour :
n = do_string_check (corde, valid_characters) ; / * la fonction renvoie * interne/si (== GOOD_RETURN de n){process_string(string) ;}
Ici, l'exécution est faible parce que la forme négative, un mauvais retour, n'est jamais manipulée. Une meilleure exécution est
n = do_string_check(string, valid_characters) ; / * la fonction renvoie * interne/si (n ! = GOOD_RETURN){special_error_processing_routine(n) ; / * la mauvaise valeur, font quelque chose */}process_string(string) ;
Le retour négatif est manipulé par la routine de traitement d'le-erreur, qui peut sortir le programme, demander une nouvelle corde, ou convertir la valeur de retour en paramètre valide. Si la valeur de retour est bonne, elle va à la routine de processus.
Bout
La création des routines réutilisables d'événement et d'erreur fournit un mécanisme standard par lequel toutes les applications réagissent à de diverses attaques et issues. Les idées pour ces routines incluent des méthodes communes de validation pour la corde et des valeurs, des fonctions d'emballage pour exécuter des contrôles d'intégrité, et des mécanismes numériques de protection qui valident des variables et des endroits de mémoire. Toujours vérifiez et traitez la valeur de retour d'une fonction.
Le prochain peu du détail comporte l'utilisation d'information sensible dans l'application, y compris des mots de passe, le chiffrage, ou n'importe quelle autre information privée. Comme mentionné précédemment, toute l'information de programme existe dans les secteurs de la piscine commune de la mémoire qui peut être sujette à la lecture et à la modification par des procédures externes. Il est salutaire de dégager la mémoire quand l'information n'est plus en service, afin d'éviter d'indiquer l'information pendant une attaque. La méthode la plus commune et la plus suffisante aux données claires, ceci désigné typiquement sous le nom mettant à zéro hors de la mémoire. Quand l'information stockée n'est nécessaire plus, les endroits de stockage devraient être recouverts avec des zéros ou des données aléatoires pour empêcher un attaquant de récupérer l'information par l'intermédiaire des vidages de mémoire ou d'mémoire. Ce procédé devient particulièrement important quand le chiffrage est en service. Les clefs chiffraient et les messages de déchiffrage sont les morceaux les plus importants d'un système cryptographique, et de tout possible de les protéger les besoins d'être fait.
Ces directives exemplifient certaines des issues communes qui surgissent dans des applications C-basées. C est très un populaire et la langue puissante qui permet fournit la grande flexibilité au réalisateur, et le soin devrait être prise avec son utilisation.
Le Perl est une bête intéressante qui combine plusieurs des avantages d'un langage de programmation structuré, comme C, avec la flexibilité et l'intégration d'une coquille d'UNIX. Le Perl permet au lotisseur de créer des procédures ou des sous-programmes, de définir des variables, et d'utiliser des applications et des commandes disponibles avec le logiciel d'exploitation. Ces possibilités, et sa force avec des expressions et analyse régulières, Perl d'élasticité une présence forte dans des applications de Web, administration de système, et automation.
Les programmes de Perl ne sont pas généralement susceptibles des débordements d'amortisseur en raison de la nature faiblement dactylographiée de ses variables et déclarations. À la différence de C, où des variables et la mémoire doivent être définies comme classe particulière de stockage et de la mémoire doit être assignée pour elles, le Perl fait tout automatiquement et traite tout comme données de corde. Prenez l'exemple suivant :
# !/path/to/perl$one = 1 ;$one_s = "1" ; # aucun différent que $one$two = $one + # ; # le résultat est 2, ou "2", qui sont équivalents
En C, le $one variable serait probablement déclaré un nombre entier et #, une corde. L'addition des deux éléments aurait également comme conséquence une valeur incorrecte. Le Perl ne différencie pas entre les différents types, ainsi $two est assigné 2, ou "2"—ils sont équivalents dans le Perl. La langue également ne tombe pas proie aux conditions d'attribution de mémoire que d'autres langues montrent. L'exemple suivant est complètement acceptable dans le Perl :
# !/path/to/perl$var1 = "AAAAA" ;$var2 = "BBBB" ;$var2 = # ; # $var2 devient "AAAAA" ;
$var2 prend la nouvelle valeur de cinq "des caractères de A". Toutes les variables sont dynamiquement assignées ; il y a aucun concept d'espace mémoire préréglé qui ne pourrait être débordé.
Le Perl est susceptible, cependant, des états de course et des vulnérabilités liées à l'exécution des programmes externes. Le soin devrait être donné à l'ordonnancement des fonctions. La validation d'entrée est également importante dans le Perl, afin d'empêcher l'exploitation des applications externes.
Le Perl soutient les possibilités pour ouvrir des dossiers, pareillement à C et à d'autres langues, donc l'utilisation des fichiers temporaires devrait incorporer des permissions appropriées et des drapeaux de création.
L'utilisation du Perl dans des programmes de cgi de Web-based est également extrêmement populaire. Les plus grands risques se sont associés à son utilisation dans cet environnement se produisent pendant la validation d'entrée et l'exécution des programmes système externes d'en dedans. Pour protéger l'application, plusieurs précautions peuvent être prises. Employer trace-vérifient des mécanismes de Perl, n'importe quel ensemble variable en dehors de du programme ne sera pas passé à n'importe quel programme exécuté par l'application. Toutes les variables ont placé par la variable corrompue deviennent corrompues. Trace-vérifiez le mode est particulièrement utile pour éviter des vulnérabilités, où des variables non réprimées d'utilisateur sont passées surreptitiously aux programmes appelés de l'application de Perl. Pour initialiser la version 5 du Perl dans trace-vérifiez le mode, emploient l'en-tête suivant de manuscrit :
# !/path/to/perl –T # fonctionnent dans trace-vérifient le mode
La prochaine précaution doit analyser des valeurs d'entrée pour enlever des métacaractères et des valeurs non désirées. Ceci aide à se protéger contre les attaques qui exploitent le paramètre-dépassement aux coquilles et à d'autres applications. L'exemple suivant montre une routine simple qui balaye une corde d'entrée pour tous les métacaractères qui pourraient être interprétés par un programme :
$unclean_input = &get_HTML_forms_response() ;if($unclean_input = ~ TR/;|`!$&*()[]{} :'"//){# copie hors d'un certain HTML indiquant ici l'échec&do_some_error_reporting() ;}
Dans ce cas-ci, la routine rapporte une erreur si un métacaractère est trouvé. Les méthodes alternatives remplacent des métacaractères, ou continuent seulement si aucun métacaractère n'est trouvé.
Une précaution finale est l'utilisation d'une coquille de courir d'autres applications. Comme avec l'appel de system() d'UNIX et l'appel d'exec() de Windows, l'appel de system() dans le Perl permet au lotisseur de courir une autre application. L'appel d'exec() dans le Perl fonctionne comme cet appel dans UNIX que—le processus courant est remplacé par le programme a indiqué. Ces fonctions peuvent être particulièrement dangereuses une fois utilisées dans les environnements qui permettent à l'utilisateur d'entrer, comme le cgi programme ou les utilités de système. Si la validation d'entrée ne se produit pas, l'application peut être exploitée pour exécuter les programmes arbitraires qui peuvent affecter le système. L'exemple suivant démontre les insécurités d'employer le system() avec nonvalidated l'entrée. Supposez que l'utilisateur a fourni le username ;/bin/rm rf –de corde/qui est devenu assigné au variable # :
system("ecommerce_app # ") ;
Ceci traduit efficacement au username d'ecommerce_app de /bin/sh ; /bin/rm –rf/. supposant que le programme fonctionne avec des privilèges, le programme exécutera une coquille pour courir l'application d'e-commerce ; frappez le point-virgule de coquille, qui est le séparateur de commande dans une coquille ; et rm alors couru –rf, qui efface le système de fichiers entier.
Java est une invention relativement récente dans le monde du calcul distribué d'Internet. Il apporte à la fructification le concept du code plateforme-indépendant. Java fonctionne à côté d'écrire le code et de le compiler dans un format spécial qui est alors couru sur les machines virtuelles de Java. La machine virtuelle (VM) est détail de plateforme, mais le code qui les courses là-dessus n'est pas. Java permet à des navigateurs de Web et à des systèmes à distance de courir des applications plus complexes et plus interactives. Le navigateur de Web accède à un emplacement de Web et reçoit un Java applet Du serveur. Cet applet alors fonctionne dans le navigateur de Web et peut communiquer avec le serveur de commencement de Web. Une fois présenté, Java a transformé les Pages Web statiques en applications dynamiques et débordantes. Depuis les jours tôt, l'utilisation de Java a augmenté dans beaucoup de différents domaines d'application distribués tels que la gestion de réseau, les appareils incorporés d'Internet, et d'autres fonctions de service.
Java est un exemple fin d'une langue dont les lotisseurs ont considéré la sécurité aux étapes préliminaires de conception. Les versions initiales de Java ont eu une architecture bien documentée de sécurité, appelée le sandbox, qui a empêché le Java applet ou l'application Des ressources de système d'accès. Pendant que l'utilisation de Java commençait à augmenter, le besoin s'est fait sentir pour l'accès aux ressources de système en dehors de du sandbox. La première version du kit de développement de Java a fourni l'utilisation des applet signés. Le modèle décrit un applet qui est digitalement signé pour vérifier son créateur. Quand la signature numérique est vérifiée, l'applet est alors fait confiance par le système local, qui permet l'accès d'applet à d'autres ressources de système. Cette méthode numérique de signature implique une quantité considérable de complexe programmant pour travailler correctement. Il est également important de noter que ce modèle de sécurité d'un Java applet Digitalement signé est défectueux. N'importe qui peut signer un applet. Un applet malveillant peut être signé par l'attaquant et être téléchargé par le navigateur de Web. Le navigateur de Web vérifie efficacement que l'applet malveillant est en effet écrit par l'attaquant, et l'exécute alors heureusement, à quelque résultat soit programmé dans lui.
L'itération courante et deuxième de l'architecture de sécurité de Java est beaucoup plus puissante et flexible que plus tôt des versions. Ceci permet à Java d'entrer dans beaucoup de domaines du développement d'application précédemment au delà de ses possibilités. La nouvelle architecture de sécurité de Java emploie facilement les politiques de sécurité et les méthodes définissables de contrôle d'accès qui permettent à un applet ou à une application d'accéder aux ressources spécifiques aux degrés variables. Par rapport aux directives a présenté ici, les concepteurs de Java ont analysé les diverses interactions et vulnérabilités avec des applications réparties d'Internet, et sont arrivés à un modèle qui fournit à la sécurité élevée la flexibilité extrême. Pour la documentation complète sur Java et son APIs, voir le http://java.sun.com.
UNIX écosse la forme la base de l'interaction d'utilisateur avec un système d'UNIX. Les coquilles sont commande-ligne interprètes qui soutiennent un certain niveau d'automation et de la programmation sous forme de manuscrits de coquille. Ces manuscrits sont souvent employés pour automatiser le système charge, effectue des opérations réitérées, et court des applications de Web de cgi. Comme avec le Perl, les secteurs du risque potentiel sont validation entrée, conditions de course, interaction avec les dossiers externes et les programmes, et l'organisation de la fonctionnalité.
Dans UNIX, des opérations privilégiées peuvent être courues par un utilisateur privilégié, ou elles peuvent être placées à la course en tant qu'utilisateur privilégié. Il y a des différences subtiles entre les deux méthodes. Tous les dossiers dans un système d'UNIX, y compris des applications, ont un ensemble d'attributs qui incluent l'utilisateur et groupent la propriété, et un ensemble de drapeaux de permissions. Combinés, ils permettent l'accès de dossier être strictement commandé. Des applications normales sont possédées par un utilisateur et, selon les autorisations d'accès, elles pourraient être courues seulement par le propriétaire, par un groupe, ou par n'importe qui sur le système. Les applications héritent des privilèges de l'utilisateur qui les court. Une application qui exige des privilèges de racine peut être courue par un utilisateur de non-racine, mais, à points où des privilèges plus élevés sont exigés, elle échouera. Pour surmonter ceci et permettre aux utilisateurs normaux d'accéder à certaines fonctions privilégiées, UNIX fournit les drapeaux de SetUID et de SetGID. Une fois permis, ils font fonctionner l'application en tant que le propriétaire ou groupe pour cette application qu'—ils ont placé l'identification de l'utilisateur (UID) de l'application à qui que ce soit que la possède.
Beaucoup de le cgi et les programmes système exigent l'accès aux ressources de système et sont racine de SetUID. Ceci s'applique aux programmes compilés, tels que des programmes C, et aux manuscrits, y compris le Perl et les coquilles d'UNIX. Les utilisateurs et les lotisseurs expérimentés d'UNIX avertissent souvent au sujet des dangers des manuscrits de coquille de SetUID qui fournissent des privilèges de racine. Comme discuté plus tôt, la validation et les états entrés de course sont facilement exploités quand le manuscrit n'est pas protégé correctement. En courant un manuscrit en tant qu'utilisateur privilégié, il n'y a aucune manière plus facile de remettre les clefs au château qu'un manuscrit de coquille faible. De tels manuscrits sont particulièrement dangereux une fois programmés sans mesures de sécurité parce qu'une coquille est interactive par la nature. L'entrée d'approvisionnement d'utilisateurs, et la coquille exécute une fonction. Le Perl a beaucoup de contrôles automatiques et équilibres qui permettent une utilisation plus sûre de SetUID.
Les appareils d'Internet sont ces systèmes et dispositifs dont le but entier est calcul d'Internet. Tous les directives de conception, considérations de langage de programmation, vulnérabilités, et paradigmes de fonctionnement sont directement appropriés aux appareils d'Internet. Les appareils d'Internet emploient souvent les logiciels d'exploitation, les applications, et les méthodes communs pour accomplir leurs buts. Si l'application à l'étude suit ce chemin, une particulière attention de salaire à toute l'information présentée ici. Quelques appareils d'Internet sont développés à partir de zéro, incorporant seulement des conceptions et des technologies nouvellement développées. L'évaluation du risque de sécurité pour ces systèmes exige la diligence supplémentaire. Il est particulièrement important d'intégrer la sécurité dans un processus de conception quand à partir de l'éraflure.
Online: 413 users browsing the articles directory
|
|