diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml
index 1927456..c192e99 100644
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -76,7 +76,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
 
     steps:
       - uses: actions/checkout@v4
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index c829e02..4ec540e 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -15,7 +15,7 @@ jobs:
     strategy:
       fail-fast: false # IMPORTANT: run all Python versions even if one fails
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
 
     steps:
     - uses: actions/checkout@v4
@@ -34,7 +34,7 @@ jobs:
         ruff check . --output-format=concise
     - name: Run tests
       run: |
-        python -m pytest
+        python -m pytest -n auto --dist loadscope
     - name: Upload test.docx
       uses: actions/upload-artifact@v4
       with:
diff --git a/HISTORY.rst b/HISTORY.rst
index 63898ed..c07f8f7 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -3,17 +3,38 @@
 Release History
 ---------------
 
-1.3.0 (2026-xx-xx)
+1.3.0 (unreleased)
 ++++++++++++++++++
 
+**Security**
+
+- Fixed SSRF (CWE-918) and arbitrary local file read (CWE-73 / CWE-22) when converting untrusted HTML through ``<img src>`` and ``<link rel="stylesheet" href>``. All versions up to and including 1.2.1 are affected. See `GHSA-xh3w-67hm-58x9 <https://github.com/dfop02/html4docx/security/advisories/GHSA-xh3w-67hm-58x9>`_ . | `dfop02 <https://github.com/dfop02>`_
+
+  - Remote fetches are restricted to ``http`` and ``https``. ``file://``, ``ftp://`` and other schemes are refused, including through redirects.
+  - Connections to non-public IPs (loopback, private, link-local/cloud metadata, reserved, multicast) are refused. The check runs on the connected IP for every redirect hop, which also prevents DNS rebinding.
+  - Local files are confined to ``local-files-root``, with ``..`` and symlinks resolved first.
+  - Each resource is capped at ``max-resource-bytes``.
+
+**Breaking changes**
+
+- Local files (paths and ``file://``) are disabled by default. Set ``parser.options['local-files-root']`` to the directory that may be read. Relative paths are now resolved against it instead of the current working directory.
+- Resources on private network addresses (e.g. intranet servers) are blocked by default. Add them to ``parser.options['private-network-allowlist']``.
+- ``HTTP_PROXY`` / ``HTTPS_PROXY`` environment variables are no longer honored when fetching remote resources.
+
 **Updates**
-- None
+
+- Resource fetching moved from ``html4docx.utils`` to the new ``html4docx.resources`` module. ``utils.fetch_image``, ``utils.fetch_image_data`` and ``utils.fetch_external_css`` are still importable for backward compatibility and accept an optional ``policy`` argument. | `dfop02 <https://github.com/dfop02>`_
+- README: options reorganized, new external resources security and migration sections, and outdated examples fixed. | `dfop02 <https://github.com/dfop02>`_
+- Add ``pytest-xdist`` to ``pyproject.toml`` and ``requirements_test.txt`` to speed up tests on CI. | `dfop02 <https://github.com/dfop02>`_
+- Add Python 3.15 to the CI tests matrix and add 3.15 to the package classifiers. | `dfop02 <https://github.com/dfop02>`_
 
 **Fixes**
-- None
+
+- Malformed ``data:image`` URIs no longer raise an exception; the image is skipped and a warning is logged. | `dfop02 <https://github.com/dfop02>`_
 
 **New Features**
-- None
+
+- New options: ``allow-remote-resources``, ``allow-private-network``, ``private-network-allowlist``, ``local-files-root`` and ``max-resource-bytes``. | `dfop02 <https://github.com/dfop02>`_
 
 1.2.1 (2026-10-19)
 ++++++++++++++++++
diff --git a/README.md b/README.md
index 56efd92..6c36925 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,9 @@
 ![Version](https://img.shields.io/pypi/v/html-for-docx.svg)
 ![Supported Versions](https://img.shields.io/pypi/pyversions/html-for-docx.svg)
 
-Convert html to docx, this project is a fork from descontinued [pqzx/html2docx](https://github.com/pqzx/html2docx).
+Convert html to docx, this project is a fork from the discontinued [pqzx/html2docx](https://github.com/pqzx/html2docx).
 
-## How install
+## How to install
 
 `pip install html-for-docx`
 
@@ -17,11 +17,14 @@ Convert html to docx, this project is a fork from descontinued [pqzx/html2docx](
 Add HTML-formatted content to an existing `.docx` document
 
 ```python
+from docx import Document
 from html4docx import HtmlToDocx
 
+document = Document('existing_file.docx')
 parser = HtmlToDocx()
 html_string = '<h1>Hello world</h1>'
-parser.add_html_to_document(html_string, filename_docx)
+parser.add_html_to_document(html_string, document)
+document.save('existing_file.docx')
 ```
 
 You can use `python-docx` to manipulate directly the file, here an example
@@ -54,9 +57,9 @@ for part in ['First', 'Second', 'Third']:
 parser.save('your_file_name.docx')
 ```
 
-When you pass a `Document` object, you can either use `document.save()` from python-docx or `parser.save()` from html4docx, both works well.
+When you pass a `Document` object, you can either use `document.save()` from python-docx or `parser.save()` from html4docx, both work well.
 
-Both supports saving it in-memory, using `BytesIO`.
+Both support saving it in-memory, using `BytesIO`.
 
 ```python
 from io import BytesIO
@@ -89,6 +92,15 @@ parser.parse_html_file(input_html_file_path, output_docx_file_path)
 parser.parse_html_file(input_html_file_path, output_docx_file_path, 'utf-8')
 ```
 
+If the HTML file references local images or stylesheets, allow the folder that holds them (see [External resources security](#external-resources-security)):
+
+```python
+import os
+
+parser.options['local-files-root'] = os.path.dirname(os.path.abspath(input_html_file_path))
+parser.parse_html_file(input_html_file_path, output_docx_file_path)
+```
+
 #### Convert files from a string
 
 ```python
@@ -120,31 +132,62 @@ All table styles we support can be found [here](https://python-docx.readthedocs.
 
 ## Options
 
-There is 7 options that you can use to personalize your execution:
-- Disable Images: Ignore all images.
-- Disable Tables: If you do it, it will render just the raw tables content
-- Disable Styles: Ignore all CSS styles. Also disables Style-Map.
-- Disable Fix-HTML: Use BeautifulSoap to Fix possible HTML missing tags.
-- Disable Style-Map: Ignore CSS classes to word styles mapping
-- Disable Tag-Override: Ignore html tag overrides.
-- Disable HTML-Comments: Ignore all "<!-- ... -->" comments from HTML.
-
-This is how you could disable them if you want:
+All options are set through `parser.options` before parsing. Copy only the ones you need to change:
 
 ```python
 from html4docx import HtmlToDocx
 
 parser = HtmlToDocx()
-parser.options['images'] = False # Default True
-parser.options['tables'] = False # Default True
-parser.options['styles'] = False # Default True
-parser.options['fix-html'] = False # Default True
-parser.options['html-comments'] = False # Default False
-parser.options['style-map'] = False # Default True
-parser.options['tag-override'] = False # Default True
+
+# --- Rendering ---
+parser.options['images'] = False         # Default True.  False ignores all images.
+parser.options['tables'] = False         # Default True.  False renders only the raw table content.
+parser.options['styles'] = False         # Default True.  False ignores all CSS (also disables 'style-map').
+parser.options['fix-html'] = False       # Default True.  False skips BeautifulSoup fixing of missing HTML tags.
+parser.options['style-map'] = False      # Default True.  False ignores CSS class to Word style mapping.
+parser.options['tag-override'] = False   # Default True.  False ignores HTML tag overrides.
+parser.options['html-comments'] = True   # Default False. True renders "<!-- ... -->" comments.
+
+# --- External resources security (see the section below) ---
+parser.options['allow-remote-resources'] = False                    # Default True.  False skips all http(s) images and stylesheets.
+parser.options['private-network-allowlist'] = ["10.0.5.20", "192.168.10.0/24"]  # Default []. Private IPs/CIDRs that may be fetched.
+parser.options['local-files-root'] = '/srv/app/assets'              # Default None.  Directory local files may be read from (None = disabled).
+parser.options['max-resource-bytes'] = 5 * 1024 * 1024              # Default 10 MB. Maximum size of each fetched resource.
+parser.options['allow-private-network'] = False                     # Default False. True allows EVERY private address and ignores the allowlist: trusted HTML only!
+
 docx = parser.parse_html_string(input_html_file_string)
 ```
 
+### External resources security
+
+HTML is often untrusted input, so images (`<img src>`) and stylesheets (`<link rel="stylesheet">`) are fetched under a restrictive policy by default:
+
+- **Remote resources:** only `http`/`https` are fetched. `file://`, `ftp://` and any other scheme are always refused. Inline images (`data:image/...`) keep working.
+- **Private network:** requests to non-public addresses (loopback, private ranges, link-local such as the cloud metadata endpoint `169.254.169.254`, reserved, multicast) are refused. The check is applied to the IP actually connected to, on every redirect hop, so DNS rebinding and open redirects can't bypass it.
+- **Local files:** disabled by default. When `local-files-root` is set, only files inside that directory (after resolving `..` and symlinks) can be read, and relative paths are resolved against it.
+- **Size:** each resource, remote or local, is limited to `max-resource-bytes`.
+
+**Reaching an internal server.** Add its addresses to `private-network-allowlist`. Only those IPs/CIDRs are opened, and everything else stays blocked. Public addresses (CDNs, websites) never need to be listed. Keep entries as narrow as possible: a broad range such as `169.254.0.0/16` also opens cloud metadata endpoints. Invalid entries raise `ValueError` instead of being silently ignored. `allow-private-network` opens every private address at once and should only be used when the HTML is fully trusted.
+
+> **Converting HTML from users?** Keep `allow-private-network` disabled, keep `private-network-allowlist` as small as possible and never point `local-files-root` at a directory containing sensitive files. If you don't need external images or stylesheets at all, set `allow-remote-resources` to `False`.
+
+Blocked or unavailable resources are skipped and a warning is logged (logger `html4docx.resources`); the conversion itself does not fail.
+
+#### Migrating from <=1.2.x
+
+Public `http`/`https` URLs and `data:image/...` images work as before. What changed:
+
+- **Local paths** in `<img src>` and `<link href>` are disabled by default. Set `local-files-root` to the folder that holds your assets. Relative paths are now resolved against it, not the current working directory:
+
+```python
+import os
+
+parser.options['local-files-root'] = os.path.abspath('./assets')
+```
+
+- **Private network addresses** (e.g. an intranet server) are blocked. Add them to `private-network-allowlist`.
+- **Proxies:** `HTTP_PROXY` / `HTTPS_PROXY` environment variables are ignored, because routing through a proxy would bypass the private network protection. If your server can only reach the internet through a proxy, remote resources will not load. Embed images as `data:image/...` URIs, put CSS in an inline `<style>` tag, or serve the files from `local-files-root`.
+
 ## Extended Styling Features
 
 ### CSS Class to Word Style Mapping
@@ -198,11 +241,11 @@ If a referenced custom style does not exist in the document at generation time,
 Set custom default paragraph style:
 
 ```python
-# Use 'Body' as default (default behavior)
-parser = HtmlToDocx(default_paragraph_style='Body')
+# Word's 'Normal' style is used by default
+parser = HtmlToDocx()
 
-# Use Word's default 'Normal' style
-parser = HtmlToDocx(default_paragraph_style=None)
+# Use a custom style, e.g. 'Body', as default
+parser = HtmlToDocx(default_paragraph_style='Body')
 ```
 
 ## CSS
@@ -218,7 +261,7 @@ Full support for inline CSS styles on any element:
 
 #### External CSS Styles
 
-Limited support for external CSS styles (local or url):
+Limited support for external CSS styles (local or url). Remote stylesheets follow the [External resources security](#external-resources-security) rules, and local ones require `local-files-root`:
 
 **HTML**
 
@@ -227,8 +270,8 @@ Limited support for external CSS styles (local or url):
     <title>My page</title>
     <!-- Must contain rel="stylesheet" otherwise will be ignored -->
     <link rel="stylesheet" href="https://my-external-css.domain.com/style.css">
-    <!-- OR -->
-    <link rel="stylesheet" href="../my_local/css/style.css">
+    <!-- OR, a file inside local-files-root -->
+    <link rel="stylesheet" href="css/style.css">
 </head>
 <body>
     <div class="classFromExternalCss">
@@ -267,7 +310,7 @@ p {
 - text-align
 - background-color
 - Border (for tables)
-- Verticial Align (for tables)
+- Vertical Align (for tables)
 
 ### !important Flag Support
 
@@ -305,22 +348,23 @@ parser = HtmlToDocx()
 parser.set_initial_attrs(document)
 metadata = parser.metadata
 
+# Set new metadata
+metadata.set_metadata(author="Jane", created="2025-07-18T09:30:00")
+
 # You can get metadata as dict
 metadata_json = metadata.get_metadata()
 print(metadata_json['author']) # Jane
-# or just print all metadata if if you want
+# or just print all metadata if you want
 metadata.get_metadata(print_result=True)
 
-# Set new metadata
-metadata.set_metadata(author="Jane", created="2025-07-18T09:30:00")
 document.save('your_file_name.docx')
 ```
 
 You can find all available metadata attributes [here](https://python-docx.readthedocs.io/en/latest/dev/analysis/features/coreprops.html).
 
-#### Logging
+## Logging
 
-html4docx uses Python's standard `logging` module with named, hierarchical loggers (for example, `html4docx.h4d`). The library never logs directly to the root logger and installs a `NullHandler` by default, so it remains silent unless your application configures logging.
+html4docx uses Python's standard `logging` module with named, hierarchical loggers (for example, `html4docx.h4d` and `html4docx.resources`). The library never logs directly to the root logger and installs a `NullHandler` by default, so it remains silent unless your application configures logging.
 
 **Silence all html4docx logs:**
 
@@ -353,13 +397,13 @@ LOGGING = {
 }
 ```
 
-> **Note:** Unrecognised CSS properties (e.g. `letter-spacing`, `margin`, `padding`) are intentionally logged at `DEBUG` level because they are expected skips for any real-world HTML, not problems. Only genuinely unexpected situations (missing styles, unsupported colour formats, etc.) are logged at `WARNING`.
+> **Note:** Unrecognised CSS properties (e.g. `letter-spacing`, `margin`, `padding`) are intentionally logged at `DEBUG` level because they are expected skips for any real-world HTML, not problems. Only genuinely unexpected situations (missing styles, unsupported colour formats, blocked external resources, etc.) are logged at `WARNING`.
 
-### Why
+## Why
 
 My goal in forking and fixing/updating this package was to complete my current task at work, which involves converting HTML to DOCX. The original package lacked a few features and had some bugs, preventing me from completing the task. Instead of creating a new package from scratch, I preferred to update this one.
 
-### Differences (fixes and new features)
+## Differences (fixes and new features)
 
 **Fixes**
 - Fix `table_style` not working | [Dfop02](https://github.com/dfop02) from [Issue](https://github.com/dfop02/html4docx/issues/11)
@@ -377,9 +421,10 @@ My goal in forking and fixing/updating this package was to complete my current t
 - Fix color parsing failing due to invalid colors, falling back to black. | [dfop02](https://github.com/dfop02) from [Issue](https://github.com/dfop02/html4docx/issues/53)
 - Fix logging noise: replace root-logger calls with named module loggers so consumers can silence or configure html4docx output independently. | [dfop02](https://github.com/dfop02) from [Issue](https://github.com/dfop02/html4docx/issues/80)
 - Fixed non-breaking spaces (`&nbsp;`) being collapsed into ordinary spaces, which let Word break lines inside amounts like `1 000,00 €` | [Lynuxen](https://github.com/Lynuxen)
+- Fix SSRF and arbitrary local file read through `<img src>` and `<link rel="stylesheet">` when converting untrusted HTML | [dfop02](https://github.com/dfop02)
 
 **New Features**
-- Add Witdh/Height style to images | [maifeeulasad](https://github.com/maifeeulasad) from [PR](https://github.com/pqzx/html2docx/pull/29)
+- Add Width/Height style to images | [maifeeulasad](https://github.com/maifeeulasad) from [PR](https://github.com/pqzx/html2docx/pull/29)
 - Support px, cm, pt, in, rem, em, mm, pc and % units for styles | [Dfop02](https://github.com/dfop02)
 - Improve performance on large tables | [dashingdove](https://github.com/dashingdove) from [PR](https://github.com/pqzx/html2docx/pull/58)
 - Support for HTML Pagination | [Evilran](https://github.com/Evilran) from [PR](https://github.com/pqzx/html2docx/pull/39)
@@ -393,11 +438,12 @@ My goal in forking and fixing/updating this package was to complete my current t
 - Support to metadata | [Dfop02](https://github.com/dfop02)
 - Add support to table cells style (border, background-color, width, height, margin) | [Dfop02](https://github.com/dfop02)
 - Being able to use inline images on same paragraph. | [Dfop02](https://github.com/dfop02)
-- Refactory Tests to be more consistent and less 'human validation' | [Dfop02](https://github.com/dfop02)
+- Refactor Tests to be more consistent and less 'human validation' | [Dfop02](https://github.com/dfop02)
 - Support for common CSS properties for text | [Lynuxen](https://github.com/Lynuxen)
 - Support for CSS classes to Word Styles | [raithedavion](https://github.com/raithedavion)
 - Support for HTML tag style overrides | [raithedavion](https://github.com/raithedavion)
 - Support style tag and external CSS styles | [Dfop02](https://github.com/dfop02)
+- Security policy for external resources (`allow-remote-resources`, `private-network-allowlist`, `allow-private-network`, `local-files-root`, `max-resource-bytes`) | [dfop02](https://github.com/dfop02)
 
 ## To-Do
 
@@ -427,15 +473,26 @@ These are the ideas I'm planning to work on in the future to make this project e
    - Would be necessary a responsive CSS, that's not applied to Docx.
 
 4. **@import:**
-   - Do not support `@import` em CSS.
+   - Do not support `@import` in CSS.
    - We can try implement it in future if necessary.
 
+5. **CSS Variables:**
+   - Do not support `var(--name)` values. Frameworks that define colors through variables (e.g. Bootstrap 5 `text-danger`) fall back to black.
+
+### External resources
+- Proxies configured through `HTTP_PROXY` / `HTTPS_PROXY` are not used (see [Migrating from <=1.2.x](#migrating-from-12x)).
+- `data:` URIs are only supported for images. Stylesheets must be remote, local (inside `local-files-root`) or inline in a `<style>` tag.
+
 ## Project Guidelines
 
 This project is primarily designed for compatibility with Microsoft Word, but it currently works well with LibreOffice and Google Docs, based on our testing. The goal is to maintain this cross-platform harmony while continuing to implement fixes and updates.
 
 > ⚠️ However, please note that Microsoft Word is the priority. Bugs or issues specific to other editors (e.g., LibreOffice or Google Docs) may be considered, but fixing them is secondary to maintaining full compatibility with Word.
 
+## Security
+
+If you find a security vulnerability, please **do not open a public issue**. Report it privately through [GitHub Security Advisories](https://github.com/dfop02/html4docx/security/advisories/new).
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
diff --git a/html4docx/constants.py b/html4docx/constants.py
index eff13cb..bf8eb43 100644
--- a/html4docx/constants.py
+++ b/html4docx/constants.py
@@ -10,6 +10,9 @@
 # Style to use with tables. By default no style is used.
 DEFAULT_TABLE_STYLE = None
 
+DEFAULT_MAX_RESOURCE_BYTES = 10 * 1024 * 1024
+REMOTE_RESOURCE_SCHEMES = ("http", "https")
+
 DEFAULT_OPTIONS = {
     'fix-html': True,
     'images': True,
@@ -18,6 +21,12 @@
     'html-comments': False,
     "style-map": True,
     "tag-override": True,
+    # Security of external resources (<img src>, <link rel="stylesheet">)
+    "allow-remote-resources": True,   # fetch http(s) resources
+    "allow-private-network": False,   # allow loopback/private/link-local/metadata IPs (SSRF!)
+    "private-network-allowlist": [],  # IPs/CIDRs allowed even when private, e.g. ["10.0.5.20/32"]
+    "local-files-root": None,         # directory allowed for local files; None = local files disabled
+    "max-resource-bytes": 10 * 1024 * 1024,
 }
 
 DEFAULT_TABLE_ROW_SELECTORS = [
diff --git a/html4docx/h4d.py b/html4docx/h4d.py
index 3d75511..585689f 100644
--- a/html4docx/h4d.py
+++ b/html4docx/h4d.py
@@ -15,7 +15,7 @@
 from docx.oxml.ns import qn
 from docx.shared import RGBColor
 
-from html4docx import constants, utils
+from html4docx import constants, resources, utils
 from html4docx.css_parser import CSSParser
 from html4docx.metadata import Metadata
 
@@ -37,6 +37,10 @@ def __init__(self, style_map=None, tag_style_overrides=None, default_paragraph_s
         self.tag_style_overrides = tag_style_overrides or constants.DEFAULT_TAG_OVERRIDES
         self.default_paragraph_style = default_paragraph_style or constants.DEFAULT_PARAGRAPH_STYLE
 
+    def _resource_policy(self) -> resources.ResourcePolicy:
+        """Security policy for external resources, built from self.options."""
+        return resources.ResourcePolicy.from_options(self.options)
+
     def set_initial_attrs(self, document=None):
         self.tags = {
             "span": [],
@@ -1230,7 +1234,7 @@ def handle_img(self, current_attrs):
         width = utils.unit_converter(utils.add_px(current_attrs["width"])) if "width" in current_attrs else None
 
         # fetch image
-        image = utils.fetch_image_data(src)
+        image = resources.fetch_image_data(src, self._resource_policy())
 
         if not self.paragraph:
             self.paragraph = self.doc.add_paragraph()
@@ -2121,7 +2125,7 @@ def _extract_and_parse_link_tags(self) -> None:
                 continue
 
             # Fetch external CSS
-            css_content = utils.fetch_external_css(href)
+            css_content = resources.fetch_external_css(href, self._resource_policy())
             if css_content:
                 # Use selective parsing to only load relevant rules
                 # This prevents loading thousands of unused CSS rules from frameworks
@@ -2140,7 +2144,7 @@ def _extract_link_tags_from_string(self, html: str) -> None:
         for match in link_pattern.finditer(html):
             href = match.group(1)
             if href:
-                css_content = utils.fetch_external_css(href)
+                css_content = resources.fetch_external_css(href, self._resource_policy())
                 if css_content:
                     # Use selective parsing
                     self.css_parser.parse_css(css_content, selective=True)
@@ -2169,7 +2173,7 @@ def _extract_and_parse_css_in_document_order(self) -> None:
                     continue
                 href = element.get("href") or element.get("data-href")
                 if href:
-                    css_content = utils.fetch_external_css(href)
+                    css_content = resources.fetch_external_css(href, self._resource_policy())
                     if css_content:
                         self.css_parser.parse_css(css_content, selective=True)
                 element.decompose()
diff --git a/html4docx/resources.py b/html4docx/resources.py
new file mode 100644
index 0000000..3b99e16
--- /dev/null
+++ b/html4docx/resources.py
@@ -0,0 +1,263 @@
+import base64
+import binascii
+import functools
+import http.client
+import ipaddress
+import logging
+import os
+import socket
+import urllib.error
+import urllib.request
+from io import BytesIO
+from typing import Optional
+from urllib.parse import urlparse
+
+from html4docx import constants
+
+logger = logging.getLogger(__name__)
+
+
+class BlockedResourceError(Exception):
+    """Raised when a resource is refused by the ResourcePolicy."""
+
+
+class ResourcePolicy:
+    def __init__(
+        self,
+        allow_remote: bool = True,
+        allow_private_network: bool = False,
+        private_network_allowlist=(),
+        local_files_root: Optional[str] = None,
+        max_bytes: int = constants.DEFAULT_MAX_RESOURCE_BYTES,
+        timeout: float = 5,
+    ):
+        self.allow_remote = allow_remote
+        self.allow_private_network = allow_private_network
+        self.private_network_allowlist = _parse_allowlist(private_network_allowlist)
+        self.local_files_root = local_files_root
+        self.max_bytes = max_bytes
+        self.timeout = timeout
+        if self.allow_private_network and self.private_network_allowlist:
+            logger.warning("'allow-private-network' is enabled, so 'private-network-allowlist' is ignored")
+
+    @classmethod
+    def from_options(cls, options: dict) -> "ResourcePolicy":
+        return cls(
+            allow_remote=options.get("allow-remote-resources", True),
+            allow_private_network=options.get("allow-private-network", False),
+            private_network_allowlist=options.get("private-network-allowlist") or (),
+            local_files_root=options.get("local-files-root"),
+            max_bytes=options.get("max-resource-bytes", constants.DEFAULT_MAX_RESOURCE_BYTES),
+        )
+
+
+def _parse_allowlist(entries) -> tuple:
+    """Convert IPs/CIDRs to ip_network objects. Invalid entries raise ValueError (fail fast)."""
+    if isinstance(entries, str):
+        entries = [entries]
+    return tuple(ipaddress.ip_network(str(entry).strip(), strict=False) for entry in entries)
+
+
+def _is_forbidden_ip(ip_str: str, allowlist: tuple = ()) -> bool:
+    ip = ipaddress.ip_address(ip_str.split("%", 1)[0])  # strip IPv6 zone id
+    if ip.version == 6 and ip.ipv4_mapped:
+        ip = ip.ipv4_mapped
+
+    if any(ip in net for net in allowlist):
+        return False
+    return (not ip.is_global) or ip.is_multicast
+
+
+def _guarded_create_connection(
+    address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None, *args, allowlist=(), **kwargs
+):
+    """
+    Replacement for socket.create_connection that resolves the host once and
+    connects only to vetted public IPs (no TOCTOU / DNS rebinding window).
+    """
+    host, port = address
+    last_err = None
+    for family, socktype, proto, _, sockaddr in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
+        if _is_forbidden_ip(sockaddr[0], allowlist):
+            last_err = BlockedResourceError(f"Refusing to connect to non-public address {sockaddr[0]} ({host})")
+            continue
+        sock = socket.socket(family, socktype, proto)
+        try:
+            if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
+                sock.settimeout(timeout)
+            if source_address:
+                sock.bind(source_address)
+            sock.connect(sockaddr)
+            return sock
+        except OSError as err:
+            sock.close()
+            last_err = err
+    raise last_err or OSError(f"Could not resolve {host}")
+
+
+class _GuardedHTTPConnection(http.client.HTTPConnection):
+    def __init__(self, *args, allowlist=(), **kwargs):
+        super().__init__(*args, **kwargs)
+        self._create_connection = functools.partial(_guarded_create_connection, allowlist=allowlist)
+
+
+class _GuardedHTTPSConnection(http.client.HTTPSConnection):
+    def __init__(self, *args, allowlist=(), **kwargs):
+        super().__init__(*args, **kwargs)
+        self._create_connection = functools.partial(_guarded_create_connection, allowlist=allowlist)
+
+
+class _GuardedHTTPHandler(urllib.request.HTTPHandler):
+    def __init__(self, allowlist=(), **kwargs):
+        super().__init__(**kwargs)
+        self._allowlist = allowlist
+
+    def http_open(self, req):
+        return self.do_open(_GuardedHTTPConnection, req, allowlist=self._allowlist)
+
+
+class _GuardedHTTPSHandler(urllib.request.HTTPSHandler):
+    def __init__(self, allowlist=(), **kwargs):
+        super().__init__(**kwargs)
+        self._allowlist = allowlist
+
+    def https_open(self, req):
+        return self.do_open(_GuardedHTTPSConnection, req, context=self._context, allowlist=self._allowlist)
+
+def _build_opener(allow_private_network: bool, allowlist: tuple = ()) -> urllib.request.OpenerDirector:
+    """
+    Opener with ONLY http/https handlers: no file://, ftp://, data: handlers
+    and no environment proxies, so redirects cannot escape to other schemes.
+    """
+    opener = urllib.request.OpenerDirector()
+    if allow_private_network:
+        handlers = [urllib.request.HTTPHandler(), urllib.request.HTTPSHandler()]
+    else:
+        handlers = [_GuardedHTTPHandler(allowlist=allowlist), _GuardedHTTPSHandler(allowlist=allowlist)]
+    handlers += [
+        urllib.request.HTTPDefaultErrorHandler(),
+        urllib.request.HTTPRedirectHandler(),
+        urllib.request.HTTPErrorProcessor(),
+        urllib.request.UnknownHandler(),
+    ]
+    for handler in handlers:
+        opener.add_handler(handler)
+    return opener
+
+
+def _fetch_remote_bytes(url: str, policy: ResourcePolicy) -> bytes:
+    if not policy.allow_remote:
+        raise BlockedResourceError("Remote resources are disabled ('allow-remote-resources')")
+    if urlparse(url).scheme.lower() not in constants.REMOTE_RESOURCE_SCHEMES:
+        raise BlockedResourceError(f"Scheme not allowed: {url}")
+    opener = _build_opener(policy.allow_private_network, policy.private_network_allowlist)
+    with opener.open(url, timeout=policy.timeout) as response:
+        data = response.read(policy.max_bytes + 1)
+    if len(data) > policy.max_bytes:
+        raise BlockedResourceError(f"Resource larger than {policy.max_bytes} bytes: {url}")
+    return data
+
+
+def _resolve_local_path(src: str, policy: ResourcePolicy) -> str:
+    """Resolve a local path / file:// URL, confined to policy.local_files_root."""
+    if not policy.local_files_root:
+        raise BlockedResourceError("Local files are disabled (set 'local-files-root' to enable)")
+
+    parsed = urlparse(src)
+    if parsed.scheme.lower() == "file":
+        if parsed.netloc not in ("", "localhost"):
+            raise BlockedResourceError(f"Remote file:// host not allowed: {src}")
+        src = urllib.request.url2pathname(parsed.path)
+
+    root = os.path.realpath(policy.local_files_root)
+    candidate = os.path.realpath(os.path.join(root, src))  # absolute src replaces root, then gets checked
+    try:
+        inside = os.path.commonpath([root, candidate]) == root
+    except ValueError:  # different drives on Windows
+        inside = False
+    if not inside:
+        raise BlockedResourceError(f"Path outside of local-files-root: {src}")
+    return candidate
+
+
+def _read_local_bytes(src: str, policy: ResourcePolicy) -> bytes:
+    path = _resolve_local_path(src, policy)
+    if not os.path.isfile(path):
+        raise FileNotFoundError(path)
+    if os.path.getsize(path) > policy.max_bytes:
+        raise BlockedResourceError(f"File larger than {policy.max_bytes} bytes: {src}")
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def _classify_source(src: str) -> str:
+    scheme = urlparse(src).scheme.lower()
+    if scheme in constants.REMOTE_RESOURCE_SCHEMES:
+        return "remote"
+    if scheme == "file" or len(scheme) <= 1:  # "" or Windows drive letter (C:\...)
+        return "local"
+    return "blocked"
+
+
+def fetch_resource_bytes(src: str, policy: Optional[ResourcePolicy] = None) -> Optional[bytes]:
+    """
+    Fetch a remote or local resource honoring the policy.
+    Returns None (and logs a warning) if it's blocked or unavailable.
+    """
+    policy = policy or ResourcePolicy()
+    try:
+        kind = _classify_source(src)
+        if kind == "remote":
+            return _fetch_remote_bytes(src, policy)
+        if kind == "local":
+            return _read_local_bytes(src, policy)
+        raise BlockedResourceError(f"Scheme not allowed: {src}")
+    except BlockedResourceError as err:
+        logger.warning("Blocked external resource: %s", err)
+    except (urllib.error.URLError, http.client.HTTPException, OSError, ValueError) as err:
+        logger.warning("Could not fetch external resource %s: %s", src, err)
+    return None
+
+
+def fetch_image(url: str, policy: Optional[ResourcePolicy] = None):
+    """
+    Fetches an image from a http(s) url honoring the ResourcePolicy.
+    If successful returns a BytesIO object, else returns None.
+    """
+    if _classify_source(url) != "remote":
+        logger.warning("Blocked external resource: not a http(s) url: %s", url)
+        return None
+    data = fetch_resource_bytes(url, policy)
+    return BytesIO(data) if data is not None else None
+
+
+def fetch_image_data(src: str, policy: Optional[ResourcePolicy] = None):
+    """Fetches image data from a data URI, URL or (allowed) local file."""
+    if src.startswith("data:image/"):  # Handle Base64
+        try:
+            _, encoded = src.split(",", 1)
+            return BytesIO(base64.b64decode(encoded))
+        except (ValueError, binascii.Error):
+            return None
+
+    data = fetch_resource_bytes(src, policy)
+    return BytesIO(data) if data is not None else None
+
+
+def fetch_external_css(url: str, policy: Optional[ResourcePolicy] = None) -> Optional[str]:
+    """
+    Fetch external CSS from URL or local file, honoring the ResourcePolicy.
+
+    Returns:
+        Optional[str]: CSS content as string, or None if blocked / fetch fails
+    """
+    if not url:
+        return None
+
+    content = fetch_resource_bytes(url, policy)
+    if content is None:
+        return None
+    try:
+        return content.decode("utf-8")
+    except UnicodeDecodeError:
+        return content.decode("latin-1")
diff --git a/html4docx/utils.py b/html4docx/utils.py
index 7dfc2df..007f1f7 100644
--- a/html4docx/utils.py
+++ b/html4docx/utils.py
@@ -1,12 +1,7 @@
-import base64
 import logging
 import os
 import re
-import urllib
-import urllib.request
 from enum import Enum
-from io import BytesIO
-from typing import Optional
 from urllib.parse import urlparse
 
 from docx.shared import Cm, Inches, Mm, Pt, RGBColor
@@ -64,76 +59,6 @@ def remove_important_from_style(text: str):
     return re.sub("!important", "", text, flags=re.IGNORECASE).strip()
 
 
-def fetch_image(url: str):
-    """
-    Attempts to fetch an image from a url, with 5s timeout.
-    If successful returns a bytes object, else returns None
-
-    :return:
-    """
-    try:
-        with urllib.request.urlopen(url, timeout=5) as response:
-            return BytesIO(response.read())
-    except urllib.error.URLError:
-        return None
-
-
-def fetch_image_data(src: str):
-    """Fetches image data from a URL or local file."""
-    if src.startswith("data:image/"):  # Handle Base64
-        _, encoded = src.split(",", 1)
-        return BytesIO(base64.b64decode(encoded))
-
-    elif is_url(src):  # Handle URLs
-        return fetch_image(src)
-
-    else:  # Handle Local Files
-        try:
-            return open(src, "rb")
-        except FileNotFoundError:
-            return None
-
-
-def fetch_external_css(url: str) -> Optional[str]:
-    """
-    Fetch external CSS from URL or local file.
-
-    Args:
-        url (str): URL or local file path to CSS file
-
-    Returns:
-        Optional[str]: CSS content as string, or None if fetch fails
-
-    Example:
-        css = fetch_external_css('https://example.com/style.css')
-        css = fetch_external_css('./styles/custom.css')
-    """
-    if not url:
-        return None
-
-    try:
-        if is_url(url):
-            # Fetch from URL
-            with urllib.request.urlopen(url, timeout=5) as response:
-                # Read body once; try UTF-8, fall back to latin-1
-                content = response.read()
-                try:
-                    return content.decode('utf-8')
-                except UnicodeDecodeError:
-                    return content.decode('latin-1')
-        else:
-            # Fetch from local file
-            try:
-                with open(url, encoding='utf-8') as f:
-                    return f.read()
-            except UnicodeDecodeError:
-                with open(url, encoding='latin-1') as f:
-                    return f.read()
-    except (urllib.error.URLError, FileNotFoundError, OSError):
-        logging.warning(f"Could not fetch external CSS from: {url}")
-        return None
-
-
 def parse_dict_string(string: str, separator: str = ";"):
     """Parse style string into dict, return empty dict if no style"""
     if not string:
diff --git a/pyproject.toml b/pyproject.toml
index e99e795..9faae5d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -2,6 +2,9 @@
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
+[tool.pytest.ini_options]
+addopts = "-n auto"
+
 [tool.ruff]
 line-length = 127
 target-version = "py37"
diff --git a/requirements_test.txt b/requirements_test.txt
index 5882d08..ac21e6c 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,4 +1,5 @@
 ruff>=0.1.0
 pytest>=8.3.4
+pytest-xdist>=3.6.1
 pytest-cov>=6.2.1
 pluggy>=1.6.0
diff --git a/setup.cfg b/setup.cfg
index 8311db6..58f6d8b 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -31,6 +31,7 @@ classifiers =
     Programming Language :: Python :: 3.12
     Programming Language :: Python :: 3.13
     Programming Language :: Python :: 3.14
+    Programming Language :: Python :: 3.15
 
 [options]
 python_requires = >=3.7
diff --git a/setup.py b/setup.py
index 4a58378..0bce5a2 100644
--- a/setup.py
+++ b/setup.py
@@ -42,7 +42,8 @@
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
-        'Programming Language :: Python :: 3.14'
+        'Programming Language :: Python :: 3.14',
+        'Programming Language :: Python :: 3.15'
     ],
     install_requires = [
         'python-docx>=1.1.0',
diff --git a/tests/test_css_features.py b/tests/test_css_features.py
index 8052dd5..e27744b 100644
--- a/tests/test_css_features.py
+++ b/tests/test_css_features.py
@@ -529,8 +529,9 @@ class TestCSSLoadingOrder(unittest.TestCase):
     def setUp(self):
         self.css_dir = os.path.join(test_dir, "assets", "css")
 
-    def _parse(self, html):
+    def _parse(self, html, local_root=test_dir):
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = local_root
         return parser.parse_html_string(html)
 
     def test_style_tag_before_link_tag(self):
@@ -543,6 +544,7 @@ def test_style_tag_before_link_tag(self):
         <p>Test</p>
         """
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, Document())
 
         # Both style tag and CSS file have p rule.
@@ -563,6 +565,7 @@ def test_link_tag_before_style_tag(self):
         <p>Test</p>
         """
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, Document())
 
         self.assertIn("p", parser.css_parser.tag_rules)
@@ -576,6 +579,7 @@ def test_multiple_style_tags_cascade(self):
         <p>Test</p>
         """
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, Document())
         # Second style tag overrides first
         self.assertEqual(parser.css_parser.tag_rules["p"]["color"], "blue")
@@ -592,6 +596,7 @@ def test_multiple_link_tags_cascade(self):
         <p>Test</p>
         """
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, Document())
         # test_styles.css loaded second → its p color wins
         self.assertEqual(parser.css_parser.tag_rules["p"]["color"], "blue")
@@ -605,6 +610,7 @@ def test_style_tag_without_head_tag(self):
         </body>
         """
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, Document())
         self.assertTrue(parser.css_parser.has_rules())
         self.assertIn("p", parser.css_parser.tag_rules)
@@ -793,8 +799,9 @@ class TestExternalCSSBehavior(unittest.TestCase):
     def setUp(self):
         self.css_dir = os.path.join(test_dir, "assets", "css")
 
-    def _parse(self, html):
+    def _parse(self, html, local_root=test_dir):
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = local_root
         return parser.parse_html_string(html)
 
     def test_external_css_applied_to_output(self):
@@ -867,7 +874,7 @@ def test_external_css_with_temp_file(self):
             tmp_path = f.name
         try:
             html = f'<link rel="stylesheet" href="{tmp_path}"><p>Temp CSS</p>'
-            doc = self._parse(html)
+            doc = self._parse(html, local_root=os.path.dirname(tmp_path))
             run = _run_for_text(doc, "Temp CSS")
             self.assertIsNotNone(run)
             self.assertEqual(_run_color(run), RGBColor(255, 0, 0))
@@ -1130,8 +1137,9 @@ def test_span_css_class_does_not_affect_paragraph_alignment(self):
 class TestComplexCSSScenarios(unittest.TestCase):
     """Complex nesting, compound selectors, and multi-level CSS interactions."""
 
-    def _parse(self, html):
+    def _parse(self, html, local_root=test_dir):
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = local_root
         return parser.parse_html_string(html)
 
     def test_span_compound_selector(self):
@@ -1333,7 +1341,7 @@ def test_multiple_css_sources_all_applied(self):
             <link rel="stylesheet" href="{tmp}">
             <p class="style-tag ext-class" style="font-weight: bold;">Triple styled</p>
             """
-            doc = self._parse(html)
+            doc = self._parse(html, local_root=os.path.dirname(tmp))
             run = _run_for_text(doc, "Triple styled")
             self.assertIsNotNone(run)
             # From <style> tag
diff --git a/tests/test_css_parser.py b/tests/test_css_parser.py
index d49c648..24a777d 100644
--- a/tests/test_css_parser.py
+++ b/tests/test_css_parser.py
@@ -362,6 +362,7 @@ def setUp(self):
         self.document = Document()
         self.parser = HtmlToDocx()
         self.test_dir = os.path.abspath(os.path.dirname(__file__))
+        self.parser.options["local-files-root"] = self.test_dir
 
     def test_external_css_from_local_file(self):
         """Test loading CSS from local file via <link> tag"""
@@ -530,4 +531,3 @@ def test_selective_parsing_efficiency(self):
 
 if __name__ == "__main__":
     unittest.main()
-
diff --git a/tests/test_h4d.py b/tests/test_h4d.py
index 5e1ba33..7e6f3cb 100644
--- a/tests/test_h4d.py
+++ b/tests/test_h4d.py
@@ -120,6 +120,7 @@ def tearDownClass(cls):
 
     def setUp(self):
         self.parser = HtmlToDocx()
+        self.parser.options["local-files-root"] = os.path.dirname(test_dir)
 
     # ============================== Tests ============================== #
     def test_save_docx_by_filename(self):
@@ -3110,6 +3111,7 @@ def test_local_css_with_selective_parsing(self):
         """
 
         parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
         parser.add_html_to_document(html, self.document)
 
         # Verify CSS was loaded
diff --git a/tests/test_security.py b/tests/test_security.py
new file mode 100644
index 0000000..6524370
--- /dev/null
+++ b/tests/test_security.py
@@ -0,0 +1,216 @@
+"""Regression tests for SSRF / arbitrary local file read via <img> and <link>."""
+import http.server
+import os
+import socket
+import socketserver
+import tempfile
+import threading
+import unittest
+from unittest import mock
+
+from docx import Document
+
+from html4docx import HtmlToDocx, resources
+
+test_dir = os.path.abspath(os.path.dirname(__file__))
+TEST_IMG = os.path.join(test_dir, "assets", "images", "test_img.png")
+
+
+class _Handler(http.server.BaseHTTPRequestHandler):
+    hits = []
+
+    def do_GET(self):
+        _Handler.hits.append(self.path)
+        if self.path.startswith("/redirect"):
+            self.send_response(302)
+            self.send_header("Location", self.path.split("to=", 1)[1])
+            self.end_headers()
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", "text/css")
+        self.end_headers()
+        self.wfile.write(b"p { color: red; }")
+
+    def log_message(self, *args):
+        pass
+
+
+class SecurityTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.server = socketserver.TCPServer(("127.0.0.1", 0), _Handler)
+        cls.port = cls.server.server_address[1]
+        threading.Thread(target=cls.server.serve_forever, daemon=True).start()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.shutdown()
+        cls.server.server_close()
+
+    def setUp(self):
+        _Handler.hits.clear()
+        fd, self.secret = tempfile.mkstemp()
+        os.write(fd, b"SECRET_FILE_CONTENTS")
+        os.close(fd)
+
+    def tearDown(self):
+        os.remove(self.secret)
+
+    def _url(self, path):
+        return f"http://127.0.0.1:{self.port}{path}"
+
+    # --- SSRF ---------------------------------------------------------- #
+    def test_default_blocks_loopback_ssrf_via_img_and_link(self):
+        html = f'<link rel="stylesheet" href="{self._url("/css")}"><img src="{self._url("/img")}">'
+        HtmlToDocx().add_html_to_document(html, Document())
+        self.assertEqual(_Handler.hits, [])
+
+    def test_default_blocks_metadata_and_private_ips(self):
+        for url in (
+            "http://169.254.169.254/latest/meta-data/",
+            "http://10.0.0.1/",
+            "http://192.168.0.1/",
+            "http://[::1]/",
+            "http://[::ffff:127.0.0.1]/",
+            "http://0.0.0.0/",
+            "http://localhost/",
+        ):
+            with self.subTest(url=url), self.assertRaises(resources.BlockedResourceError):
+                resources._fetch_remote_bytes(url, resources.ResourcePolicy())
+
+    def test_redirect_to_private_address_is_blocked(self):
+        # Simulates a public first hop by allowing only the first connection.
+        target = self._url("/secret")
+        real = resources._guarded_create_connection
+        calls = {"n": 0}
+
+        def first_hop_allowed(address, *args, **kwargs):
+            calls["n"] += 1
+            if calls["n"] == 1:
+                return socket.create_connection(address, *args[:1])
+            return real(address, *args, **kwargs)
+
+        with mock.patch.object(resources, "_guarded_create_connection", first_hop_allowed):
+            result = resources.fetch_external_css(self._url(f"/redirect?to={target}"))
+        self.assertIsNone(result)
+        self.assertEqual(_Handler.hits, ["/redirect?to=" + target])
+
+    def test_non_http_schemes_are_blocked(self):
+        for src in ("ftp://example.com/a.css", "gopher://127.0.0.1:70/", "jar:file:///x!/y"):
+            with self.subTest(src=src):
+                self.assertIsNone(resources.fetch_external_css(src))
+
+    def test_opt_in_private_network(self):
+        policy = resources.ResourcePolicy(allow_private_network=True)
+        self.assertEqual(resources.fetch_external_css(self._url("/css"), policy), "p { color: red; }")
+
+    def test_remote_can_be_disabled(self):
+        parser = HtmlToDocx()
+        parser.options["allow-remote-resources"] = False
+        parser.options["allow-private-network"] = True
+        parser.add_html_to_document(f'<img src="{self._url("/img")}">', Document())
+        self.assertEqual(_Handler.hits, [])
+
+    def test_max_size_enforced(self):
+        policy = resources.ResourcePolicy(allow_private_network=True, max_bytes=5)
+        self.assertIsNone(resources.fetch_external_css(self._url("/css"), policy))
+
+    # --- Private network allowlist ----------------------------------- #
+    def test_allowlist_allows_listed_private_ip(self):
+        policy = resources.ResourcePolicy(private_network_allowlist=["127.0.0.1/32"])
+        self.assertEqual(resources.fetch_external_css(self._url("/css"), policy), "p { color: red; }")
+
+    def test_allowlist_via_options(self):
+        parser = HtmlToDocx()
+        parser.options["private-network-allowlist"] = ["127.0.0.1"]
+        parser.add_html_to_document(f'<link rel="stylesheet" href="{self._url("/css")}"><p>x</p>', Document())
+        self.assertEqual(_Handler.hits, ["/css"])
+
+    def test_allowlist_does_not_open_other_private_ips(self):
+        allowlist = resources._parse_allowlist(["10.0.5.0/24"])
+        self.assertFalse(resources._is_forbidden_ip("10.0.5.20", allowlist))
+        self.assertTrue(resources._is_forbidden_ip("10.0.6.1", allowlist))
+        self.assertTrue(resources._is_forbidden_ip("127.0.0.1", allowlist))
+        self.assertFalse(resources._is_forbidden_ip("8.8.8.8", allowlist))  # public still allowed
+
+    def test_allow_private_network_takes_precedence_over_allowlist(self):
+        # 127.0.0.1 is NOT in the allowlist, but allow-private-network=True opens everything
+        parser = HtmlToDocx()
+        parser.options["allow-private-network"] = True
+        parser.options["private-network-allowlist"] = ["10.0.5.20"]
+        parser.add_html_to_document(f'<link rel="stylesheet" href="{self._url("/css")}"><p>x</p>', Document())
+        self.assertEqual(_Handler.hits, ["/css"])
+
+    def test_allowlist_alone_does_not_open_unlisted_private_ip(self):
+        parser = HtmlToDocx()
+        parser.options["private-network-allowlist"] = ["10.0.5.20"]
+        parser.add_html_to_document(f'<link rel="stylesheet" href="{self._url("/css")}"><p>x</p>', Document())
+        self.assertEqual(_Handler.hits, [])
+
+    def test_disabling_remote_overrides_all_network_options(self):
+        parser = HtmlToDocx()
+        parser.options["allow-remote-resources"] = False
+        parser.options["allow-private-network"] = True
+        parser.options["private-network-allowlist"] = ["127.0.0.1"]
+        parser.add_html_to_document(f'<link rel="stylesheet" href="{self._url("/css")}"><p>x</p>', Document())
+        self.assertEqual(_Handler.hits, [])
+
+    def test_warns_when_allow_private_network_and_allowlist_are_combined(self):
+        with self.assertLogs("html4docx.resources", level="WARNING") as logs:
+            resources.ResourcePolicy(allow_private_network=True, private_network_allowlist=["10.0.5.20"])
+        self.assertTrue(any("'private-network-allowlist' is ignored" in line for line in logs.output))
+
+    def test_warns_when_combined_through_parser_options(self):
+        parser = HtmlToDocx()
+        parser.options["allow-private-network"] = True
+        parser.options["private-network-allowlist"] = ["10.0.5.20"]
+        with self.assertLogs("html4docx.resources", level="WARNING") as logs:
+            parser._resource_policy()
+        self.assertTrue(any("'private-network-allowlist' is ignored" in line for line in logs.output))
+
+    def test_no_warning_when_only_one_network_option_is_used(self):
+        cases = {
+            "only allow-private-network": {"allow_private_network": True},
+            "only private-network-allowlist": {"private_network_allowlist": ["10.0.5.20"]},
+            "neither (defaults)": {},
+        }
+        for name, kwargs in cases.items():
+            with self.subTest(name):
+                # assertNoLogs needs Python 3.10+, so patch the logger to stay compatible with 3.9
+                with mock.patch.object(resources.logger, "warning") as warning:
+                    resources.ResourcePolicy(**kwargs)
+                warning.assert_not_called()
+
+    def test_invalid_allowlist_entry_fails_fast(self):
+        with self.assertRaises(ValueError):
+            resources.ResourcePolicy(private_network_allowlist=["not-an-ip"])
+
+    # --- Local files --------------------------------------------------- #
+    def test_default_blocks_local_files(self):
+        file_url = "file://localhost/" + self.secret.replace("\\", "/").lstrip("/")
+        self.assertIsNone(resources.fetch_external_css(file_url))
+        self.assertIsNone(resources.fetch_external_css(self.secret))
+        self.assertIsNone(resources.fetch_image_data(TEST_IMG))
+
+    def test_local_files_confined_to_root(self):
+        policy = resources.ResourcePolicy(local_files_root=test_dir)
+        self.assertIsNotNone(resources.fetch_image_data(TEST_IMG, policy))
+        self.assertIsNotNone(resources.fetch_image_data("assets/images/test_img.png", policy))
+        self.assertIsNone(resources.fetch_external_css(self.secret, policy))
+        self.assertIsNone(resources.fetch_external_css("../../../../../../etc/passwd", policy))
+        self.assertIsNone(resources.fetch_external_css("file:///etc/passwd", policy))
+        self.assertIsNone(resources.fetch_external_css("file://otherhost/etc/passwd", policy))
+
+    def test_local_root_via_options(self):
+        parser = HtmlToDocx()
+        parser.options["local-files-root"] = test_dir
+        doc = parser.parse_html_string(f'<img src="{TEST_IMG}">')
+        self.assertEqual(len(doc.inline_shapes), 1)
+
+        parser = HtmlToDocx()
+        doc = parser.parse_html_string(f'<img src="{TEST_IMG}">')
+        self.assertEqual(len(doc.inline_shapes), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()