Quels sont les avantages d'un système de types en termes de sécurité?

Dans JavaScript: The Good Parts de Douglas Crockford, il mentionne dans son chapitre sur l'héritage,

L’autre avantage de l’héritage classique est qu’il inclut la spécification d’un système de types. Cela libère généralement le programmeur de la nécessité d’écrire des opérations de transtypage explicites, ce qui est une très bonne chose, car lors de la transposition, les avantages en matière de sécurité d’un système de types sont perdus.

Alors tout d’abord, c’est quoi la sécurité? protection contre la corruption des données, les pirates, les dysfonctionnements du système, etc.?

Quels sont les avantages d'un système de types en termes de sécurité? Qu'est-ce qui différencie un système de types lui permettant d'offrir ces avantages en matière de sécurité?

Les systèmes de types préviennent les erreurs

Les systèmes de types éliminent les programmes illégaux. Considérez le code Python suivant.

 a = 'foo'
 b = True
 c = a / b

En Python, ce programme échoue. il jette une exception. Dans un langage comme Java, C #, Haskell , peu importe, ce n'est même pas un programme légal. Vous évitez entièrement ces erreurs car elles ne sont tout simplement pas possibles dans l'ensemble des programmes d'entrée.

De même, un meilleur système de types exclut plus d'erreurs. Si nous sautons aux systèmes de types super avancés, nous pouvons dire des choses comme celle-ci:

 Definition divide x (y : {x : integer | x /= 0}) = x / y

Maintenant, le système de types garantit qu’il n’ya pas d’erreur de division par 0.

Quel genre d'erreurs

Voici une brève liste de ce que les systèmes de types d'erreur peuvent éviter

