Aller au contenu

Web XML Injection

Injection XML Web

Description

Les vulnérabilités d'injection XML surviennent lorsque les entrées des utilisateurs sont intégrées de manière incorrecte dans un document XML côté serveur ou un message SOAP. L'exploitation de cette vulnérabilité implique la manipulation de métacaractères XML pour altérer potentiellement la structure XML. L'impact varie en fonction de la fonction utilisant le document XML, allant de la perturbation de la logique de l'application à des actions non autorisées ou un accès non autorisé à des données sensibles.

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.StringWriter;

public class XMLInjectionExample {

    public static void main(String[] args) {
  // Simulated user input (this should come from a user or external source)
  String userInput = "<maliciousTag>Payload</maliciousTag>";

  // Vulnerable XML construction without proper input validation
  String xmlData = "<data>" + userInput + "</data>";

  // Process the XML data (vulnerable code)
  processXmlData(xmlData);
    }

    public static void processXmlData(String xmlData) {
  try {
      // Parse the XML data
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      DocumentBuilder builder = factory.newDocumentBuilder();
      Document document = builder.parse(new org.xml.sax.InputSource(new java.io.StringReader(xmlData)));

      // Extract information from the XML (vulnerable code)
      Element root = document.getDocumentElement();
      String content = root.getTextContent();
      System.out.println("Processed XML data: " + content);
  } catch (Exception e) {
      System.err.println("Error processing XML data: " + e.getMessage());
  }
    }
}

const userInput = '<maliciousTag>Payload</maliciousTag>';

// Vulnerable XML construction without proper input validation
const xmlData = '<data>' + userInput + '</data>';

// Process the XML data (vulnerable code)
processXmlData(xmlData);

function processXmlData(xmlData) {
    try {
  // Parse the XML data
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlData, 'text/xml');

  // Extract information from the XML (vulnerable code)
  const content = xmlDoc.getElementsByTagName('data')[0].textContent;
  console.log('Processed XML data: ' + content);
    } catch (error) {
  console.error('Error processing XML data: ' + error.message);
    }
}

<?php
$userInput = '<maliciousTag>Payload</maliciousTag>';

// Vulnerable XML construction without proper input validation
$xmlData = '<data>' . $userInput . '</data>';

// Process the XML data (vulnerable code)
processXmlData($xmlData);

function processXmlData($xmlData) {
    try {
  // Create a new DOMDocument
  $doc = new DOMDocument();

  // Load the XML data
  $doc->loadXML($xmlData);

  // Extract information from the XML (vulnerable code)
  $content = $doc->getElementsByTagName('data')->item(0)->textContent;
  echo 'Processed XML data: ' . $content . PHP_EOL;
    } catch (Exception $e) {
  echo 'Error processing XML data: ' . $e->getMessage() . PHP_EOL;
    }
}
?>

Recommandation

  • Éviter la concaténation directe : Évitez de concaténer les entrées utilisateur directement dans les documents XML.
  • Assainissement des entrées utilisateur : Assainissez les entrées utilisateur avant de les insérer dans les documents XML.
  • Analyseurs XML robustes : Utilisez des analyseurs XML bien établis et sécurisés qui respectent les spécifications XML. Soyez prudent avec les analyseurs personnalisés ou obsolètes qui peuvent présenter des vulnérabilités.
  • Désactiver les fonctionnalités XML dangereuses : Si elle n'est pas nécessaire, désactivez l'expansion d'entités externes pour réduire la surface d'attaque et atténuer le risque de vulnérabilités XXE.
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.StringReader;

public class MitigatedXMLInjectionExample {

    public static void main(String[] args) {
  // Simulated user input (this should come from a user or external source)
  String userInput = "<maliciousTag>Payload</maliciousTag>";

  // Mitigated XML construction with proper input validation
  String sanitizedInput = sanitizeUserInput(userInput);
  String xmlData = "<data>" + sanitizedInput + "</data>";

  // Process the XML data (mitigated code)
  processXmlData(xmlData);
    }

    public static String sanitizeUserInput(String input) {
  // Perform proper input validation and sanitization
  // For example, you can use a library or a regex to remove invalid characters
  return input.replaceAll("[&<>\"]", "");
    }

    public static void processXmlData(String xmlData) {
  try {
      // Parse the XML data
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      DocumentBuilder builder = factory.newDocumentBuilder();
      Document document = builder.parse(new org.xml.sax.InputSource(new StringReader(xmlData)));

      // Extract information from the XML (mitigated code)
      Element root = document.getDocumentElement();
      String content = root.getTextContent();
      System.out.println("Processed XML data: " + content);
  } catch (Exception e) {
      System.err.println("Error processing XML data: " + e.getMessage());
  }
    }
}

const userInput = '<maliciousTag>Payload</maliciousTag>';

// Mitigated XML construction with proper input validation
const sanitizedInput = sanitizeUserInput(userInput);
const xmlData = '<data>' + sanitizedInput + '</data>';

// Process the XML data (mitigated code)
processXmlData(xmlData);

function sanitizeUserInput(input) {
    // Perform proper input validation and sanitization
    // For example, you can use a library like DOMPurify for HTML/XML sanitization
    // Here, we are using a simple approach to remove invalid characters
    return input.replace(/[&<>"']/g, '');
}

function processXmlData(xmlData) {
    try {
  // Parse the XML data
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlData, 'text/xml');

  // Extract information from the XML (mitigated code)
  const content = xmlDoc.getElementsByTagName('data')[0].textContent;
  console.log('Processed XML data: ' + content);
    } catch (error) {
  console.error('Error processing XML data: ' + error.message);
    }
}

<?php
$userInput = '<maliciousTag>Payload</maliciousTag>';

// Mitigated XML construction with proper input validation
$sanitizedInput = sanitizeUserInput($userInput);
$xmlData = '<data>' . $sanitizedInput . '</data>';

// Process the XML data (mitigated code)
processXmlData($xmlData);

function sanitizeUserInput($input) {
    // Perform proper input validation and sanitization
    // For example, you can use functions like htmlspecialchars to sanitize XML content
    return htmlspecialchars($input, ENT_XML1, 'UTF-8');
}

function processXmlData($xmlData) {
    try {
  // Create a new DOMDocument
  $doc = new DOMDocument();

  // Load the XML data
  $doc->loadXML($xmlData);

  // Extract information from the XML (mitigated code)
  $content = $doc->getElementsByTagName('data')->item(0)->textContent;
  echo 'Processed XML data: ' . $content . PHP_EOL;
    } catch (Exception $e) {
  echo 'Error processing XML data: ' . $e->getMessage() . PHP_EOL;
    }
}
?>

Liens

Normes

  • GDPR:
    • ART_25
    • ART_32
  • PCI_STANDARDS:
    • REQ_6_4
    • REQ_6_5
  • SOC2_CONTROLS:
    • CC_2_1
    • CC_4_1
    • CC_7_1
    • CC_7_2
    • CC_7_4
    • CC_7_5
  • HIPAA_CONTROLS:
    • SECURITY212
    • SECURITY213
    • SECURITY255