OWASP Java HTML Sanitizer

Java में लिखा गया एक तेज़ और आसानी से कॉन्फ़िगर होने वाला HTML Sanitizer जो आपको अपने वेब एप्लिकेशन में तीसरे पक्ष द्वारा लिखे गए HTML को शामिल करने देता है, साथ ही XSS से सुरक्षा प्रदान करता है।

sanitizer JAR की कोई रनटाइम निर्भरता नहीं है। इसकी एकमात्र कंपाइल-टाइम निर्भरता spotbugs-annotations है (provided scope, केवल annotations); अन्य jars की आवश्यकता केवल टेस्ट सूट को होती है।

यह कोड सुरक्षा संबंधी सर्वोत्तम प्रथाओं को ध्यान में रखते हुए लिखा गया है, इसका एक व्यापक टेस्ट सूट है, और इसने adversarial security review से गुज़रा है।

शुरुआत करना

शुरुआत करना में Maven के साथ या उसके बिना शुरुआत करने के निर्देश शामिल हैं।

रिपॉज़िटरी लेआउट

बिल्ड करने के लिए JDK 11 या नया आवश्यक है। रिपॉज़िटरी रूट से, सभी Maven मॉड्यूल बिल्ड करें और उनके टेस्ट चलाएँ:

./mvnw clean verify

Maven wrapper आवश्यक Maven संस्करण को पिन करता है। यदि आप -pl के साथ कोई मॉड्यूल चुनते हैं, तो -am का भी उपयोग करें ताकि Maven उन मॉड्यूल्स को बनाए जिन पर यह निर्भर करता है।

owasp-java-html-sanitizer/ में प्रकाशित लाइब्रेरी, उसके परीक्षण, और उसका Java मॉड्यूल डिस्क्रिप्टर शामिल हैं।
java8-shim/ और java10-shim/ उस संगतता कोड को लागू करते हैं जो लाइब्रेरी JAR में बंडल किया गया है।
examples/ में पढ़ने और कॉपी करने के लिए नमूना नीतियाँ शामिल हैं; इसका परीक्षण किया जाता है लेकिन इसे प्रकाशित नहीं किया जाता।
empiricism/ में sanitizer की HTML एलिमेंट तालिकाओं को उत्पन्न करने के लिए उपयोग किए गए ब्राउज़र प्रयोग शामिल हैं।
docs/ में उपयोगकर्ता, सुरक्षा, और ऐतिहासिक दस्तावेज़ीकरण शामिल हैं।

पूर्व-पैकेज्ड नीतियाँ

आप पूर्व-पैकेज्ड नीतियाँ उपयोग कर सकते हैं:

PolicyFactory policy = Sanitizers.FORMATTING.and(Sanitizers.LINKS);
String safeHTML = policy.sanitize(untrustedHTML);

एक नीति तैयार करना

tests दिखाते हैं कि अपनी स्वयं की policy को कैसे कॉन्फ़िगर करें:

PolicyFactory policy = new HtmlPolicyBuilder()
    .allowElements("a")
    .allowUrlProtocols("https")
    .allowAttributes("href").onElements("a")
    .requireRelNofollowOnLinks()
    .toFactory();
String safeHTML = policy.sanitize(untrustedHTML);

कस्टम नीतियाँ

आप कस्टम नीतियाँ लिख सकते हैं ताकि आप h1s को एक निश्चित क्लास वाले divs में बदलने जैसे काम कर सकें:

PolicyFactory policy = new HtmlPolicyBuilder()
    .allowElements("p")
    .allowElements(
        (String elementName, List<String> attrs) -> {
          // Add a class attribute.
          attrs.add("class");
          attrs.add("header-" + elementName);
          // Return elementName to include, null to drop.
          return "div";
        }, "h1", "h2", "h3", "h4", "h5", "h6")
    .toFactory();
String safeHTML = policy.sanitize(untrustedHTML);

कृपया ध्यान दें कि तत्वों "a", "font", "img", "input" और "span" को स्पष्ट रूप से allowWithoutAttributes() विधि का उपयोग करके श्वेतसूचीबद्ध करने की आवश्यकता है यदि आप चाहते हैं कि इन तत्वों में कोई विशेषता शामिल न होने पर भी इन्हें फ़िल्टर से गुज़रने की अनुमति मिले।

विशेषता नीतियाँ कस्टम कोड चलाने की भी अनुमति देती हैं। एक विशेषता नीति जोड़ने से style या URL विशेषता जाँच जैसी किसी भी डिफ़ॉल्ट नीति कमज़ोर नहीं होगी।

PolicyFactory myPolicy = new HtmlPolicyBuilder()
    .allowElements("div", "span")
    .allowAttributes("data-foo")
        .matching(
            (String elementName, String attributeName, String value) -> {
              // Return value for the attribute or null to drop.
              return value;
            })
        .onElements("div", "span")
    .toFactory();

प्रीप्रोसेसर

प्रीप्रोसेसर टेक्स्ट सम्मिलित करने और बड़े पैमाने पर संरचनात्मक परिवर्तन करने की अनुमति देते हैं।

PolicyFactory myPolicy = new HtmlPolicyBuilder()
    .withPreprocessor(
        (HtmlStreamEventReceiver r) -> {
          // Provide user with info about links before they click.
          // Before:                       <a href="https://example.com/...">
          // After:  (https://example.com) <a href="https://example.com/...">
          return new HtmlStreamEventReceiverWrapper(r) {
            @Override public void openTag(String elementName, List<String> attrs) {
              if ("a".equals(elementName)) {
                for (int i = 0, n = attrs.size(); i < n; i += 2) {
                  if ("href".equals(attrs.get(i))) {
                    String url = attrs.get(i + 1);
                    String origin;
                    try {
                      URI uri = new URI(url);
                      String scheme = uri.getScheme();
                      String authority = uri.getRawAuthority();
                      if (scheme == null && authority == null) {
                        origin = null;
                      } else {
                        origin = (scheme != null ? scheme + ":" : "")
                               + (authority != null ? "//" + authority : "");
                      }
                    } catch (URISyntaxException ex) {
                      origin = "about:invalid";
                    }
                    if (origin != null) {
                      text(" (" + origin + ") ");
                    }
                  }
                }
              }
              super.openTag(elementName, attrs);
            }
          };
        })
     .allowElements("a")
     .allowAttributes("href").onElements("a")
     .allowStandardUrlProtocols()
    ...
    .toFactory();

पॉलिसी लागू होने से पहले प्रीप्रोसेसिंग होती है, इसलिए यह आउटपुट की सुरक्षा को प्रभावित नहीं कर सकती।

टेलीमेट्री

जब कोई पॉलिसी किसी एलिमेंट या एट्रिब्यूट को अस्वीकार करती है, तो यह एक HtmlChangeListener को सूचित करती है।

java-html-sanitizer v20260921.1