Fonctions de validation et d'assainissement

Chaque application web a la même vulnérabilité : les entrées utilisateur. Un champ de formulaire qui attend une adresse e-mail reçoit une injection JavaScript. Une barre de recherche qui attend du texte reçoit une requête SQL. Un champ de commentaire qui attend des mots reçoit une balise <script>. La seule défense est la validation (rejeter les entrées invalides) et l'assainissement (neutraliser les entrées dangereuses).

Dans la plupart des langages, cette défense nécessite l'installation de packages. validator pour JavaScript. django.core.validators pour Python. govalidator pour Go. Chaque package a sa propre API, ses propres cas limites et ses propres vulnérabilités. En FLIN, la validation et l'assainissement sont intégrés dans le langage. Les Sessions 131 et 190 à 192 ont ajouté 67 fonctions qui couvrent chaque besoin de validation et d'assainissement d'une application web.

Les deux lignes de défense

FLIN sépare la validation (vérifier si l'entrée est valide) de l'assainissement (rendre l'entrée sûre). Les deux sont nécessaires.

flin// Validation : cette entrée est-elle acceptable ?
email = "[email protected]"
email.is_email              // true -- l'accepter

// Assainissement : rendre cette entrée sûre pour l'affichage
comment = "<script>alert('xss')</script>Hello!"
safe = sanitize_html(comment)
// "Hello!" -- la balise script est supprimée

Fonctions de validation

flintext.is_email              // Vérification e-mail RFC 5322 simplifiée
text.is_url                // URL valide avec protocole
text.is_ip                 // Adresse IPv4 ou IPv6
text.is_uuid               // Format UUID v4
text.is_json               // Chaîne JSON valide
text.is_numeric            // Tous des chiffres (0-9)
text.is_alpha              // Toutes des lettres (a-z, A-Z)
text.is_phone              // Format de numéro de téléphone international
text.is_credit_card        // Numéro de carte de crédit (vérification Luhn)

Fonctions d'assainissement

flin// Niveau 1 : Échapper les entités HTML
html_escape("<script>alert('xss')</script>")
// "&lt;script&gt;alert('xss')&lt;/script&gt;"

// Niveau 2 : Supprimer toutes les balises HTML
strip_tags("<b>Hello</b> <script>evil()</script> World")
// "Hello  World"

// Niveau 3 : Assainir le HTML (garder les balises sûres)
sanitize_html("<b>Bold</b> <script>evil()</script> <a href='url'>Link</a>")
// "<b>Bold</b>  <a href='url'>Link</a>"

// Prévention d'injection SQL
safe = escape_sql("Robert'; DROP TABLE users; --")
// "Robert''; DROP TABLE users; --"

// Encodage URL
url_encode("hello world & more")
// "hello%20world%20%26%20more"

Validation au niveau des entités

Le système d'entités de FLIN intègre la validation au niveau du schéma en utilisant les contraintes where :

flinentity Product {
    name: text where len >= 1 and len <= 200
    description: text where len <= 5000
    price: float where > 0
    sku: text where matches("^[A-Z]{2}-\\d{4}$")
    email: text where is_email
    url: text? where is_url
    category: text where in ["electronics", "clothing", "food", "other"]
}

Ces contraintes sont vérifiées automatiquement lors des opérations create et update. Si une contrainte échoue, l'opération retourne une erreur avec un message descriptif.

Soixante-sept fonctions, zéro vulnérabilité

L'API complète de validation et d'assainissement :

• 15 validateurs de format (e-mail, URL, IP, UUID, téléphone, carte de crédit, etc.)
• 5 validateurs de contenu (numérique, alpha, alphanumérique, vide, blanc)
• 6 validateurs de longueur/plage
• 1 validateur de pattern (matches)
• 3 assainisseurs HTML (html_escape, strip_tags, sanitize_html)
• 2 assainisseurs SQL (escape_sql, escape_sql_like)
• 2 encodeurs URL (url_encode, url_decode)
• 2 assainisseurs de chemin (sanitize_path, path_within)
• 2 codeurs base64 (base64_encode, base64_decode)
• 28 mots-clés de contrainte d'entité (where, in, between, matches, etc.)

Soixante-sept fonctions qui remplacent validator, sanitize-html, xss, dompurify, express-validator et une douzaine d'autres packages liés à la sécurité.

Ceci est la partie 79 de la série "How We Built FLIN", documentant comment un CEO à Abidjan et un CTO IA ont construit la validation et l'assainissement des entrées directement dans un langage de programmation.

Navigation de la série : - [78] Reduce, Map, Filter: Higher-Order Functions - [79] Validation and Sanitization Functions (vous êtes ici) - [80] Error Tracking and Performance Monitoring - [81] FlinUI: Zero-Import Component System