1. Erreurs hors de portée
2. Injection SQL
3. En généralisant 2, de nombreux problèmes de sécurité (à quoi sert la vérification des altérations dans Perl )
4. Erreurs hors séquence (oubli d'appeler init)
5. Forcer l'utilisation d'un sous-ensemble de valeurs (par exemple, seuls les entiers supérieurs à 0)
6. Chatons néfastes (Oui, c'était une blague)
7. Erreurs de perte de précision
8. Erreurs de mémoire logicielle transactionnelle (STM) (cela nécessite de la pureté, ce qui nécessite également des types)
9. Généraliser 8, contrôler les effets secondaires
10. Invariants sur des structures de données (un arbre binaire est-il équilibré?)
11. Oublier une exception ou jeter la mauvaise

Et rappelez-vous, ceci est également au moment de la compilation . Nul besoin d'écrire des tests avec une couverture de code à 100% pour simplement vérifier les erreurs de type, le compilateur le fait pour vous :)

Étude de cas: lambda calcul typé

Très bien, examinons le plus simple de tous les systèmes de types, simplement le lambda calcul .

Fondamentalement, il existe deux types,

Type = Unit | Type -> Type

Et tous les termes sont soit des variables, des lambdas ou des applications. Sur cette base, nous pouvons prouver que tout programme bien typé se termine. Il n'y a jamais une situation où le programme va rester bloqué ou en boucle pour toujours. Ce n'est pas prouvable dans le calcul lambda normal parce que, bien, ce n'est pas vrai.

Pensez-y, nous pouvons utiliser des systèmes de types pour garantir que notre programme ne fonctionne pas en boucle pour toujours, plutôt cool, non?

Détournez dans les types dynamiques

Les systèmes de types dynamiques peuvent offrir des garanties identiques aux systèmes de types statiques, mais au moment de l'exécution plutôt que lors de la compilation. En fait, puisque c'est le temps d'exécution, vous pouvez réellement offrir plus d'informations. Vous perdez cependant certaines garanties, en particulier concernant les propriétés statiques telles que la terminaison.

Ainsi, les types dynamiques n'excluent pas certains programmes, mais orientent plutôt les programmes mal formés vers des actions bien définies, telles que le lancement d'exceptions.

TLDR

En résumé, les systèmes de types excluent certains programmes. Beaucoup de programmes sont cassés d'une certaine manière, par conséquent, avec les systèmes de types, nous évitons ces programmes cassés.

La réalité elle-même est dactylographiée. Vous ne pouvez pas ajouter de longueurs aux poids. Et bien que vous puissiez ajouter des pieds aux mètres (les deux sont des unités de longueur), vous devez redimensionner au moins l'une des deux. Faute de quoi, votre mission sur Mars pourrait s'écraser, littéralement.

Dans un système typé, ajouter deux longueurs exprimées dans des unités différentes aurait été une erreur ou aurait provoqué une conversion automatique.

Un système de types vous aide à éviter les erreurs de codage simples, ou permet plutôt au compilateur d'attraper ces erreurs pour vous.

Par exemple, en JavaScript et en Python, le problème suivant ne sera souvent détecté qu'à l'exécution - et en fonction des tests, la qualité / rareté de la condition peut en réalité être mise en production:

if (someRareCondition)
     a = 1
else
     a = {1, 2, 3}

// 10 lines below
k = a.length

Tandis qu'un langage fortement typé vous obligera à déclarer explicitement qu'il as'agit d'un tableau et ne vous laissera pas attribuer un entier. De cette façon, il n'y a aucune chance que acela ne se produise length- même dans les cas les plus rares.

Plus tôt dans le cycle de développement logiciel vous pouvez détecter une erreur, moins il est coûteux de la réparer. Considérez une erreur qui entraîne la perte de données de votre plus gros client ou de tous vos clients. Une telle erreur pourrait être la fin de votre entreprise si elle est capturée seulement après que de vrais clients ont perdu des données! Il est clairement moins coûteux de trouver et de corriger ce bogue avant de le mettre en production.

Même pour des erreurs moins coûteuses, les testeurs sont plus actifs que les programmeurs, mais les programmeurs peuvent le trouver et le corriger. C’est moins cher s’il n’est pas vérifié dans le contrôle de source où d’autres programmeurs peuvent créer un logiciel qui en dépend. La sécurité des types empêche la compilation même de certaines classes d’erreurs, éliminant ainsi presque tout le coût potentiel de ces erreurs.

Mais ce n'est pas toute l'histoire. Comme le diront tous ceux qui programment dans un langage dynamique, il est parfois agréable de compiler votre programme afin que vous puissiez en essayer une partie sans avoir à régler tous les détails. Il y a un compromis entre sécurité et commodité. Les tests unitaires peuvent limiter le risque d'utiliser un langage dynamique, mais écrire et maintenir de bons tests unitaires a un coût qui peut être plus élevé que celui d'un langage sûr pour le type.

Si vous faites des essais, si votre code ne sera utilisé qu'une seule fois (comme un rapport ponctuel), ou si vous êtes dans une situation où vous n'auriez pas la peine d'écrire un test unitaire de toute façon, un langage dynamique est probablement parfait pour vous. Si vous avez une application volumineuse et souhaitez modifier une partie sans casser le reste, le type sécurité sauve des vies. Les types d’erreurs de type «captures de sécurité» correspondent exactement au type d’erreurs que les humains ont tendance à négliger ou à se tromper lors de la refactorisation.

introduction

La sécurité de type peut être obtenue avec des langages à type statique (compilé, vérification de type statique) et / ou à l'exécution (évalué, vérification de type dynamique). Selon Wikipedia, un système de type " fort" est décrit comme un système dans lequel aucune erreur de type d'exécution non vérifiée (ed Luca Cardelli) n'est possible. En d'autres termes, l'absence d'erreurs d'exécution non vérifiées est appelée sécurité ou type sécurité ... '

Sécurité - Vérification de type statique

Classiquement, la sécurité des types est synonyme de typage statique, dans des langages tels que C, C ++ et Haskell, conçus pour détecter les correspondances de types lors de leur compilation. Cela présente l'avantage d'éviter des conditions potentiellement indéfinies ou sujettes à erreur lors de l'exécution du programme. Cela peut être inestimable lorsqu'il existe un risque que les types de pointeurs soient mal adaptés, par exemple, une situation qui pourrait avoir des conséquences catastrophiques si elle n'est pas détectée. En ce sens, le typage statique est considéré comme synonyme de sécurité de la mémoire.

Le typage statique n'est pas complètement sûr mais améliore la sécurité , cependant. Même les systèmes statiques peuvent avoir des conséquences catastrophiques. De nombreux experts considèrent que le typage statique peut être utilisé pour écrire des systèmes (critiques) plus robustes et moins sujets aux erreurs.

Les langages à typage statique peuvent aider à réduire le risque de perte de données ou de précision dans le travail numérique, qui peut être dû à une mauvaise correspondance ou à une troncation des types double à float ou des types intégral et float.

L’utilisation de langages à typage statique présente un avantage en termes d’efficacité et de rapidité d’exécution. Le runtime bénéficie de l’absence de détermination des types lors de l’exécution.

Sécurité - Vérification du type d'exécution

Erlang, par exemple, est un type déclaratif, langage vérifié de type dynamique qui s'exécute sur une machine virtuelle. Le code Erlang peut être compilé octet. Erlang est considéré comme le plus important langage critique à la mission et tolérant aux pannes, et sa fiabilité est de neuf 9 (99,9999999%, soit au plus 31,5 ms par an).

Certaines langues, telles que Common Lisp, ne sont pas typées statiquement, mais des types peuvent être déclarés si nécessaire, ce qui peut contribuer à améliorer la vitesse et l'efficacité. Il convient également de noter que nombre des langages interprétés les plus largement utilisés, tels que Python, sont écrits sous la boucle d'évaluation dans des langages à typage statique tels que C ou C ++. Commom Lisp et Python sont tous deux considérés comme sûrs par la définition ci-dessus.

les avantages d'un système de types en termes de sécurité sont perdus.

Alors tout d’abord, c’est quoi la sécurité? protection contre la corruption des données, les pirates, les dysfonctionnements du système, etc.?

Quels sont les avantages d'un système de types en termes de sécurité? Qu'est-ce qui différencie un système de types lui permettant d'offrir ces avantages en matière de sécurité?

J'ai l'impression que les systèmes de types ont une vue si négative. Un système de types consiste davantage à donner une garantie qu'à prouver l'absence d'absence d'erreur. Ce dernier est une conséquence du système de types. Un système de types pour un langage de programmation est un moyen de produire, au moment de la compilation, la preuve qu'un programme respecte une sorte de spécification.

Le type de spécification que l'on peut encoder en tant que type dépend de la langue, ou plus directement de la puissance du système de types de la langue.

Le type de spécification le plus fondamental est une garantie sur le comportement des fonctions en entrée / sortie et sur la validité de l'intérieur d'un corps de fonction. Considérons un en-tête de fonction

f : (Int,Int) -> String

Un bon système de types s'assurera que f n'est appliqué qu'aux objets produisant une paire de Int lors de l'évaluation et garantira que f produira toujours une chaîne.

Certaines instructions dans un langage, comme les blocs if-then, n'ont pas de comportement d'entrée / sortie; Ici, le système de types garantit la validité de chaque déclaration ou instruction du bloc; c’est-à-dire applique des opérations aux objets du type correct. Ces garanties sont composables.

En outre, cela donne une sorte de condition de sécurité de la mémoire. La citation dont vous parlez concerne le casting. Dans certains cas, la conversion est correcte, comme la conversion d’un int de 32 bits en un int de 64 bits. Cependant, généralement, cela plante le système de types.

Considérer

Foo x = new Foo(3,4,5,6);
f((Int)x,(Int)x);

À cause de la conversion, x est transformé en un Int, donc techniquement, le contrôle de type ci-dessus est vérifié; Cependant, cela va vraiment à l'encontre de l'objectif de vérification de type.

Une chose qui pourrait créer un système de types différent et meilleur est de disséminer les conversions (A) x où x avant le cas correspond au type B, sauf si B est un sous-type (ou sous-objet) de A. Les notions de théorie du sous-typage ont été utilisées en sécurité pour éliminer la possibilité d'attaques de débordement / débordement d'entier.

Sommaire

Un système de types est un moyen de prouver qu'un programme répond à une sorte de spécification. Les avantages qu'un système de types peut fournir dépendent de la force du système de types utilisé.

Un avantage qui n’a pas encore été mentionné pour un système de types réside dans le fait que de nombreux programmes sont lus plus qu’ils ne sont écrits, et dans de nombreux cas, un système de types peut permettre de spécifier un grand nombre d’informations de manière concise et facile à utiliser. digéré par quelqu'un qui lit le code. Bien que les types de paramètres ne remplacent pas les commentaires descriptifs, la plupart des gens trouveront plus rapidement ce qui suit: "int Distance;" ouDistance As Int32que lire "La distance doit être un nombre entier +/- 2147483647"; Des fractions de passage peuvent donner des résultats incohérents. "En outre, les types de paramètres peuvent aider à réduire l'écart entre ce qu'une implémentation particulière d'une API fait par rapport à ce que les appelants sont autorisés à utiliser. Par exemple, si une implémentation Javascript particulière d'une API utilise ses paramètres d'une manière qui forcerait toutes les chaînes à la forme numérique, il peut être difficile de savoir si les appelants sont autorisés à compter sur un tel comportement, ou si d' autres implémentations du dysfonctionnement pourrait API si les chaînes données. avoir une méthode dont le paramètre est spécifié comme DoubleWould indiquer clairement que toutes les valeurs de chaîne doivent être forcées par l'appelant avant d'être transmises; disposer d'une méthode avec une surcharge qui accepte Doubleet une autre qui accepteString serait un peu plus clair que les appelants détenteurs de chaînes seraient autorisés à les transmettre en tant que tels.

Alors tout d’abord, c’est quoi la sécurité? Protection contre la corruption des données, les pirates, les dysfonctionnements du système, etc.?

Toutes les autres réponses et plus. En général, "sécurité du type" signifie simplement qu'aucun des programmes compilés avec succès par un compilateur ne contient d'erreur de type.

Maintenant, quelle est une erreur de type? En principe, vous pouvez spécifier toute propriété indésirable en tant qu'erreur de type, et certains systèmes de types seront en mesure de garantir de manière statique qu'aucun programme ne présente une telle erreur.

Par "propriété" ci-dessus, j'entends un type de proposition logique qui s'applique à votre programme, par exemple, "tous les index sont compris dans les limites d'un tableau". Parmi les autres types de propriétés, on peut citer "tous les pointeurs différés sont valables", "ce programme n'effectue aucune E / S" ou "ce programme n'effectue des E / S que sur / dev / null", etc. La propriété peut être spécifiée et le type vérifié de cette manière, en fonction de l’expression de votre système de typage.

Les systèmes de types dépendants font partie des systèmes de types les plus généraux, grâce auxquels vous pouvez appliquer à peu près n'importe quelle propriété de votre choix. Ce n'est pas forcément facile à faire, car les propriétés sophistiquées sont sujettes à l' incomplétude de la part de Gödel .