html_sanitizer 0.1.1

A customizable HTML sanitizer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

#![deny(missing_docs)]

//! This crate is a simple HTML sanitizer, build on top of [html5ever](https://crates.io/crates/html5ever)
//! 
//! With this crate, you can determine for every HTML tag what you want to sanitize. This is done by the [Tag](struct.Tag.html) struct that gets passed for every HTML tag.
//! 
//! ```no_run
//! use std::fs::File;
//! use html_sanitizer::TagParser;
//! 
//! fn main() {
//!     let mut file = File::open("your_html_document.html").unwrap();
//!     let mut tag_parser = TagParser::new(&mut file);
//!     let result = tag_parser.walk(|tag| {
//!         if tag.name == "html" || tag.name == "body" {
//!             // ignore <html> and <body> tags, but still parse their children
//!             tag.ignore_self();
//!         } else if tag.name == "head" || tag.name == "script" || tag.name == "style" {
//!             // Ignore <head>, <script> and <style> tags, and all their children
//!             tag.ignore_self_and_contents();
//!         } else if tag.name == "a" {
//!             // Allow specific attributes
//!             tag.allow_attribute(String::from("href"));
//!         } else if tag.name == "img" {
//!             // Completely rewrite tags and their children
//!             tag.rewrite_as(String::from("<b>Images not allowed</b>"));
//!         } else {
//!             // Allow specific attributes
//!             tag.allow_attribute(String::from("style"));
//!         }
//!     });
//!     // result contains a string of your sanitized HTML
//! }
//! ```

extern crate html5ever;

use html5ever::driver::ParseOpts;
use html5ever::parse_document;
use html5ever::rcdom::{Handle, NodeData, RcDom};
use html5ever::tendril::TendrilSink;
use html5ever::tree_builder::TreeBuilderOpts;
use std::io;

/// Create a tag parser.
/// 
/// The tag parser is responsible for parsing the tag and walking through the nodes in the HTML document.
/// 
/// ```rust
/// # use html_sanitizer::TagParser;
/// # let mut input = std::io::BufReader::<&[u8]>::new(&[]);
/// let mut parser = TagParser::new(&mut input);
/// parser.walk(|tag| {
///     // Do something with `tag` here
/// });
/// ```
pub struct TagParser {
    dom: RcDom,
}

impl TagParser {
    /// Create a new tagparser with any Read source.
    /// 
    /// Suggested read targets are `std::fs::File` and `std::io::BufReader`.
    pub fn new<A>(input: &mut A) -> Self
    where
        A: io::Read + Sized,
    {
        let opts = ParseOpts {
            tree_builder: TreeBuilderOpts {
                drop_doctype: true,
                scripting_enabled: false,
                ..Default::default()
            },
            ..Default::default()
        };
        let dom = parse_document(RcDom::default(), opts)
            .from_utf8()
            .read_from(input)
            .unwrap();
        println!("Errors: {:?}", dom.errors);

        TagParser { dom }
    }

    fn internal_walk<F>(handle: &Handle, callback: &F) -> String
    where
        F: Fn(&mut Tag),
    {
        let mut output = String::new();

        if let NodeData::Element { name, attrs, .. } = &handle.data {
            let name = &name.local;
            let attrs = attrs.borrow();
            let mut attributes = Vec::<(&str, &str)>::new();
            for attr in attrs.iter() {
                attributes.push((
                    &attr.name.local,
                    &attr.value
                ));
            }
            let mut tag = Tag::from_name_and_attrs(name, &attributes);
            callback(&mut tag);

            if tag.ignore_self && tag.ignore_contents {
                return output;
            }
            if let Some(rewrite) = tag.rewrite {
                return rewrite;
            }
            if !tag.ignore_self {
                output += "<";
                output += name;

                for attr in tag.attrs.iter() {
                    if tag.allowed_attributes.iter().any(|a| a == attr.0) {
                        output += " ";
                        output += attr.0;
                        output += "=\"";
                        output += attr.1;
                        output += "\"";
                    }
                }
                output += ">";
            }

            if !tag.ignore_contents {
                for child in handle.children.borrow().iter() {
                    output += &TagParser::internal_walk(child, callback);
                }
            }
            if !tag.ignore_self {
                output += "</";
                output += name;
                output += ">";
            }
        } else {
            match &handle.data {
                NodeData::Document => {}
                NodeData::Doctype { .. } => {}
                NodeData::Text { contents } => output += (&contents.borrow()).trim(),
                NodeData::Comment { .. } => {},
                NodeData::Element { .. } => unreachable!(),
                NodeData::ProcessingInstruction { target, contents } => println!(
                    "Unknown enum tag: NodeData::ProcessingInstruction {{ {:?} {:?} }}",
                    target, contents
                ),
            }
            for child in handle.children.borrow().iter() {
                output += &TagParser::internal_walk(child, callback);
            }
        }
        output
    }

    /// Recursively walk through all the HTML nodes, calling `callback` for each tag.
    pub fn walk<F>(&mut self, callback: F) -> String
    where
        F: Fn(&mut Tag),
    {
        TagParser::internal_walk(&self.dom.document, &callback)
    }
}

/// Represents a single HTML node. You can read the `name` and `attrs` properties to figure out what tag you're sanitizing.
/// 
/// By default all html nodes will be printed, but attributes will be stripped from a tag unless they are added with `allow_attribute` and `allow_attributes`.
pub struct Tag<'a> {
    /// The name of the HTML tag, e.g. 'div', 'img', etc.
    pub name: &'a str,

    /// The attributes of the HTML tag, e.g. ('style', 'width: 100%').
    pub attrs: &'a [(&'a str, &'a str)],
    rewrite: Option<String>,
    allowed_attributes: Vec<String>,
    ignore_self: bool,
    ignore_contents: bool,
}

impl<'a> Tag<'a> {
    fn from_name_and_attrs(name: &'a str, attrs: &'a [(&'a str, &'a str)]) -> Tag<'a> {
        Tag {
            name,
            attrs,
            rewrite: None,
            allowed_attributes: Vec::new(),
            ignore_self: false,
            ignore_contents: false,
        }
    }

    /// Allow the given attribute. This attribute does not have to exist in the `attrs` tag.
    /// 
    /// When this HTML node gets printed, this attribute will also get printed.
    pub fn allow_attribute(&mut self, attr: String) {
        self.allowed_attributes.push(attr);
    }

    /// Allow the given attributes. These attributes do not have to exist in the `attrs` tag.
    /// 
    /// When this HTML node gets printed, these attributes will also get printed.
    pub fn allow_attributes(&mut self, attr: &[String]) {
        self.allowed_attributes.reserve(attr.len());
        for attr in attr {
            self.allowed_attributes.push(attr.clone());
        }
    }

    /// Ignore this tag. This means that the HTML Node will not be printed in the output. In addition, all the child nodes and text content will also not be printed.
    pub fn ignore_self_and_contents(&mut self){
        self.ignore_self = true;
        self.ignore_contents = true;
    }

    /// Ignore this tag. This means that the HTML Node will not be printed in the output. All child nodes and text content will be printed.
    pub fn ignore_self(&mut self){
        self.ignore_self = true;
    }

    /// Completely rewrite this tag and all it's children, replacing them by the custom string that is passed to this function.
    pub fn rewrite_as(&mut self, new_contents: String) {
        self.rewrite = Some(new_contents);
    }
}