diff --git a/.github/workflows/cross_platform_tests.yml b/.github/workflows/cross_platform_tests.yml index dce2798..51f1d85 100644 --- a/.github/workflows/cross_platform_tests.yml +++ b/.github/workflows/cross_platform_tests.yml @@ -3,8 +3,8 @@ name: Cross-Platform Tests on: push: branches: [ main, master ] - pull_request: - branches: [ main, master ] + tags: + - 'v*.*.*' # Only trigger on tags like v1.0.0, v1.2.3 workflow_dispatch: # Allows manual triggering # Add this section to control notification behavior @@ -25,8 +25,8 @@ jobs: strategy: fail-fast: false # Continue with other jobs if one fails matrix: - os: [ubuntu-latest, macos-latest] - python-version: ['3.11'] + os: [ubuntu-22.04] + python-version: ['3.11', '3.12'] steps: - uses: actions/checkout@v4 @@ -66,6 +66,12 @@ jobs: echo "VIRTUAL_ENV=$PWD/.venv" >> $GITHUB_ENV echo "$PWD/.venv/bin" >> $GITHUB_PATH + - name: Install system dependencies + run: | + sudo apt-get update + sudo apt-get install -y libssl-dev pkg-config build-essential + shell: bash + - name: Install dependencies run: | python -m pip install --upgrade pip @@ -76,24 +82,24 @@ jobs: - name: Build and install package with maturin uses: PyO3/maturin-action@v1 with: - python-interpreter: ${{ steps.setup_python.outputs.python-path }} - target: ${{ matrix.os == 'macos-latest' && 'universal2-apple-darwin' || 'x86_64' }} + target: x86_64 command: develop args: --release sccache: 'true' - - name: Run tests - run: python run_tests.py + - name: Run API tests only + run: python run_tests.py --api-only continue-on-error: true # Continue even if tests fail to get wheels - name: Build wheel uses: PyO3/maturin-action@v1 with: - python-interpreter: ${{ steps.setup_python.outputs.python-path }} - target: ${{ matrix.os == 'macos-latest' && 'universal2-apple-darwin' || 'x86_64' }} + target: x86_64 command: build args: --release sccache: 'true' + env: + OPENSSL_NO_VENDOR: 1 - name: Upload wheels uses: actions/upload-artifact@v4 @@ -117,8 +123,46 @@ jobs: run: find wheels -type f -name "*.whl" | sort shell: bash + - name: Flatten wheel structure + run: | + mkdir -p dist + find wheels -name "*.whl" -exec cp {} dist/ \; + echo "Files in dist after flattening:" + ls -la dist/ + - name: Upload combined wheels uses: actions/upload-artifact@v4 with: name: all-wheels - path: wheels/*/*.whl \ No newline at end of file + path: dist/*.whl + + publish_to_pypi: + name: Publish Python distributions to PyPI + needs: collect_wheels + runs-on: ubuntu-latest + environment: pypi + # Trigger on tags (releases) OR manual workflow dispatch + if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch' + permissions: + id-token: write # IMPORTANT: this permission is mandatory for trusted publishing + + steps: + - name: Download all wheels + uses: actions/download-artifact@v4 + with: + name: all-wheels + path: dist/ + + - name: List downloaded files + run: | + echo "Files in dist/:" + ls -la dist/ + echo "Checking for .whl files specifically:" + find dist -name "*.whl" -type f + echo "Wheel file details:" + find dist -name "*.whl" -type f -exec basename {} \; + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + + \ No newline at end of file diff --git a/.gitignore b/.gitignore index 3585a11..69c7aab 100644 --- a/.gitignore +++ b/.gitignore @@ -40,4 +40,7 @@ wheels/ .env .venv venv/ -ENV/ \ No newline at end of file +ENV/ + +# Cursor rules +.cursorrules \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 2254bf6..2a3a18f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,16 +1,22 @@ [package] -name = "fast_c2pa_reader" +name = "fast-c2pa-python" version = "0.1.0" edition = "2021" +authors = ["Sightengine "] +license = "MIT OR Apache-2.0" +description = "Fast Python library for reading C2PA metadata using PyO3 bindings to c2pa-rs" +keywords = ["c2pa", "metadata", "python", "bindings"] [lib] -name = "fast_c2pa_reader" +name = "fast_c2pa_core" crate-type = ["cdylib"] [dependencies] c2pa = { version = "0.49.5", features = ["file_io"] } pyo3 = { version = "0.19.0", features = ["extension-module"] } serde_json = "1.0" +log = "0.4" +image = "0.25.6" # Optimize for performance in release builds [profile.release] @@ -19,4 +25,4 @@ lto = "fat" # Link-time optimization codegen-units = 1 # Slower build, better optimization panic = "abort" # Remove unwinding code strip = true # Strip symbols from binary -debug = false # No debug info \ No newline at end of file +debug = false # No debug info diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9a9b455 --- /dev/null +++ b/LICENSE @@ -0,0 +1,196 @@ +MIT License + +Copyright (c) 2025 Sightengine + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +================================================================================ + +This project incorporates the c2pa-rs library (https://github.com/contentauth/c2pa-rs) +Copyright (c) Content Authenticity Initiative contributors +which is dual-licensed under MIT and Apache 2.0 licenses. + +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (which may include materials held in the "License Appendix"). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based upon (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and derivative works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control + systems, and issue tracking systems that are managed by, or on behalf + of, the Licensor for the purpose of discussing and improving the Work, + but excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to use, reproduce, modify, display, perform, + sublicense, and distribute the Work and such Derivative Works in + Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, trademark, patent, + attribution and other notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright notice regarding Your contributions. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Support. You may choose to offer, and charge a + fee for, warranty, support, indemnity or other liability obligations + and/or rights consistent with this License. However, in accepting such + obligations, You may act only on Your own behalf and on Your sole + responsibility, not on behalf of any other Contributor, and only if + You agree to indemnify, defend, and hold each Contributor harmless for + any liability incurred by, or claims asserted against, such Contributor + by reason of your accepting any such warranty or support. + +END OF TERMS AND CONDITIONS \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..01de19d --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +dev: + maturin develop + +dev-release: + maturin develop --release + +test: dev + python -m pytest tests/ -v + +test-perf: dev-release + python -m pytest tests/test_performance.py -s -v + +test-api: dev + python -m pytest tests/test_api.py -s -v + +clean: + cargo clean + rm -rf target/ \ No newline at end of file diff --git a/README.md b/README.md index 7ba219b..4998f84 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ -# fast_c2pa_reader +# fast-c2pa-python -A high-performance Python library for reading C2PA metadata. +A Python library for reading C2PA metadata based on c2pa-rs ## Overview -This library provides extremely fast C2PA metadata extraction from digital assets using direct PyO3 bindings to the Rust C2PA implementation. It was created to address performance bottlenecks in existing Python C2PA libraries. +This library provides fast C2PA metadata extraction from digital assets using direct PyO3 bindings to the Rust C2PA implementation. It was created to address performance bottlenecks in existing Python C2PA libraries. > **Note:** This library is designed for reading C2PA metadata only. It does not support writing or creating C2PA metadata at this time. @@ -12,15 +12,15 @@ This library provides extremely fast C2PA metadata extraction from digital asset | Implementation | Average Read Time | | -------------- | ---------------- | -| c2pa-python (UniFFI) | ~486ms | +| c2pa-python (UniFFI) v8 | ~486ms | | numbers-c2pa | ~17ms | -| fast_c2pa_reader (PyO3) | ~8ms | +| fast-c2pa-python (PyO3) | ~8ms | | Native Rust | ~7ms | ## Installation ```bash -pip install fast-c2pa-reader +pip install fast-c2pa-python ``` ## Usage @@ -28,7 +28,7 @@ pip install fast-c2pa-reader ### Basic Usage ```python -from fast_c2pa_reader import read_c2pa_from_file +from fast_c2pa_python import read_c2pa_from_file # Read C2PA metadata from a file (with automatic MIME type detection) metadata = read_c2pa_from_file("path/to/image.jpg") @@ -41,7 +41,7 @@ metadata = read_c2pa_from_file("path/to/image.jpg", "image/jpeg") ### Reading from Binary Data ```python -from fast_c2pa_reader import read_c2pa_from_bytes +from fast_c2pa_python import read_c2pa_from_bytes # From HTTP response or other binary source response = requests.get("https://example.com/image.jpg") @@ -73,7 +73,7 @@ with open("path/to/image.jpg", "rb") as f: ## Testing -The library includes both API compatibility tests and performance benchmarks to ensure functionality and speed. +The library includes API compatibility tests to ensure functionality. ### Running Tests @@ -83,10 +83,10 @@ Install test dependencies: pip install -r tests/requirements.txt ``` -Run all tests: +Run API tests: ```bash -python run_tests.py +python run_tests.py --api-only ``` ## Development @@ -115,9 +115,21 @@ maturin build --release Wheel files are generated in the `target/wheels/` directory and can be shared directly with users who can install them using pip: ```bash -pip install /path/to/fast_c2pa_reader-x.x.x-cp3xx-cp3xx-platform.whl +pip install /path/to/fast_c2pa_python-x.x.x-cp3xx-cp3xx-platform.whl ``` ## License -MIT \ No newline at end of file +This project is dual-licensed under both MIT and Apache 2.0 licenses to ensure compatibility with the underlying c2pa-rs library. + +## Attribution + +This library is built upon the excellent work of the [c2pa-rs](https://github.com/contentauth/c2pa-rs) library by the Content Authenticity Initiative. The c2pa-rs library provides the core C2PA implementation in Rust, and this project creates Python bindings using PyO3 for improved performance. + +**Developed by:** [Sightengine](https://sightengine.com) - AI-powered content moderation + +**Key Dependencies:** +- [c2pa-rs](https://github.com/contentauth/c2pa-rs) - Core C2PA implementation +- [PyO3](https://github.com/PyO3/pyo3) - Rust bindings for Python + +Special thanks to the Content Authenticity Initiative and the c2pa-rs contributors for their foundational work on C2PA standards and implementation. \ No newline at end of file diff --git a/benchmark_c2pa_python.py b/benchmark_c2pa_python.py index 9144246..031d823 100644 --- a/benchmark_c2pa_python.py +++ b/benchmark_c2pa_python.py @@ -60,6 +60,6 @@ def benchmark_c2pa_python(image_path, iterations=200): print(f" Max time: {max_time_full:.3f}ms") if __name__ == "__main__": - # Use the same test image as in the fast_c2pa_reader benchmark + # Use the same test image as in the fast_c2pa_python benchmark image_path = "./tests/test_images/adobe_firefly_image.jpg" benchmark_c2pa_python(image_path, 10) \ No newline at end of file diff --git a/benchmark_fastc2pa.py b/benchmark_fastc2pa.py index d4f9e2d..7d3f7c1 100644 --- a/benchmark_fastc2pa.py +++ b/benchmark_fastc2pa.py @@ -1,7 +1,28 @@ import time import statistics import json -import fast_c2pa_reader +from pathlib import Path +import fast_c2pa_python +from fast_c2pa_python import setup_trust_verification + +def setup_trust_if_available(): + """Setup trust verification if config files are available.""" + trust_dir = Path("./tests/tmp_cert") + anchors_file = trust_dir / "anchors.pem" + allowed_file = trust_dir / "allowed.pem" + config_file = trust_dir / "store.cfg" + + if all(f.exists() for f in [anchors_file, allowed_file, config_file]): + try: + setup_trust_verification(str(anchors_file), str(allowed_file), str(config_file)) + print("Trust verification enabled") + return True + except Exception as e: + print(f"Failed to setup trust: {e}") + return False + else: + print("Trust files not found, running without trust verification") + return False def benchmark_c2pa_read(image_path, iterations=200): print(f"\nRunning FAST C2PA reading benchmark over {iterations} iterations...") @@ -12,7 +33,7 @@ def benchmark_c2pa_read(image_path, iterations=200): data = f.read() print(f"File read complete. Size: {len(data)} bytes") - result = fast_c2pa_reader.read_c2pa_from_bytes(data, "image/jpeg", allow_threads=True) + result = fast_c2pa_python.read_c2pa_from_bytes(data, "image/jpeg", allow_threads=True) if result: print("\nC2PA Data Found (full data):") print(f" Title: {result.get('title')}") @@ -31,7 +52,7 @@ def benchmark_c2pa_read(image_path, iterations=200): times_full = [] for i in range(iterations): start_time = time.perf_counter() - fast_c2pa_reader.read_c2pa_from_bytes(data, "image/jpeg", allow_threads=True) + fast_c2pa_python.read_c2pa_from_bytes(data, "image/jpeg", allow_threads=True) duration = (time.perf_counter() - start_time) * 1000 # Convert to milliseconds times_full.append(duration) print(f"Iteration {i + 1}: {duration:.3f}ms") @@ -49,6 +70,9 @@ def benchmark_c2pa_read(image_path, iterations=200): print(f" Max time: {max_time_full:.3f}ms") if __name__ == "__main__": + # Setup trust verification if available + setup_trust_if_available() + # Replace with your image path image_path = "./tests/test_images/adobe_firefly_image.jpg" benchmark_c2pa_read(image_path) \ No newline at end of file diff --git a/fast_c2pa_python/__init__.py b/fast_c2pa_python/__init__.py new file mode 100644 index 0000000..946f01b --- /dev/null +++ b/fast_c2pa_python/__init__.py @@ -0,0 +1,48 @@ +import mimetypes +from fast_c2pa_core import read_c2pa_from_bytes, load_c2pa_settings, convert_to_gray_keep_c2pa +import json +from pathlib import Path + +__all__ = ["read_c2pa_from_file", "read_c2pa_from_bytes", "get_mime_type", "setup_trust_verification", "convert_to_gray_keep_c2pa"] + +def get_mime_type(file_path): + """Get MIME type of file""" + mime_type, _ = mimetypes.guess_type(file_path) + return mime_type or "application/octet-stream" + +def read_c2pa_from_file(file_path, mime_type=None, allow_threads=True): + """Read C2PA data from file using Rust core""" + # Determine MIME type if not provided + effective_mime_type = mime_type if mime_type else get_mime_type(file_path) + + with open(file_path, 'rb') as f: + return read_c2pa_from_bytes(f.read(), effective_mime_type, allow_threads) + +def build_trust_settings_from_files(anchors_path, allowed_path, config_path): + """Build trust settings from three config files""" + try: + anchors = Path(anchors_path).read_text() + allowed = Path(allowed_path).read_text() + config = Path(config_path).read_text() + + settings = { + "verify": { + "verify_trust": True + }, + "trust": { + "trust_anchors": anchors, + "allowed_list": allowed, + "trust_config": config + } + } + + return json.dumps(settings) + except FileNotFoundError as e: + raise FileNotFoundError(f"Trust config file not found: {e}") + except Exception as e: + raise RuntimeError(f"Error building trust settings: {e}") + +def setup_trust_verification(anchors_path, allowed_path, config_path): + """Setup global C2PA trust settings""" + settings = build_trust_settings_from_files(anchors_path, allowed_path, config_path) + load_c2pa_settings(settings) \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3330445..5b11fd4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,18 +3,24 @@ requires = ["maturin>=1.8.3"] build-backend = "maturin" [project] -name = "fast_c2pa_reader" -version = "0.1.0" -requires-python = ">=3.10" +name = "fast-c2pa-python" +version = "0.1.3" +description = "Fast Python library for reading C2PA metadata using PyO3 bindings to c2pa-rs" +authors = [{name = "Sightengine", email = "info@sightengine.com"}] +license = {text = "MIT OR Apache-2.0"} +readme = "README.md" +keywords = ["c2pa", "metadata", "python", "bindings"] +requires-python = ">=3.11" classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", "Programming Language :: Rust", "Programming Language :: Python :: Implementation :: CPython", - "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", "License :: OSI Approved :: MIT License", + "License :: OSI Approved :: Apache Software License", "Operating System :: POSIX :: Linux", - "Operating System :: MacOS", - "Operating System :: Microsoft :: Windows", ] [tool.maturin] diff --git a/run_tests.py b/run_tests.py index c0efee6..2f723b9 100644 --- a/run_tests.py +++ b/run_tests.py @@ -1,6 +1,6 @@ #!/usr/bin/env python """ -Test runner for fast_c2pa_reader. +Test runner for fast_c2pa_python. This script runs both API compatibility tests and performance benchmarks. """ @@ -12,8 +12,8 @@ from pathlib import Path def main(): - """Run tests for fast_c2pa_reader.""" - parser = argparse.ArgumentParser(description="Run tests for fast_c2pa_reader") + """Run tests for fast_c2pa_python.""" + parser = argparse.ArgumentParser(description="Run tests for fast_c2pa_python") parser.add_argument("--api-only", action="store_true", help="Run only API tests") parser.add_argument("--perf-only", action="store_true", help="Run only performance tests") parser.add_argument("--image", type=str, help="Path to test image with C2PA metadata") diff --git a/src/c2pa_reader.rs b/src/c2pa_reader.rs new file mode 100644 index 0000000..d4bcf8a --- /dev/null +++ b/src/c2pa_reader.rs @@ -0,0 +1,67 @@ +use pyo3::prelude::*; +use std::io::Cursor; +use c2pa::{ + Reader, + jumbf_io::load_jumbf_from_stream, +}; +use log::debug; +use pyo3::exceptions::PyRuntimeError; + +/// Read C2PA metadata from a byte array +/// +/// This function parses binary data to extract C2PA metadata, returning a Python +/// dictionary if found. +/// +/// Args: +/// data: Binary data of the file (bytes-like object) +/// mime_type: MIME type of the data (e.g., "image/jpeg") +/// allow_threads: Whether to release the Python GIL during processing (default: True) +/// +/// Returns: +/// A dictionary containing the C2PA data if found, or None if no +/// C2PA metadata is present +/// +/// Raises: +/// RuntimeError: If there is an error reading or parsing the C2PA data +#[pyfunction] +#[pyo3(signature = (data, mime_type, allow_threads=true))] +pub fn read_c2pa_from_bytes( + py: Python, + data: &[u8], + mime_type: &str, + allow_threads: bool, +) -> PyResult> { + // First check if JUMBF data exists before trying to create a Reader + let has_jumbf = { + let mut cursor = Cursor::new(data); + load_jumbf_from_stream(mime_type, &mut cursor).is_ok() + }; + + if !has_jumbf { + // No JUMBF data found + debug!("No JUMBF data found in the provided data"); + return Ok(None); + } + + // JUMBF data exists, proceed with Reader creation + let reader = if allow_threads { + let cursor = Cursor::new(data); + py.allow_threads(|| Reader::from_stream(mime_type, cursor)) + } else { + let cursor = Cursor::new(data); + Reader::from_stream(mime_type, cursor) + }; + + match reader { + Ok(reader) => { + let json_str = reader.json(); + let json_module = PyModule::import(py, "json")?; + let py_json = json_module.getattr("loads")?.call1((json_str,))?; + + Ok(Some(py_json.to_object(py))) + }, + Err(e) => { + Err(PyRuntimeError::new_err(format!("Error reading C2PA data: {}", e))) + } + } +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 3396880..858407d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,160 +1,34 @@ -use c2pa::Reader; -use pyo3::exceptions::PyRuntimeError; +//TODO: Check better way to handle mime + use pyo3::prelude::*; -use std::io::Cursor; +use pyo3::exceptions::PyRuntimeError; -/// A Python module for fast C2PA reading -/// -/// This module provides high-performance functions for reading Content Authenticity -/// Initiative (CAI) C2PA metadata from media files. -#[pymodule] -fn fast_c2pa_reader(_py: Python, m: &PyModule) -> PyResult<()> { - m.add_function(wrap_pyfunction!(read_c2pa_from_bytes, m)?)?; - m.add_function(wrap_pyfunction!(read_c2pa_from_file, m)?)?; - m.add_function(wrap_pyfunction!(get_mime_type, m)?)?; - Ok(()) -} +mod c2pa_reader; +use c2pa_reader::{ + read_c2pa_from_bytes, +}; -/// Determine MIME type from file extension -/// -/// This function uses Python's mimetypes module to determine the MIME type -/// based on the file extension. -/// -/// Args: -/// file_path: Path to the file -/// -/// Returns: -/// A string containing the MIME type if determinable, or None if not -#[pyfunction] -fn get_mime_type(py: Python, file_path: &str) -> PyResult> { - // Import Python's mimetypes module - let mimetypes = PyModule::import(py, "mimetypes")?; - - // Initialize mimetypes if needed - if !mimetypes.getattr("inited")?.extract::()? { - mimetypes.call_method0("init")?; - } - - // Get MIME type from file path - let result = mimetypes.call_method1("guess_type", (file_path,))?; - let mime_type: Option = result.get_item(0)?.extract()?; - - // If MIME type not found, try with common extensions fallback - if mime_type.is_none() { - let path = PyModule::import(py, "os.path")?; - - // Extract file extension - let splitext = path.call_method1("splitext", (file_path,))?; - let ext: String = splitext.get_item(1)?.extract::()?.to_lowercase(); - - // Fallbacks for common image types - match ext.as_str() { - ".jpg" | ".jpeg" => return Ok(Some("image/jpeg".to_string())), - ".png" => return Ok(Some("image/png".to_string())), - ".gif" => return Ok(Some("image/gif".to_string())), - ".webp" => return Ok(Some("image/webp".to_string())), - ".tiff" => return Ok(Some("image/tiff".to_string())), - ".heic" => return Ok(Some("image/heic".to_string())), - _ => {} - } - } - - Ok(mime_type) -} +mod utils; +use utils::{ + convert_to_gray_keep_c2pa +}; -/// Read C2PA metadata from a byte array -/// -/// This function parses binary data to extract C2PA metadata, returning a Python -/// dictionary containing the manifest if found. -/// -/// Args: -/// data: Binary data of the file (bytes-like object) -/// mime_type: MIME type of the data (e.g., "image/jpeg") -/// allow_threads: Whether to release the Python GIL during processing (default: True) -/// -/// Returns: -/// A dictionary containing the C2PA manifest data if found, or None if no -/// C2PA metadata is present -/// -/// Raises: -/// RuntimeError: If there is an error reading or parsing the C2PA data #[pyfunction] -#[pyo3(signature = (data, mime_type, allow_threads=true))] -fn read_c2pa_from_bytes(py: Python, data: &[u8], mime_type: &str, allow_threads: bool) -> PyResult> { - let reader = if allow_threads { - let cursor = Cursor::new(data); - py.allow_threads(|| Reader::from_stream(mime_type, cursor)) - } else { - let cursor = Cursor::new(data); - Reader::from_stream(mime_type, cursor) - }; - match reader { - Ok(reader) => { - // Get the active manifest - if let Some(manifest) = reader.active_manifest() { - let json_str = serde_json::to_string(&manifest) - .unwrap_or_else(|_| String::from("{}")); - - // Convert to Python object - let json_module = PyModule::import(py, "json")?; - let py_json = json_module.getattr("loads")?.call1((json_str,))?; - - Ok(Some(py_json.to_object(py))) - } else { - // No active manifest found - Ok(None) - } - }, - Err(e) => { - // Ok if Error is missing JUMBF data - if e.to_string().contains("no JUMBF data found") { - // TODO: rely on error message is fragile - Ok(None) - } else { - // Error reading C2PA data - Err(PyRuntimeError::new_err(format!("Error reading C2PA data: {}", e))) - } - } +pub fn load_c2pa_settings(settings_json: &str) -> PyResult<()> { + match c2pa::settings::load_settings_from_str(settings_json, "json") { + Ok(_) => Ok(()), + Err(e) => Err(PyRuntimeError::new_err(format!("Error loading C2PA settings: {}", e))) } } -/// Read C2PA metadata from a file -/// -/// This function reads a file from disk and extracts C2PA metadata, returning a Python -/// dictionary containing the manifest if found. -/// -/// Args: -/// file_path: Path to the file to read -/// mime_type: MIME type of the file (e.g., "image/jpeg"). If None or empty, -/// it will be automatically determined from the file extension. -/// allow_threads: Whether to release the Python GIL during processing (default: True) -/// -/// Returns: -/// A dictionary containing the C2PA manifest data if found, or None if no -/// C2PA metadata is present +/// A Python module for fast C2PA reading /// -/// Raises: -/// RuntimeError: If there is an error reading or parsing the C2PA data -#[pyfunction] -#[pyo3(signature = (file_path, mime_type=None, allow_threads=true))] -fn read_c2pa_from_file(py: Python, file_path: &str, mime_type: Option<&str>, allow_threads: bool) -> PyResult> { - // Determine the MIME type if not provided or empty - let effective_mime_type = match mime_type { - Some(mime) if !mime.trim().is_empty() => mime.to_string(), - _ => match get_mime_type(py, file_path)? { - Some(mime) => mime, - None => return Err(PyRuntimeError::new_err(format!("Could not determine MIME type for file: {}", file_path))) - } - }; - - // Read the file into memory - match std::fs::read(file_path) { - Ok(data) => { - // Reuse the existing function to process the bytes - read_c2pa_from_bytes(py, &data, &effective_mime_type, allow_threads) - }, - Err(e) => { - Err(PyRuntimeError::new_err(format!("Error reading file: {}", e))) - } - } +/// This module provides high-performance functions for reading Content Authenticity +/// Initiative (CAI) C2PA metadata from media files. +#[pymodule] +fn fast_c2pa_core(_py: Python, m: &PyModule) -> PyResult<()> { + m.add_function(wrap_pyfunction!(read_c2pa_from_bytes, m)?)?; + m.add_function(wrap_pyfunction!(load_c2pa_settings, m)?)?; + m.add_function(wrap_pyfunction!(convert_to_gray_keep_c2pa, m)?)?; + Ok(()) } \ No newline at end of file diff --git a/src/utils.rs b/src/utils.rs new file mode 100644 index 0000000..9ea861d --- /dev/null +++ b/src/utils.rs @@ -0,0 +1,42 @@ +use std::io::Cursor; +use c2pa::jumbf_io::{load_jumbf_from_stream, save_jumbf_to_stream}; +use pyo3::prelude::*; +use pyo3::pyfunction; +use pyo3::exceptions::PyRuntimeError; + +#[pyfunction] +pub fn convert_to_gray_keep_c2pa( + input_path: &str, + output_path: &str, + format: &str, +) -> PyResult<()> { + // 1. Read and extract JUMBF (C2PA data) + let mut source = std::fs::File::open(input_path) + .map_err(|e| PyRuntimeError::new_err(format!("Failed to open file: {}", e)))?; + + let jumbf = load_jumbf_from_stream(format, &mut source) + .map_err(|e| PyRuntimeError::new_err(format!("Failed to load JUMBF: {}", e)))?; + + // 2. Convert to grayscale + let input_img = image::open(input_path) + .map_err(|e| PyRuntimeError::new_err(format!("Failed to open input path: {}", e)))?; + + let output_img = input_img.grayscale(); + output_img.save(output_path) + .map_err(|e| PyRuntimeError::new_err(format!("Failed to save output file: {}", e)))?; + + + // 3. Write back JUMBF + let image = std::fs::read(output_path)?; + let mut dest = std::fs::File::create(output_path)?; + save_jumbf_to_stream( + format, + &mut Cursor::new(image), + &mut dest, + &jumbf + ) + .map_err(|e| PyRuntimeError::new_err(format!("Failed to save output with jumbf: {}", e)))?; + + Ok(()) +} + diff --git a/tests/requirements.txt b/tests/requirements.txt index c73c978..30858f6 100644 --- a/tests/requirements.txt +++ b/tests/requirements.txt @@ -2,4 +2,5 @@ pytest>=7.0.0 pytest-benchmark>=4.0.0 statistics>=1.0.3.5 c2pa-python==0.8.3 -cryptography==44.0.3 \ No newline at end of file +cryptography==44.0.3 +pytest-order \ No newline at end of file diff --git a/tests/test_api.py b/tests/test_api.py index 303c442..db5d507 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -1,5 +1,5 @@ """ -API compatibility tests for fast_c2pa_reader. +API compatibility tests for fast_c2pa_python. These tests verify that our implementation correctly reads C2PA metadata and maintains compatibility with expected output formats. @@ -11,46 +11,197 @@ import mimetypes from pathlib import Path -# Import the implementation -from fast_c2pa_reader import read_c2pa_from_bytes, read_c2pa_from_file, get_mime_type +from fast_c2pa_python import read_c2pa_from_bytes, read_c2pa_from_file, get_mime_type, setup_trust_verification -# Test image path - update this to point to a test image with C2PA metadata +# Test images - both JPEG and PNG formats TEST_IMAGES_DIR = Path(__file__).parent / "test_images" -# TEST_IMAGE = str(TEST_IMAGES_DIR / "adobe_firefly_image.jpg") -TEST_IMAGE = str(TEST_IMAGES_DIR / "chatgpt_image.png") +TEST_IMAGES = [ + str(TEST_IMAGES_DIR / "chatgpt_image.png"), + str(TEST_IMAGES_DIR / "adobe_firefly_image.jpg") +] TEST_IMAGE_NOT_C2PA = str(TEST_IMAGES_DIR / "screenshot_noc2pa.png") -@pytest.fixture(scope="session") -def setup_test_image_bytes(): - """Ensure test images directory exists and return image bytes.""" +# Trust settings files +TRUST_ANCHORS_FILE = str(Path(__file__).parent / "tmp_cert" / "anchors.pem") +TRUST_ALLOWED_FILE = str(Path(__file__).parent / "tmp_cert" / "allowed.pem") +TRUST_CONFIG_FILE = str(Path(__file__).parent / "tmp_cert" / "store.cfg") + +@pytest.fixture(scope="session", params=TEST_IMAGES) +def setup_test_image_bytes(request): + """Ensure test images directory exists and return image bytes for each test image.""" TEST_IMAGES_DIR.mkdir(exist_ok=True) - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + test_image = request.param + + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") # Read file into bytes - with open(TEST_IMAGE, "rb") as f: - image_bytes_firefly = f.read() + with open(test_image, "rb") as f: + image_bytes = f.read() - return image_bytes_firefly, get_mime_type(TEST_IMAGE) + return image_bytes, get_mime_type(test_image), test_image + +def get_active_manifest(metadata): + """Helper function to get the active manifest from c2pa structure.""" + if not metadata or "active_manifest" not in metadata or "manifests" not in metadata: + return None + active_manifest_id = metadata["active_manifest"] + return metadata["manifests"].get(active_manifest_id) + +def has_trust_files(): + """Check if trust configuration files exist.""" + return (os.path.exists(TRUST_ANCHORS_FILE) and + os.path.exists(TRUST_ALLOWED_FILE) and + os.path.exists(TRUST_CONFIG_FILE)) + +def setup_trust_settings(): + """Configure trust settings for C2PA validation.""" + if not has_trust_files(): + return False + + try: + setup_trust_verification(TRUST_ANCHORS_FILE, TRUST_ALLOWED_FILE, TRUST_CONFIG_FILE) + return True + except Exception as e: + print(f"Failed to setup trust settings: {e}") + return False def test_read_c2pa_from_bytes(setup_test_image_bytes): """Test reading C2PA metadata from bytes.""" - image_bytes, mime_type = setup_test_image_bytes + image_bytes, mime_type, test_image = setup_test_image_bytes + + print(f"Testing {test_image} with MIME type {mime_type}") # Read metadata from bytes metadata = read_c2pa_from_bytes(image_bytes, mime_type) - # Basic validation + # Basic validation - check c2pa structure assert metadata is not None - assert "title" in metadata or "generator" in metadata or "claim_generator" in metadata + assert "active_manifest" in metadata + assert "manifests" in metadata + + # Get active manifest + active_manifest = get_active_manifest(metadata) + assert active_manifest is not None + assert "title" in active_manifest or "generator" in active_manifest or "claim_generator" in active_manifest # Verify signature info exists if the file has valid C2PA data - if "signature_info" in metadata: - assert "issuer" in metadata["signature_info"] + if "signature_info" in active_manifest: + assert "issuer" in active_manifest["signature_info"] + +@pytest.mark.parametrize("test_image", TEST_IMAGES) +@pytest.mark.order(1) # Run this test early before any trust setup +def test_validation_state_without_trust(test_image): + """Test that validation_state is 'Valid' when no trust settings are configured.""" + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + # This test should only run if trust hasn't been configured yet + # We'll check this by reading metadata and seeing the state + metadata = read_c2pa_from_file(test_image) + + if metadata is None: + pytest.skip(f"No C2PA metadata found in {test_image}") + + # If trust was already configured by previous tests, skip this test + if metadata["validation_state"] == "Trusted": + pytest.skip("Trust settings already configured globally - cannot test without trust") + + # Verify validation_state is 'Valid' + assert "validation_state" in metadata + assert metadata["validation_state"] == "Valid", f"Expected 'Valid' but got '{metadata['validation_state']}'" + + # Verify no signingCredential.trusted validation result + if "validation_results" in metadata and "activeManifest" in metadata["validation_results"]: + success_results = metadata["validation_results"]["activeManifest"].get("success", []) + trusted_results = [r for r in success_results if r.get("code") == "signingCredential.trusted"] + assert len(trusted_results) == 0, "Should not have signingCredential.trusted without trust settings" + +@pytest.mark.parametrize("test_image", TEST_IMAGES) +@pytest.mark.order(2) # Run after the without-trust test +def test_validation_state_with_trust(test_image): + """Test that validation_state is 'Trusted' when trust settings are configured.""" + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + if not has_trust_files(): + pytest.skip("Trust configuration files not found - cannot test trust validation") + + # Configure trust settings + if not setup_trust_settings(): + pytest.skip("Could not configure trust settings") + + # Read metadata with trust settings + metadata = read_c2pa_from_file(test_image) + + if metadata is None: + pytest.skip(f"No C2PA metadata found in {test_image}") + + # Verify validation_state is 'Trusted' + assert "validation_state" in metadata + assert metadata["validation_state"] == "Trusted", ( + f"Expected validation_state 'Trusted' but got '{metadata['validation_state']}'" + ) + + # Verify signingCredential.trusted validation result is present + if "validation_results" in metadata and "activeManifest" in metadata["validation_results"]: + success_results = metadata["validation_results"]["activeManifest"].get("success", []) + trusted_results = [r for r in success_results if r.get("code") == "signingCredential.trusted"] + assert len(trusted_results) >= 1, ( + "Should have at least one signingCredential.trusted validation result with trust settings" + ) + + # Verify the trusted result has correct structure + trusted_result = trusted_results[0] + assert "url" in trusted_result + assert "explanation" in trusted_result + +@pytest.mark.parametrize("test_image", TEST_IMAGES) +@pytest.mark.order(3) # Run after trust is configured +def test_trust_enables_additional_validation(test_image): + """Test that trust settings add the signingCredential.trusted validation result.""" + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + if not has_trust_files(): + pytest.skip("Trust configuration files not found - cannot test trust validation") + + # Ensure trust is configured (should be from previous test) + if not setup_trust_settings(): + pytest.skip("Could not configure trust settings") + + metadata = read_c2pa_from_file(test_image) + + if metadata is None: + pytest.skip(f"No C2PA metadata found in {test_image}") + + # With trust settings, validation_state must be "Trusted" + assert metadata["validation_state"] == "Trusted" + + if "validation_results" in metadata and "activeManifest" in metadata["validation_results"]: + success_results = metadata["validation_results"]["activeManifest"].get("success", []) + + # Check that signingCredential.trusted is present + trusted_results = [r for r in success_results if r.get("code") == "signingCredential.trusted"] + assert len(trusted_results) >= 1, "Trust settings should add signingCredential.trusted validation" + + # Check that we have the standard validation results plus the trust one + validation_codes = {r.get("code") for r in success_results} + expected_codes = { + "claimSignature.insideValidity", + "claimSignature.validated", + "assertion.hashedURI.match", + "assertion.dataHash.match", + "signingCredential.trusted" # This should be added by trust settings + } + + # All expected codes should be present (may have multiple assertion.hashedURI.match) + for code in expected_codes: + assert code in validation_codes, f"Missing expected validation code: {code}" def test_mime_type_handling(setup_test_image_bytes): """Test handling of different MIME types.""" - image_bytes, correct_mime_type = setup_test_image_bytes + image_bytes, correct_mime_type, test_image = setup_test_image_bytes # Test with correct MIME type result_correct = read_c2pa_from_bytes(image_bytes, correct_mime_type) @@ -66,11 +217,11 @@ def test_mime_type_handling(setup_test_image_bytes): # Or it raises an exception, which is also acceptable pass -def test_error_handling_invalid_bytes(): +def test_no_jumbf_data(): """Test error handling with invalid data.""" - # Test with invalid bytes - with pytest.raises(Exception): - read_c2pa_from_bytes(b"invalid data", "image/jpeg") + # Test with invalid bytes - should return None instead of raising exception + result = read_c2pa_from_bytes(b"no jumbf data", "image/jpeg") + assert result is None def test_error_handling_no_c2pa(): """Test with data that has no C2PA metadata.""" @@ -90,19 +241,22 @@ def test_error_handling_no_c2pa(): result = read_c2pa_from_bytes(image_bytes, mime_type) assert result is None -def test_thread_safety(): +@pytest.mark.parametrize("test_image", TEST_IMAGES) +def test_thread_safety(test_image): """Test thread safety option.""" - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") # Read test image - with open(TEST_IMAGE, "rb") as f: + with open(test_image, "rb") as f: image_bytes = f.read() # Get MIME type - mime_type = get_mime_type(TEST_IMAGE) + mime_type = get_mime_type(test_image) if not mime_type: - pytest.skip(f"Could not determine MIME type for {TEST_IMAGE}") + pytest.skip(f"Could not determine MIME type for {test_image}") + + print(f"Testing thread safety for {test_image} with MIME type {mime_type}") # Test with allow_threads=True (default) result_threaded = read_c2pa_from_bytes(image_bytes, mime_type, allow_threads=True) @@ -116,59 +270,61 @@ def test_thread_safety(): # Both should contain the same keys if they returned data assert result_threaded.keys() == result_unthreaded.keys() -def test_get_mime_type(): - """Test the get_mime_type function.""" - # Test with common image types - assert get_mime_type(TEST_IMAGE) == "image/png" - assert get_mime_type(TEST_IMAGE_NOT_C2PA) == "image/png" - - # Test with fabricated file paths for common types - assert get_mime_type("test.jpg") == "image/jpeg" - assert get_mime_type("test.jpeg") == "image/jpeg" - assert get_mime_type("test.png") == "image/png" - assert get_mime_type("test.gif") == "image/gif" - assert get_mime_type("test.webp") == "image/webp" - - # Test with unknown extension - unknown_mime = get_mime_type("test.unknown") - assert unknown_mime is None or isinstance(unknown_mime, str) - -def test_read_c2pa_from_file_with_explicit_mime(): +@pytest.mark.parametrize("test_image", TEST_IMAGES) +def test_read_c2pa_from_file_with_explicit_mime(test_image): """Test reading C2PA metadata from file with explicit MIME type.""" - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") # Get MIME type - mime_type = get_mime_type(TEST_IMAGE) + mime_type = get_mime_type(test_image) if not mime_type: - pytest.skip(f"Could not determine MIME type for {TEST_IMAGE}") + pytest.skip(f"Could not determine MIME type for {test_image}") + + print(f"Testing explicit MIME for {test_image} with MIME type {mime_type}") # Read metadata with explicit MIME type - metadata = read_c2pa_from_file(TEST_IMAGE, mime_type) + metadata = read_c2pa_from_file(test_image, mime_type) - # Basic validation + # Basic validation - check c2pa structure assert metadata is not None - assert "title" in metadata or "generator" in metadata or "claim_generator" in metadata + assert "active_manifest" in metadata + assert "manifests" in metadata + + # Get active manifest + active_manifest = get_active_manifest(metadata) + assert active_manifest is not None + assert "title" in active_manifest or "generator" in active_manifest or "claim_generator" in active_manifest # Verify signature info exists if the file has valid C2PA data - if "signature_info" in metadata: - assert "issuer" in metadata["signature_info"] + if "signature_info" in active_manifest: + assert "issuer" in active_manifest["signature_info"] -def test_read_c2pa_from_file_with_auto_mime(): +@pytest.mark.parametrize("test_image", TEST_IMAGES) +def test_read_c2pa_from_file_with_auto_mime(test_image): """Test reading C2PA metadata from file with automatic MIME type detection.""" - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + mime_type = get_mime_type(test_image) + print(f"Testing auto MIME for {test_image} with detected MIME type {mime_type}") # Read metadata with automatic MIME type detection - metadata = read_c2pa_from_file(TEST_IMAGE) + metadata = read_c2pa_from_file(test_image) - # Basic validation + # Basic validation - check c2pa structure assert metadata is not None - assert "title" in metadata or "generator" in metadata or "claim_generator" in metadata + assert "active_manifest" in metadata + assert "manifests" in metadata + + # Get active manifest + active_manifest = get_active_manifest(metadata) + assert active_manifest is not None + assert "title" in active_manifest or "generator" in active_manifest or "claim_generator" in active_manifest # Verify signature info exists if the file has valid C2PA data - if "signature_info" in metadata: - assert "issuer" in metadata["signature_info"] + if "signature_info" in active_manifest: + assert "issuer" in active_manifest["signature_info"] def test_read_c2pa_from_file_no_c2pa(): """Test with file that has no C2PA metadata.""" @@ -179,16 +335,20 @@ def test_read_c2pa_from_file_no_c2pa(): result = read_c2pa_from_file(TEST_IMAGE_NOT_C2PA) assert result is None -def test_read_c2pa_from_file_thread_safety(): +@pytest.mark.parametrize("test_image", TEST_IMAGES) +def test_read_c2pa_from_file_thread_safety(test_image): """Test thread safety option for read_c2pa_from_file.""" - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + mime_type = get_mime_type(test_image) + print(f"Testing file thread safety for {test_image} with MIME type {mime_type}") # Test with allow_threads=True (default) - result_threaded = read_c2pa_from_file(TEST_IMAGE, allow_threads=True) + result_threaded = read_c2pa_from_file(test_image, allow_threads=True) # Test with allow_threads=False - result_unthreaded = read_c2pa_from_file(TEST_IMAGE, allow_threads=False) + result_unthreaded = read_c2pa_from_file(test_image, allow_threads=False) # Results should be the same assert type(result_threaded) == type(result_unthreaded) @@ -202,16 +362,20 @@ def test_read_c2pa_from_file_invalid_path(): with pytest.raises(Exception): read_c2pa_from_file("nonexistent_file.jpg") -def test_read_c2pa_from_file_empty_mime(): +@pytest.mark.parametrize("test_image", TEST_IMAGES) +def test_read_c2pa_from_file_empty_mime(test_image): """Test with empty MIME type (should use auto-detection).""" - if not os.path.exists(TEST_IMAGE): - pytest.skip(f"Test image not found: {TEST_IMAGE}") + if not os.path.exists(test_image): + pytest.skip(f"Test image not found: {test_image}") + + mime_type = get_mime_type(test_image) + print(f"Testing empty MIME for {test_image} with detected MIME type {mime_type}") # Read with empty MIME type string - result_empty = read_c2pa_from_file(TEST_IMAGE, "") + result_empty = read_c2pa_from_file(test_image, "") # Read with automatic MIME type - result_auto = read_c2pa_from_file(TEST_IMAGE) + result_auto = read_c2pa_from_file(test_image) # Both should work the same assert type(result_empty) == type(result_auto) diff --git a/tests/test_images/C.jpg b/tests/test_images/C.jpg new file mode 100644 index 0000000..b6579b3 Binary files /dev/null and b/tests/test_images/C.jpg differ diff --git a/tests/test_images/adobe_firefly_image_createdate.jpg b/tests/test_images/adobe_firefly_image_createdate.jpg new file mode 100644 index 0000000..30efc4b Binary files /dev/null and b/tests/test_images/adobe_firefly_image_createdate.jpg differ diff --git a/tests/test_images/adobe_firefly_image_createdate.jpg_original b/tests/test_images/adobe_firefly_image_createdate.jpg_original new file mode 100644 index 0000000..b84c4e3 Binary files /dev/null and b/tests/test_images/adobe_firefly_image_createdate.jpg_original differ diff --git a/tests/test_images/chatgpt_image_gray.png b/tests/test_images/chatgpt_image_gray.png new file mode 100644 index 0000000..ebe5d9e Binary files /dev/null and b/tests/test_images/chatgpt_image_gray.png differ diff --git a/tests/test_performance.py b/tests/test_performance.py index a564e70..fa80427 100644 --- a/tests/test_performance.py +++ b/tests/test_performance.py @@ -1,5 +1,5 @@ """ -Performance benchmark tests for fast_c2pa_reader. +Performance benchmark tests for fast_c2pa_python. These tests verify that our implementation is at least 30x faster than c2pa-python, focusing on relative performance rather than absolute time measurements. @@ -14,7 +14,7 @@ from pathlib import Path from io import BytesIO -from fast_c2pa_reader import read_c2pa_from_bytes, read_c2pa_from_file, get_mime_type +from fast_c2pa_python import read_c2pa_from_bytes, read_c2pa_from_file, get_mime_type # Import c2pa-python for comparison from c2pa import Reader @@ -61,7 +61,7 @@ def setup_test_image_bytes(): return image_bytes, get_mime_type(TEST_IMAGE) def test_compare_performance(setup_test_image_bytes): - """Test performance of fast_c2pa_reader vs c2pa-python.""" + """Test performance of fast_c2pa_python vs c2pa-python.""" settings = get_performance_settings() if settings["skip_tests"]: pytest.skip("Performance tests skipped via environment variable") @@ -71,7 +71,7 @@ def test_compare_performance(setup_test_image_bytes): if not mime_type: pytest.skip(f"Could not determine MIME type for {TEST_IMAGE}") - # Test fast_c2pa_reader performance + # Test fast_c2pa_python performance fast_c2pa_times = [] for _ in range(ITERATIONS): start_time = time.time() @@ -98,7 +98,7 @@ def test_compare_performance(setup_test_image_bytes): speedup = c2pa_python_avg / fast_c2pa_avg print(f"\nPerformance comparison results:") - print(f" fast_c2pa_reader average time: {fast_c2pa_avg:.2f}ms") + print(f" fast_c2pa_python average time: {fast_c2pa_avg:.2f}ms") print(f" c2pa-python average time: {c2pa_python_avg:.2f}ms") print(f" Speedup factor: {speedup:.2f}x") print(f" Required minimum speedup: {settings['speedup_factor']}x") @@ -107,6 +107,6 @@ def test_compare_performance(setup_test_image_bytes): # Check if our library is at least N times faster assert speedup >= settings["speedup_factor"], ( - f"fast_c2pa_reader is only {speedup:.2f}x faster than c2pa-python, " + f"fast_c2pa_python is only {speedup:.2f}x faster than c2pa-python, " f"but at least {settings['speedup_factor']}x speedup is required" ) \ No newline at end of file diff --git a/tests/tmp_cert/allowed.pem b/tests/tmp_cert/allowed.pem new file mode 100644 index 0000000..abb78d1 --- /dev/null +++ b/tests/tmp_cert/allowed.pem @@ -0,0 +1,2287 @@ +## The C2PA intends to publish an official C2PA Public Trust List. Until that time, this temporary known certificate list for use by the verifier at https://contentcredentials.org/verify. The list is subject to change, and will be deprecated. +## + +# O=CLOUDINARY INC. +-----BEGIN CERTIFICATE----- +MIIGYjCCBEqgAwIBAgIMf/QBg9NvF6i+hQB1MA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDEwMjEzMTMxMloX +DTI1MDEwMjEzMTMxMlowgaoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDQUxJRk9S +TklBMRQwEgYDVQQHEwtTQU5UQSBDTEFSQTEZMBcGA1UEYRMQTlRSVVMrREUtNTY3 +Nzg5NTEYMBYGA1UEChMPQ0xPVURJTkFSWSBJTkMuMRgwFgYDVQQDEw9DTE9VRElO +QVJZIElOQy4xITAfBgkqhkiG9w0BCQEWEm9wc0BjbG91ZGluYXJ5LmNvbTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOFquyaGsGemtzhs8jjQ9HmGv/EI +IoZSDLYJM+xyWlyX8rRjoK3raUef7zznQty40O+Xn29NnpTmUScWR8D0x5t9rnYN ++OgJ7uUYD7Ii5ogNCrw0nvI0jOTjek+gFoFMlP9HGw+BL6mNyn0H64cX1NE7zc82 +AoFdVSMXT9y7lkWOgbwgl1QsxaUvnX5Q3fm1w4ZKwq4wYgyIgMpNXzPyEu1Fy3Zr +O5uTjy3rPEPJ0K+ot3r6R8AxwHZdtHKUqunZuA7CI6Y2EJ4go8GQOqTEAlIGeMWD +U5TCVPEzX6/cd6Jyu6hFev50jEagL42pwxGY4YNtfLUo15VZStEUS9ixXQUCAwEA +AaOCAd0wggHZMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYI +KwYBBQUHMAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dz +Z2NjcjZzbWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmds +b2JhbHNpZ24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eB +DAEFAgEwCwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEFBQcCARYm +aHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIw +ADBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dz +Z2NjcjZzbWltZWNhMjAyMy5jcmwwHQYDVR0RBBYwFIESb3BzQGNsb3VkaW5hcnku +Y29tMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDBDAfBgNVHSMEGDAWgBQA +KTaeXHq6D68tUC3boCOFGLCgkjAdBgNVHQ4EFgQUXPKxSU25aa+3/cnFxAyo1gwh +1JwwDQYJKoZIhvcNAQELBQADggIBABzdK/SkyD2l8GJl+pLqNZEqRBwVskaCpGNc +GUK0GOoBGucgZ8kocxwUvcv7W8LNByy1G1HjzwItA3AMjcEzZYcodOSAABcxjXPn +X3CxTrmKISmVcIINjvb7YzePI3gaPGOUEw8YleAkc2PtgqeKZVkld5lJa6ksjP/N +ZTyP05sSl6FvQ6LLHOjTrQ75m0ik6+GiSQHElnfhlvcuqqm2vWFiEUR0WK86SIBe +kgHZiyWe1fiSX3ag879gkBfCFiqi86sqIipLl87pVFxTjYWUMeTjVR65i3bQBVbu +OoWHOVGDnZ7S2Sw/+WG1miORmWRAd8p75kxrQKfZU+8bV+dQPp7WVzBrDTSzCWlH +1PZffQRZf6d+Jjp2Qhncze0jti2u1rMJzkZeIBbFrZ+5sSl6KWwFFbKD881HHGpD +r709dL/XBa4AfzAAvOOB8zHpsDka/uZX0BLyMdPfco3aEI5gIXELwkFaNm3v2RaK +zKOZqVy9NIBZFUNaa7EbLKK6GaV9zHkn08Eqcq9JmWFZN8UKT53Odr12RII550wG +8rWJ/FVr7brePXDNr3U7hnLOOiIuXC5pHoMTi6nQz4xujASkN6H3PbQoi9ButcQO +wEBYXGGL3bk3seikHRkyTfPzR5VK6Ga6XFHmxbpa0KQb4KUSeFuyGqiCvB1jDkIK +bNNpHbvY +-----END CERTIFICATE----- + +# O=FRIENDS OF JUSTIN +-----BEGIN CERTIFICATE----- +MIIFUjCCBDqgAwIBAgIMMiCcjE8VvR/7D5IkMA0GCSqGSIb3DQEBCwUAMFsxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMTEwLwYDVQQDEyhH +bG9iYWxTaWduIEdDQyBSMyBQZXJzb25hbFNpZ24gMiBDQSAyMDIwMB4XDTIzMDgy +ODE4NTAwM1oXDTI0MDgyODE4NTAwM1owgZMxCzAJBgNVBAYTAlVTMREwDwYDVQQI +EwhBcmthbnNhczETMBEGA1UEBxMKRmFybWluZ3RvbjEaMBgGA1UEChMRRlJJRU5E +UyBPRiBKVVNUSU4xHjAcBgNVBAMTFUtub3dib3QgQ3JlZGl0IENsYWltczEgMB4G +CSqGSIb3DQEJARYRaW5mb0Brbm93Ym90cy5vcmcwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQDE6JyMb+C0KXCLmXgx9yN7cVe9H9i8QED1/odXQXTfzPJr +S+2PBQ57qZ4PZVs/l/SguSobZYwCdgjBDxOC9gaCVew31OQIzc389bTKMBQGIYMH +B7yYG0DhvCYcfAsSNwVZ2eFu1RiNoDzuEKy7+EkEvOWh1tSzazp3I4XaNDF1dJ4T +yctE6hyccUlAOiXeopY/oeu2a5nanVDDxTQIrOZnPvOaszB36oUfRuGIvRPaEWRh +6uNzVpxV1ClgTzm0DWCiZhyaPr2Ji5eNMjmAOVBScpM/F4S0cXN2yJvE1BV8+750 +yP1n5MsKDVvsOuuNHoHypiwWJubJ7bMxsbwjS72rAgMBAAGjggHbMIIB1zAOBgNV +HQ8BAf8EBAMCBaAwgaMGCCsGAQUFBwEBBIGWMIGTME4GCCsGAQUFBzAChkJodHRw +Oi8vc2VjdXJlLmdsb2JhbHNpZ24uY29tL2NhY2VydC9nc2djY3IzcGVyc29uYWxz +aWduMmNhMjAyMC5jcnQwQQYIKwYBBQUHMAGGNWh0dHA6Ly9vY3NwLmdsb2JhbHNp +Z24uY29tL2dzZ2NjcjNwZXJzb25hbHNpZ24yY2EyMDIwMEwGA1UdIARFMEMwQQYJ +KwYBBAGgMgEoMDQwMgYIKwYBBQUHAgEWJmh0dHBzOi8vd3d3Lmdsb2JhbHNpZ24u +Y29tL3JlcG9zaXRvcnkvMAkGA1UdEwQCMAAwSQYDVR0fBEIwQDA+oDygOoY4aHR0 +cDovL2NybC5nbG9iYWxzaWduLmNvbS9nc2djY3IzcGVyc29uYWxzaWduMmNhMjAy +MC5jcmwwHAYDVR0RBBUwE4ERaW5mb0Brbm93Ym90cy5vcmcwHQYDVR0lBBYwFAYI +KwYBBQUHAwIGCCsGAQUFBwMEMB8GA1UdIwQYMBaAFJYz0eZYF1s0dYqBVmTVvkje +oY/PMB0GA1UdDgQWBBSfwRTxj6nzCRjjLBcSzYY5fHi5fTANBgkqhkiG9w0BAQsF +AAOCAQEAAWyIwNMqDdvL79qXBaXNK9Wzm7nzOUGazMC3LxG5lpWtzQ1HHwHTiuF3 +2B/C5ARNeJFhgNHagmas46h1a+0yTIUR8QLVaSgPnjPewFRTy4LeTxsIfX4pk/0P +kny5wBS/oK/p7TpvRPCUCIvYMu6Sid4/GfwNMBIB2FPMzBoMrBKlddQCB5WnFXaJ +pYM6tcURMN/WX2cAYAxQsm7Z+ACTYqVxxe6dP0LnGFsz3tg/rPA11neHigi4ralN +lrLXPtRZtdk5ecgWuVRxZutE5c1ewUIh19nKg+1LGmvHggVBvw4tLuv/QyKNUqPA +UB77OwNdAWoXDeZzsYXhMMRGblKDqQ== +-----END CERTIFICATE----- + +# O=IMATAG +-----BEGIN CERTIFICATE----- +MIIGTjCCBDagAwIBAgIMJ9ahANawdnYN83D4MA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDIyMjExMDUxMloX +DTI1MDIyMjExMDUxMlowgZQxCzAJBgNVBAYTAkZSMREwDwYDVQQIEwhCcmV0YWdu +ZTEPMA0GA1UEBxMGUmVubmVzMRowGAYDVQRhExFWQVRGUi04MTgxMTU3Mzk5NzEP +MA0GA1UEChMGSU1BVEFHMQ8wDQYDVQQDEwZJTUFUQUcxIzAhBgkqhkiG9w0BCQEW +FHdhdGVybWFya0BpbWF0YWcuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB +CgKCAQEA+R9GqA87JF7jv8SsXtKH+xlz0yED9v7S8FfCpjXdZdOPyMhE3PTNSW/u +se7qVChW+JQA6oo6iaZXY2ePh8hcqjgqxASB34cnOz/O75icTUeu3XJiwe+ENbiK +eXq73qboEuiV/tJaj9rHEhzLv6WZMYNsqT5m6NEZYPmDv4eCUN6qT5SfyUcTfjhC +ayQkVFWhqXDUOmyRnbYtD/rUvVchVsU6ow3cBjxayGO8PNQHXJluQ/XZHQ3eHvEX +TY/IvRbW6InNTAop8TJA+eIOIs4lLf2a1RAs3rhSt0YWFlZJjOKp2jLJsMwYia6d +x0GSvr0R+gvoETWdrzchF4PdTAdLgQIDAQABo4IB3zCCAdswDgYDVR0PAQH/BAQD +AgWgMIGTBggrBgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3Vy +ZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5 +BggrBgEFBQcwAYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNt +aW1lY2EyMDIzMGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYK +KwYBBAGgMgoDATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWdu +LmNvbS9yZXBvc2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0 +dHA6Ly9jcmwuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAf +BgNVHREEGDAWgRR3YXRlcm1hcmtAaW1hdGFnLmNvbTAdBgNVHSUEFjAUBggrBgEF +BQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIw +HQYDVR0OBBYEFOtZlkdl3sXst+nZNiD+gmmIgA8xMA0GCSqGSIb3DQEBCwUAA4IC +AQCc81Jb/VXS7WsVJzGV6a46RsMZ2V/5bgI+dHCV7ZpKl4KgrQcbo0JOkCU66IRe +SimNcdQ8Ikti7qpYqtmlfdyvYwQfdmLTRBeLFZkk8T9WNU7AZt8bRhu/B+1qHAeu +FbWyK9ZEHGjC8MB1ci7wnbrRCOwUSzhgY2W0fJzYRbxva3d+rzyX7azJOuDB7rUE +eB94uzfPDy74paIrvaKQT58r5eIJhkmU7nTPHdUP0QspGJyhuyoqwBs0fuLeCbg7 +T875si2uT5SSlZZqQ4nlPO9wrPHO1x2SKjVLzy579gvk+xUO7ByUTFJzPQ1ukMWu +huLfeq19gdJ58NtwtA6FWleORmEiPYzcnSkOgi/7cS71HKFE6E6hl3vw5TEtN5pI +dGKLxBKPFh3Pg4MwZQzgq5M+zS95ixIjcmbvvJia2/KItBL9W8WdAd8raVTfaSNv +40GAGwfq3GfCh9WaHBgXLSZRyECcqMDl6cFv6z0GTyv/rC83or0edvIXCa9CIULy +xW+AerYVvmUko1aUWyd5tr0X3kjbMeQFrASdT/7sQActfiP4lKPZ6Bbtw8o39vuN +gPCBekysjuMrx8uOrmlpKDkjFbDtdTRSjfR5QfOt8qsnN86W61DN1jmvth/fFxVO +OgsZ3p0T1STbAStNH1ShFzC2mWb2zVGVOrrC0ViMc6fR/A== +-----END CERTIFICATE----- + +# O=NIKON CORPORATION +-----BEGIN CERTIFICATE----- +MIIGrjCCBGKgAwIBAgIMReJH0eJM+aq4bKhhMEEGCSqGSIb3DQEBCjA0oA8wDQYJ +YIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIDBS +MQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEoMCYGA1UE +AxMfR2xvYmFsU2lnbiBHQ0MgUjYgU01JTUUgQ0EgMjAyMzAeFw0yMzA5MjYwNDQ2 +MTZaFw0yNDA5MjYwNDQ2MTZaMIGHMQswCQYDVQQGEwJKUDEOMAwGA1UECBMFVG9r +eW8xEjAQBgNVBAcTCU1pbmF0by1rdTEcMBoGA1UEYRMTVkFUSlAtNTAxMDAwMTAw +ODc2MzEaMBgGA1UEChMRTklLT04gQ09SUE9SQVRJT04xGjAYBgNVBAMTEU5JS09O +IENPUlBPUkFUSU9OMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA38LT +R2gvgMruYK8JUBhs0RHa++WJ+H5uWCmJaTZgMS1hzLKFtcHJqcwBPiYyD8vYluoX +NFaJsoQUqgRR+VOMvGhn7adJLBri7xEUWnpSFC366RwX1g4Lhg0dcRN53Ke0DITM +/l4sM1rilr+4MUcRAgC6AjyGKLIQFkUhcJzJ8I9g7rLtf6/vgsAJENsXtGErZWxQ +2FVbQZen68m5FOAph4YKAfRsoQdP7AE46ymOrrliuhMMwafor41Hl+E0pmjNI2X3 +WwnAnRC5bbFH6zd7KnynrzigeRrvhM9p3akuLaCN3J/VdyMUw9Oc62ztI0VPJYIu +43DDnjtlH9VNOpJ2BQIDAQABo4IB5DCCAeAwDgYDVR0PAQH/BAQDAgWgMIGTBggr +BgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxz +aWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcw +AYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIz +MGUGA1UdIAReMFwwCQYHZ4EMAQUDATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoD +AjA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBv +c2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwu +Z2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAkBgNVHREEHTAb +gRlLYXRzdXJhLkl3YW1vdG9Abmlrb24uY29tMB0GA1UdJQQWMBQGCCsGAQUFBwMC +BggrBgEFBQcDBDAfBgNVHSMEGDAWgBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNV +HQ4EFgQUAY95gnmbzNfE3waoi1dDBJqPtx4wQQYJKoZIhvcNAQEKMDSgDzANBglg +hkgBZQMEAgEFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAKIDAgEgA4IC +AQAX8mrj6oeZn1S+WnvKSZfvxdad2tFGCq8V6DSIaSSmm8DWuYg8w/cvodAxNn9C +ZlQbPz0rJoDlrwgnan7260UK7aQrPLKIG4ihAtka8HLi1bp15uMImri2Vdq+vnON +oHDXHE8jb3f1NnB9PEJY8aYGkg5Mkp3qp6NGou67gr0chocDdQntlZZcdjHloy8y +2O/Nckm6dT5IDaBqvgQ4rwrUFkeVWS8wXNPD3DeZ6tR9e6ToPDR5HVhOA/IGqPqm +8uTU4bYAY3hnFPbUo71/YzXNI+6mIGQFPQuNQLuc7pz7naRbTNYubnvwmJtEINvH +3YNqJ4Gfk3mI9jN6FHQxNayOO9E9z5Tu3IADjWCFsduZmH0nt8QsjXKDnIhBa9FT +1capVVkry0wnY8AdmN9XbXjwUjgJMWZTBnt0pJWP26mHPS2jyM8bK4B2eln4O4L+ ++Z/WLVBKZ6JyzLO9GKfGdBMWgnFNzg8kbVqEovr4/yM5boXgaQbHKvq3+EoZyY5T +zEo6rwlWIn2Hk1Yb0EuOq+JbLzljn4DaEeQlXKCQF8MLp1BNJk/lRfGsUquaQDdq +iI0eRtysvblmdSQbLu65XyQeE4ppErVSn9D/WKw4aR/GqLWLkQ8tnTWr91jQuo6r +GIlH+zSz3/RVfETqn6Cm2laXfQ48L/DLvQWi6jP9VpVkRQ== +-----END CERTIFICATE----- + +# O=Numbers Co. +-----BEGIN CERTIFICATE----- +MIIEgTCCA2mgAwIBAgIQDFlKlvV3LulV8wJLIZiChjANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDAyMjYwMDAwMDBaFw0yNTAyMjYyMzU5NTlaMIGKMRcw +FQYDVQRhEw5OVFJUVy04Mjg4NTk5MDELMAkGA1UEBhMCVFcxFDASBgNVBAgTC1Rh +aXBlaSBDaXR5MRowGAYDVQQKExFOdW1iZXJzIENvLiwgTHRkLjENMAsGA1UEBBME +Q2hlbjENMAsGA1UEKhMEQm9mdTESMBAGA1UEAxMJQm9mdSBDaGVuMHYwEAYHKoZI +zj0CAQYFK4EEACIDYgAEwk78GoSZDE5DA0CH7YaWpu0UIpndtoblmKEwb+AlfXEI +eIb/fmjTHaOsQ2eQPt3eSdFfZA6SfkgX0s7L8qKx6P0IgXhuSSy2RQvlpxbUh+85 +/eDDG95hc3uBWOy89dZlo4IBrjCCAaowHwYDVR0jBBgwFoAUpWIgUNy7W1eXrSOP +NeJUbKl++U4wHQYDVR0OBBYEFJPlUCHUOGEMwBXjF78ZUvaW/n/YMCAGA1UdEQQZ +MBeBFWhpQG51bWJlcnNwcm90b2NvbC5pbzAUBgNVHSAEDTALMAkGB2eBDAEFAwEw +DgYDVR0PAQH/BAQDAgOIMBMGA1UdJQQMMAoGCCsGAQUFBwMEMIGLBgNVHR8EgYMw +gYAwPqA8oDqGOGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3Vy +ZWRJRENsaWVudENBRzIuY3JsMD6gPKA6hjhodHRwOi8vY3JsNC5kaWdpY2VydC5j +b20vRGlnaUNlcnRBc3N1cmVkSURDbGllbnRDQUcyLmNybDB9BggrBgEFBQcBAQRx +MG8wJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBHBggrBgEF +BQcwAoY7aHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJl +ZElEQ2xpZW50Q0FHMi5jcnQwDQYJKoZIhvcNAQELBQADggEBAIT2Z1PPBO4FjHgm +4Sq0ZjnlhmAOuNxho4OGLzfBOSbfPCdp8HPiCxQYnBZ4WHUQwh5xKuFBc1wEL2Xs +qNfW1X5C+psHCl7fBhRQUo5zbxJY6ukQLTyTyt0tpzb/HRpKqwGYl943qORYeNbq +d76fAJIb2k3mHsWIcl6bYSYQPz1nJjVPEO/kKT1a4nLRdBezpCG3qYd5HMjLonz0 +LENF/mfzBqJmHcByHy6IkPJdqClzmwRXpLNdutrx6l3LmSiLciJck4/zGKUJXRoG +L0fLyU23cLKYapIZbJQnJBDHGqH/k+jzc3UJJLyYQffBhdF2RfxxHr0OP/oyDsa4 +tZ78sss= +-----END CERTIFICATE----- + +# O=PIXELSTREAM\, INC. +-----BEGIN CERTIFICATE----- +MIIHaDCCBVCgAwIBAgIMQzHHnTn6jIiPrlYHMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDIxNTE4MTUxMFoX +DTI1MDIxNTE4MTUxMFowgasxCzAJBgNVBAYTAlVTMRIwEAYDVQQIEwlNaW5uZXNv +dGExDTALBgNVBAcTBElzbGUxGTAXBgNVBGETEE5UUlVTK0RFLTcwMTg3NDcxGjAY +BgNVBAoTEVBJWEVMU1RSRUFNLCBJTkMuMRowGAYDVQQDExFQSVhFTFNUUkVBTSwg +SU5DLjEmMCQGCSqGSIb3DQEJARYXc3VwcG9ydEBwaXhlbHN0cmVhbS5jb20wggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCOrs5pAHsXuaiezWsdMl0fhx7a +1++a3PjoMBiWWFQZBmH1tsJsT91+svcFKPDLHTl4Jg5nVkn0qUA4vaxLLCh2o4uP +FqJOw0StsplDv3hOPvA7KbBVfKXzxIAZMVI0JFP7WiaObVGcCTLTDhOa7OgtXfHi +a18GfnsOyUNeinUnoDIq/rtLh4PedCphMwq5NvBKXzv3LKyx0f3T/5OQswNUzXDG +jajpcblkR/Kk1cPvTFj0oGc2G/I4nPfyKkWYkKyUuMsg2z6/MzAE6YM310bfVWva +03ivyfwHc6F5+UXCXUU3U0AXLiicsWIzM5FjxaFABPnOwou/Y26OU7Y/3weCDCyE +qcAKrMpv1eZ5kbKtBJw+f3DMR4+T1nd12537O9YVHOU7QVOEdHbDt+YiO7H4O3NF +Drcl6NCIXxDLMReMD9+U8BluFJhCzilbL55RhJnfvK1JTfDFjNUZoZjavVAtCxi+ +7dQlxUKAIxUW9z2PYPnqdSRi5YsPdqSa7Yyy9kM7jWX/1fvrQM9UjgDLM+VMsoR+ +6yDzYcui3ylXQ8/obEhLkm4t5SgviYFwKlscVGHFkNlkuIx5lWAcbTMl/5xGBvXe ++w3GnQj6YDP1NAhewjgE/ospryO678R/1MB+NnndgaM6Ls6gMZEdAp68HQOHpjRu +ZLhZSKfbbqDUwBFEdQIDAQABo4IB4jCCAd4wDgYDVR0PAQH/BAQDAgWgMIGTBggr +BgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxz +aWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcw +AYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIz +MGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoD +ATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBv +c2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwu +Z2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAiBgNVHREEGzAZ +gRdzdXBwb3J0QHBpeGVsc3RyZWFtLmNvbTAdBgNVHSUEFjAUBggrBgEFBQcDAgYI +KwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0O +BBYEFNfSKazQgeCrjLKqfHUVVwp7pdaxMA0GCSqGSIb3DQEBCwUAA4ICAQC245Mo +jIJsWzqgy/lA8z3RJqe2dy2pJNz6stu8+Wu/pd/hw7jQxILl5H9+G5inQ8RJPO5z +bbJIrmRuxSBISaOy5Vby5osEWoNRuEBrg+Xg9gRYb1bPNexM2I+stdS5GNSsVisw +T4E9Oqf8J5rrUZLu0Rt02pvG97yfPGY9SVxBD6II8dTXLuNIDDtQuZJnsC5skoGJ +iwk4Wk5Hn1tyO7oSYbvavMlwKVQu3NxO8ut8zwf1NZ5L8ptJcvWcQmRmK7yOqMzu +fhZUOu3x+vpuCMQgla8tAuUPXTTI0Hethv9p25mggcZ4Y7hY3atWxhBinju1p5DP +JpdwgjLdLxx46pGbNvljRoW3knRnOLrCJ2AKeD30laEcJZC32LJDJzWrA+mRiRXq +21ls/rh6jZTgViJhVn2jTjqB8cdS0PO+9V5127TBpRMwe1SoYqGTffpAuy2ZEpe6 +PjZmcW/Wnm+8+Uo2sg/EJQvNhXA7v7OCA2LyaOOfEsa6nlvmsvzOZAeRsD1ivVBv +T3nIVQdxDn7TepbgsSA3d/DzFPd1b2UBQ1CgToGqotaDhlqiglix+DuM8/uC4r/L +s9hwpWxPaTyNT1ObBjq7jnEZvWfhUY4W9tuoAbMsA4yP5RwA3X0GpnmylJ2cBmNA +AkgDeQHgbMR7yXyh3uIVOg3u51aD8zM9OomPMg== +-----END CERTIFICATE----- + +# O=Typeface Inc +-----BEGIN CERTIFICATE----- +MIIFIzCCBAugAwIBAgIQBHZaUrQsmfyt26uAY+uiqTANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDAyMjMwMDAwMDBaFw0yNTAyMjQyMzU5NTlaMIGDMRkw +FwYDVQRhExBOVFJVUytERS02NzkxNjQ0MQswCQYDVQQGEwJVUzETMBEGA1UECBMK +Q2FsaWZvcm5pYTESMBAGA1UEBxMJUGFsbyBBbHRvMRUwEwYDVQQKEwxUeXBlZmFj +ZSBJbmMxGTAXBgNVBAMMEGluZm9AdHlwZWZhY2UuYWkwggEiMA0GCSqGSIb3DQEB +AQUAA4IBDwAwggEKAoIBAQDhJZNIzbKXNdzQbnXJ349jIq9EmEqvaagl6ymclIq1 +vS9+AMdFMMjhvUGTM39lkRkOzmJiF0yO95/PYEXe1wW9LysUlTf6H7v/4goJB/3v +Tibj/uv9aTZS7E8w0u0V6XnC1nNtBat7RD5HfyfBO8Omvvzq2XZbrLQ/84lMFEyV +6neMEa6kRPMxFgypaAwrBMANmySFxrM7xZdiI6POd42Qvh+fCNxpX3/DUgIlpsOe +9YpeYndyVx/ZBGmGC4c/xHOb39nVEHyMPxYKfFE4Dk56rNh4IKzj4ubU+iBkXuof +o87gPc/GJjnPHUMkAHvf+fKtWm3H1NMtNXF9/n7L2NlrAgMBAAGjggGpMIIBpTAf +BgNVHSMEGDAWgBSlYiBQ3LtbV5etI4814lRsqX75TjAdBgNVHQ4EFgQUQS0DAUaC +rH/TOaokWTzel/W/+tYwGwYDVR0RBBQwEoEQaW5mb0B0eXBlZmFjZS5haTAUBgNV +HSAEDTALMAkGB2eBDAEFAwEwDgYDVR0PAQH/BAQDAgWgMBMGA1UdJQQMMAoGCCsG +AQUFBwMEMIGLBgNVHR8EgYMwgYAwPqA8oDqGOGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0 +LmNvbS9EaWdpQ2VydEFzc3VyZWRJRENsaWVudENBRzIuY3JsMD6gPKA6hjhodHRw +Oi8vY3JsNC5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURDbGllbnRDQUcy +LmNybDB9BggrBgEFBQcBAQRxMG8wJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRp +Z2ljZXJ0LmNvbTBHBggrBgEFBQcwAoY7aHR0cDovL2NhY2VydHMuZGlnaWNlcnQu +Y29tL0RpZ2lDZXJ0QXNzdXJlZElEQ2xpZW50Q0FHMi5jcnQwDQYJKoZIhvcNAQEL +BQADggEBAIhB22byyeFwE2dIh7u26VaSgpx9yCs4NuU3mskX0xH15Vvc4AwDP4HM +FfucK0Oxmlbpv2/iMBaPsI3e4fBxvCqGRUcJyPU5xAE2NpXtWoPUG2vtPM9okl05 +rr8ityxuhCXMf2il6baqW+EJUBE/stLteIQc1t6fFpxNKylI2bvt7O7XnnTeRDW2 +R2oukM91+fAy6dfGy2xTC/mtfsY/BpbvvET9EJK7DLrRDhN/4/usVKYsEUbKKE3R +iSbWBf19BR2pxQ2fLHw8XZPlgQcYGnYMTXsJ1F1SqYJUOLsEgDU9haA5WNqD4nb8 +Sebgnx18VMyi/L4hqr6sfNSk/hCUUR0= +-----END CERTIFICATE----- + +# O=Wrapt Inc +-----BEGIN CERTIFICATE----- +MIIEdDCCA1ygAwIBAgIQCg/6SksFGjqv7zUTdzMdijANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDA1MDEwMDAwMDBaFw0yNTA1MDEyMzU5NTlaMIGdMRkw +FwYDVQRhExBOVFJVUytERS02Njk4Njg0MQswCQYDVQQGEwJVUzETMBEGA1UECBMK +Q2FsaWZvcm5pYTESMBAGA1UEBxMJTG9zIEdhdG9zMRIwEAYDVQQKEwlXcmFwdCBJ +bmMxDjAMBgNVBAQTBVdhaXRlMQ8wDQYDVQQqEwZTdHVhcnQxFTATBgNVBAMTDFN0 +dWFydCBXYWl0ZTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLYADc2q+aRoVoU3 +ZoqKdvhSA34jfFSasLKG/BeKVI9Wgzv/TcTWu+7kXDl3tLAw7nKCNhov4JyNPvIh +Ad+ynaijggGrMIIBpzAfBgNVHSMEGDAWgBSlYiBQ3LtbV5etI4814lRsqX75TjAd +BgNVHQ4EFgQUwjZ7+I13nbj/7AePIrqL7AdAfhYwHQYDVR0RBBYwFIESc3R1YXJ0 +QHdyYXB0LnNwYWNlMBQGA1UdIAQNMAswCQYHZ4EMAQUDATAOBgNVHQ8BAf8EBAMC +A4gwEwYDVR0lBAwwCgYIKwYBBQUHAwQwgYsGA1UdHwSBgzCBgDA+oDygOoY4aHR0 +cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElEQ2xpZW50Q0FH +Mi5jcmwwPqA8oDqGOGh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFz +c3VyZWRJRENsaWVudENBRzIuY3JsMH0GCCsGAQUFBwEBBHEwbzAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEcGCCsGAQUFBzAChjtodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURDbGllbnRDQUcy +LmNydDANBgkqhkiG9w0BAQsFAAOCAQEAQQktityuKTItgTT0bSGmn/piOZT0zFS0 +MRLI2zpoYNrSlJYiOfJGY07EKIWTaqvNyxstPHBO+peEH6Ul4oE26J1eKM53AbDl +APBtMMMp+kcK3653372QzJjPM93rn2LwaruWF+h6znEjt2I5FdeZhAkunw1h0+zI +D8Qspwj5K0DMsbFnLnxCcHF4n/T+bePb/ldkSe3L+9ud3ZyXY0BUDn5/ggWZECdw +DPt5ffs47MlB1Z9hG/bRLIEpr4XRvSoRpaLn0NgcR3enFxXj1z/32rIItcl7ylt7 +go/WDUJi9JxEdUIrKMQHrkbo79sEqWnvmWCjivKIXXTTKEYXyOhbPg== +-----END CERTIFICATE----- + +# O=Monotype +-----BEGIN CERTIFICATE----- +MIIEgDCCA2igAwIBAgIQBRLef/P5iIs2/1nZ3zKgmjANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDA1MTUwMDAwMDBaFw0yNTA1MDgyMzU5NTlaMIGNMRkw +FwYDVQRhExBOVFJVUytERS0zMDg4NDMxMQswCQYDVQQGEwJVUzEWMBQGA1UECBMN +TWFzc2FjaHVzZXR0czEPMA0GA1UEBxMGV29idXJuMR4wHAYDVQQKExVNb25vdHlw +ZSBJbWFnaW5nIEluYy4xGjAYBgNVBAMMEWMycGFAbW9ub3R5cGUuY29tMHYwEAYH +KoZIzj0CAQYFK4EEACIDYgAE7KXfxckQxNVFvxjYdK8iWFU47sHfumtzmn2vkhgY +eubHrC9IGdwIHGPtndh5A9geJw/p9s0xP7qYm1lStGBCJPDaJLJhtq6ztNTT+xM+ +EYcgbm/hu8UtstvJLQVq/4Ozo4IBqjCCAaYwHwYDVR0jBBgwFoAUpWIgUNy7W1eX +rSOPNeJUbKl++U4wHQYDVR0OBBYEFAtLVeKneNSeaFTNkd4gLywF5NIHMBwGA1Ud +EQQVMBOBEWMycGFAbW9ub3R5cGUuY29tMBQGA1UdIAQNMAswCQYHZ4EMAQUDATAO +BgNVHQ8BAf8EBAMCA4gwEwYDVR0lBAwwCgYIKwYBBQUHAwQwgYsGA1UdHwSBgzCB +gDA+oDygOoY4aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJl +ZElEQ2xpZW50Q0FHMi5jcmwwPqA8oDqGOGh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNv +bS9EaWdpQ2VydEFzc3VyZWRJRENsaWVudENBRzIuY3JsMH0GCCsGAQUFBwEBBHEw +bzAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEcGCCsGAQUF +BzAChjtodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVk +SURDbGllbnRDQUcyLmNydDANBgkqhkiG9w0BAQsFAAOCAQEASqkHhhgN1o+GQnKv +Mui9EEEbs7hy8+FF5PKjWiYkMlb45Nz6DhIJ6aCad+UOkqBM2wJbP3UFFbDcR9Hy +hCYWryhUUPFSwaE8+QnzHwAPaqN3qP0WOauEUiMq4dUtR8z8a+vVZoDJRbm+XuJu +6/JYLIVLr2lg//5jQx8inKHdnZ8dlD1wuhieoCz60HExWnZsOCd5YhoBvH39ktbu +tSaJOXWWPM/nK1OOHWzo18ZNaNU4GLJZeMjhasoTEqX+ub59Vmr2kb46+KNyhNXl +sL0jlWPjNPAT95joT47uh/s/o9xrX8M5tVJwq2DTh6mk47EtyxAjt9Qqe0HQTokS +zi3g5g== +-----END CERTIFICATE----- + +# O=TikTok +-----BEGIN CERTIFICATE----- +MIIFOjCCBCKgAwIBAgIQA1yGmXwJOss3S6cFXAtrdDANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDA1MTMwMDAwMDBaFw0yNzA1MTUyMzU5NTlaMIGKMRkw +FwYDVQRhExBOVFJVUytDQS0zNzgwNzkyMQswCQYDVQQGEwJVUzETMBEGA1UECBMK +Q2FsaWZvcm5pYTEUMBIGA1UEBxMLQ3VsdmVyIENpdHkxFDASBgNVBAoTC1Rpa1Rv +ayBJbmMuMR8wHQYDVQQDDBZjZXJ0aWZpY2F0ZUB0aWt0b2suY29tMIIBIjANBgkq +hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAySC/Y2f9veV4zn6hZLLCpLhn0XSPxnIV +cfurvfy5YYAQBaADTZ1drzAE7sjXpr96AOtAkP2AjScNSh/ts0bXwxD2G05H9qdn +3Rq+IX+xX5DX9O8g2w3yo3MLaMWQOIRYe7e5oU28Y0gV5zuL9TYKSMIOXBBlm1xT +EV776DdqNw050fU9HLv8/r+twcc7M6naH5nmmVjcCBW1mQsPt2igIL2M56tYn9Z+ +/9Xp0kRVSpbCpZEfTL0hVh+g/QB51D9rpfkwekg/NbmNp/MpRKj5OBb2KEqcvEna +jQ4S3ean/LTXYBLvd24a4J20Ju9LR3nDVruW4XO3ggl9LsYYw4wIkQIDAQABo4IB +uTCCAbUwHwYDVR0jBBgwFoAUpWIgUNy7W1eXrSOPNeJUbKl++U4wHQYDVR0OBBYE +FGGgq3JiMMPtdTxVSj/gROlGobNhMCEGA1UdEQQaMBiBFmNlcnRpZmljYXRlQHRp +a3Rvay5jb20wFAYDVR0gBA0wCzAJBgdngQwBBQMBMA4GA1UdDwEB/wQEAwIE8DAd +BgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwgYsGA1UdHwSBgzCBgDA+oDyg +OoY4aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElEQ2xp +ZW50Q0FHMi5jcmwwPqA8oDqGOGh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdp +Q2VydEFzc3VyZWRJRENsaWVudENBRzIuY3JsMH0GCCsGAQUFBwEBBHEwbzAkBggr +BgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEcGCCsGAQUFBzAChjto +dHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURDbGll +bnRDQUcyLmNydDANBgkqhkiG9w0BAQsFAAOCAQEAOhVE4fn5IazzsdtTaLUBvcYD +uyV15nyrdWv/maSWVE535opgaXucP202OoJZnKU/g2mQhZxxw03OfsQUn4Sygzkf +6YWQ/LI7wPwVjDODmVe2OKbTFTfTa6SH5mxsKpGkyVoTpnA9aplVI/MSdtmIW+s5 +V9zRg0y7VZbYByd5+rLTmM/lz5wHpsFmQXdOVMgjpJufBfN9j6iBoBLHMoLJ6rdG +o5ZIWjY0cXEfBCh9Mcz1DiDI6eVP/u1UMEEIipox/eZrjUVADqyonLinhfLx8IVH ++g4A0gUlXjRSfS083m0yDZYU4XgZIkcgOYCMOI3vB8v01YPiW0V14ZFQBbDq0A== +-----END CERTIFICATE----- + +# O=Hour One AI LTD +-----BEGIN CERTIFICATE----- +MIIFFDCCA/ygAwIBAgIRANcxlvA65umgAAAAAEw9zMQwDQYJKoZIhvcNAQELBQAw +gaUxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkwNwYDVQQL +EzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSByZWZlcmVu +Y2UxHzAdBgNVBAsTFihjKSAyMDEwIEVudHJ1c3QsIEluYy4xIjAgBgNVBAMTGUVu +dHJ1c3QgQ2xhc3MgMiBDbGllbnQgQ0EwHhcNMjQwNjIzMTA1NzA0WhcNMjUwNjIz +MTEyNzAzWjCBjjELMAkGA1UEBhMCSUwxFzAVBgNVBAcTDlRlbCBBdml2LUphZmZh +MRgwFgYDVQQKEw9Ib3VyIE9uZSBBSSBMVEQxGDAWBgNVBGETD05UUklMLTUxNTk4 +MTIzMTEyMBIGA1UEAxMLT3JlbiBBaGFyb24wHAYJKoZIhvcNAQkBFg9jMnBhQGhv +dXJvbmUuYWkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDpq6zU2vpj +06eKyzZic8yZtLmu2DtvCM09C0wHwmDgk7kYLQkmOohXMrAZVrFXCM5yarD1XPGK +znjqQ4d/dVrLKHRDmN2PjBU2i+Yd6Os7At5u+Nv33Z+qoAvcrNOgUidBIXxt5ZFl +OxjmZpBaRp/xQkyYbsdwrAZJZxXlPwxRKGV/lsZ53QRWDevAyITPwJYSxViMAzg+ +YfI3SXqS97qtD3If2n44Oc/kXKC8R5OHulTzIQtNa7N7tpvV5k/zwt2rDqPSrnsa +BjHT85ygwzJnJ0XKGGSrcjT87+/n9SgNRirun6KSH/7o0TnlcaTqQaDIvnL9CLUy +qKXqi01bXFxvAgMBAAGjggFSMIIBTjAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYw +FAYIKwYBBQUHAwQGCCsGAQUFBwMCMBQGA1UdIAQNMAswCQYHZ4EMAQUDATBqBggr +BgEFBQcBAQReMFwwIwYIKwYBBQUHMAGGF2h0dHA6Ly9vY3NwLmVudHJ1c3QubmV0 +MDUGCCsGAQUFBzAChilodHRwOi8vYWlhLmVudHJ1c3QubmV0LzIwNDhjbGFzczJz +aGEyLmNlcjA0BgNVHR8ELTArMCmgJ6AlhiNodHRwOi8vY3JsLmVudHJ1c3QubmV0 +L2NsYXNzMmNhLmNybDAaBgNVHREEEzARgQ9jMnBhQGhvdXJvbmUuYWkwHwYDVR0j +BBgwFoAUCZGluunyLip1381+/nfK8t5rmyQwHQYDVR0OBBYEFOoynduyxXFhbkT7 +0AkmI1MX8sF9MAkGA1UdEwQCMAAwDQYJKoZIhvcNAQELBQADggEBAFnBKoCeO4oc +W/5UTTPI90AjN7AFy2hfe6+w5SoggScLJkDlFMxoFhZIklaMEXLGb/huYPrWzbPA +F48ye9bsmEq6sf1btVeBEug4o9LY0sMmq5QwrbpxIp+nbQROwYeFE4NqD4mnC6Wx +sTeMtucHqSxoqnKv/aarCAx9lycMwRqwRXVdzN7tcwLmTJMmHC/Kr4nxPYNnHJg7 +QfbTZYfyNbfnwgtw4LUnYzie3nieqCV2fSlchxyf20iZ/19Pb3Xsq9tzLEGWci0N +2hF09BXKoqak2ICdM6dZnn1vy+da9ZiAt31lA/0zMAKdgeflmVcYlU9YF4g15Q+I +lh9+XYYOnpU= +-----END CERTIFICATE----- + +# O=Crafture B.V. +-----BEGIN CERTIFICATE----- +MIIGYzCCBEugAwIBAgIMFWS6eNHkr6p48QVwMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDUxMzE1MjcwOVoX +DTI1MDUxNDE1MjcwOVowgaoxCzAJBgNVBAYTAk5MMRYwFAYDVQQIEw1Ob29yZC1I +b2xsYW5kMRIwEAYDVQQHEwlBbXN0ZXJkYW0xGzAZBgNVBGETElZBVE5MLTg2NjM5 +MzA3OUIwMTEWMBQGA1UEChMNQ3JhZnR1cmUgQi5WLjEWMBQGA1UEAxMNQ3JhZnR1 +cmUgQi5WLjEiMCAGCSqGSIb3DQEJARYTYXJ3aW5kQGNyYWZ0dXJlLmNvbTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALjLd12+Myhu/hfxCh9QDGDG+4WG +sb44oKL/iGiVAr8BGPwWj5E0uOu7VVoVOqxU/oVDbYQBIlaoCtWQk5DhkfUpWD9z +IypcQrRjK9A+huufd+9iI4LOewKiuhJ9LPLgvkF/8LyYP6mtIxhGZnd5F9bf5/69 +yzRPE061P5DFuByCaKb1cSSpQdQqG4QFx5Dsf191gxHNHGvkSBcZMtzRkv8DipOe +sYkUXSRLEW6cbNpqcvgB/yafru/MRBBo7+TIm7ymARZUNlMmf4nuc0tlZNtlh8H8 +2fqSTCPmCcuXS4h7H2pob/FLm+/eDG/w+dATM6xZmQ8jXpuPiNy38jZyXY8CAwEA +AaOCAd4wggHaMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYI +KwYBBQUHMAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dz +Z2NjcjZzbWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmds +b2JhbHNpZ24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eB +DAEFAgEwCwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEFBQcCARYm +aHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIw +ADBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dz +Z2NjcjZzbWltZWNhMjAyMy5jcmwwHgYDVR0RBBcwFYETYXJ3aW5kQGNyYWZ0dXJl +LmNvbTAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAU +ACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFHvzqW+skFHOi33Ee4ew/D4I +sQcvMA0GCSqGSIb3DQEBCwUAA4ICAQARKjrOUP/xUi5I34scnFT1OSg61DvNqt2K +h4vdem3do6szKWDj5KWuy/xjZyC49tXSMP8FuWhHn1plnmBZqaAXxa54yufLr1jT +ZIyUvHg4iZTaFQELQEMBBc8OYzhCwKl9LKgQyuxrMUj/Ek47L5vJO7Bl3C+m91Tj +/Po1q2BYPwVH4F0ek5WnFYPn6bRt7gwHZthoMZ04TTEkPFtcnciPBO9LV0ZMysby +Ehm25v2/Jb44oTo5YFr8PwgSddMWY2ynjanbemK52T2ALGZTliTT3GpLpaKu/pj3 +/Ku963X3iNeBiKUq7oUoElSspYNFtqSq7DPbjNzeGGCxTshhwLnzpAxBlACVe2/S +I4udVxFXSfpMkrxQI695KPWV7trh32g/q6ESrz+bnB1L15uM2M4FpU6vDWPUywya +6PqR7K4IRk7NO5PWs1pRpAEpbE0kWUJGihRU2qS4+LI9PEhSwlX6Hut519i0ryCx +Syc0cDRKh2McEmvVqHQilMeAJ2gQJdG5vu7EiVKOdGfibei3zEygu9WUI5hPpA90 +8WB0XxsaZ3Qj3r8gU4sP5SDGUIT301PSEHP4yQgvjjH6zH9cF4pRCz53+BdJsOdE +vIP8+Hk//ab/7zFPpGGGiPLsMmfreRaPeJUrLDbPMnoerYg9r41NC+iIiBEzp/Zh +7Kzlt1pLNw== +-----END CERTIFICATE----- + +# O=Digimarc Corporation +-----BEGIN CERTIFICATE----- +MIIGZDCCBEygAwIBAgIQTpSXk/rALLfH7aTRJxx8XTANBgkqhkiG9w0BAQsFADB+ +MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0b24x +ETAPBgNVBAoMCFNTTCBDb3JwMTowOAYDVQQDDDFTU0wuY29tIENsaWVudCBDZXJ0 +aWZpY2F0ZSBJbnRlcm1lZGlhdGUgQ0EgUlNBIFIyMB4XDTI0MDYyNDE1MzgwNloX +DTI2MDgxMzE1MzgwNVowga8xCzAJBgNVBAYTAlVTMQ8wDQYDVQQIDAZPcmVnb24x +EjAQBgNVBAcMCUJlYXZlcnRvbjEdMBsGA1UECgwURGlnaW1hcmMgQ29ycG9yYXRp +b24xGzAZBgNVBGEMEk5UUlVTK09SLTY4MzgzOC05MzEdMBsGA1UEAwwURGlnaW1h +cmMgQ29ycG9yYXRpb24xIDAeBgkqhkiG9w0BCQEWEWMycGFAZGlnaW1hcmMuY29t +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtK1n6YJjsa/UFPtq2jIE +XCJdXgq0KKXsjUAWuFNhTdlLFzhT9kAQ+R34Sj6lspogx0TsGpgZq6nGhw1y0D61 +FYNlJ5/onByzzOIUoBxzBEycpW+4TIBWkdW53DiV+w7z5lWxAtLKC7KDFW4OZcmE +YsCb1h3pDnXRHFHTRmrSRopuMnS7dow6KJzndHVCRhLwVBEhSwZKN/d62xM45FKr +IsOOfiiDqFu5UqNx+L1I0vH6HCsRtYlDSJ1rdCQuEe83Gz09v9NklueGgC/nFuoA +GeNPUfDrGrNlvcVnlgvmKX5Tw7tOwJIvhHYn+kSjhpmmiIJi7JAPeSL39p6XOqCp +FQIDAQABo4IBqjCCAaYwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRmj6a8t5Ms +nfm6SeVP3OqQUBFqnTBXBggrBgEFBQcBAQRLMEkwRwYIKwYBBQUHMAKGO2h0dHA6 +Ly9jZXJ0LnNzbC5jb20vU1NMY29tLVN1YkNBLWNsaWVudENlcnQtUlNBLTQwOTYt +UjIuY2VyMBwGA1UdEQQVMBOBEWMycGFAZGlnaW1hcmMuY29tMGIGA1UdIARbMFkw +CQYHZ4EMAQUCAjA8BgwrBgEEAYKpMAEDAgIwLDAqBggrBgEFBQcCARYeaHR0cHM6 +Ly93d3cuc3NsLmNvbS9yZXBvc2l0b3J5MA4GDCsGAQQBgqkwAQMFATAdBgNVHSUE +FjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwTAYDVR0fBEUwQzBBoD+gPYY7aHR0cDov +L2NybHMuc3NsLmNvbS9TU0xjb20tU3ViQ0EtY2xpZW50Q2VydC1SU0EtNDA5Ni1S +Mi5jcmwwHQYDVR0OBBYEFG7DY+7Kwl7RjCK8pq9iT/YkSCxYMA4GA1UdDwEB/wQE +AwIFoDANBgkqhkiG9w0BAQsFAAOCAgEAMsD9Awkwz4DXXV37jBIqU+b6yBsJHW5Q +PcX35BnVNkgkUa/8b3AOlokcuOIQd7pFtfX8kmwIv2G5rv/67YAlyDU8CWtCR25R +2HYVdo7yPjQCapio83A74z9/ZcHWXhUXZ4zADeRJVfYDKhla5kfw5WO9yk/xZYC9 +sdwnoMudLRz4uJMvgefI4uXHXNOcQRXS5LxfAM0AQK7ML3S/3GvWs2ez61UVnZRi +VJFvaJeOsmPNNJTvYJBYujYIfsCGxAyGmbn/X8OfrHFr0HMRBdnsEmvErOZNzPst +VWODwXYN7dYENuI1/SIF499xu4kiZITIB6MsoBjz5zezTi2lXMOZ+a++rV54Jk5D +W6mWGZLcohS5f7Dh9fLMT5+C/Aaxoc0qUyHoBLjr3JJcQA0YB2bJAf7tNOObhLXN +wp+kPmb87W7J2XvqwU/bAyAQog8Bziaz9ZR5dACdawY2NHAszz3Ms8+qvr57xIQ5 +qojxsSS5XwJSwKwTVxS+uPVKZLAlmjJrHg8BswwMV+ENRkcoqwQbpBaJzLt6IB2w +zFVCcBDtFs/uqkZKTzgL0iyFWGF1fFHFdZNwuU6ENITSAranK9b89D/H9VnQjBvH +9jNR8OSyB9XgedCsuIR8RtG5HfYof9W0DyiZttuRrYoUK4UByYEVXaIEUa0stfZO +RpYq82JfJz8= +-----END CERTIFICATE----- + +# O=2024 Republican National Convention +-----BEGIN CERTIFICATE----- +MIIGgDCCBGigAwIBAgIQCca0jLzq8RnFZoAjVj25LjANBgkqhkiG9w0BAQsFADBx +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xSTBHBgNVBAMT +QERpZ2lDZXJ0IEFzc3VyZWQgSUQgRzIgTXVsdGkgRG9jIFNpZ25pbmcgUlNBNDA5 +NiBTSEEzODQgMjAyMyBDQTEwHhcNMjQwNzA5MDAwMDAwWhcNMjcwNzA4MjM1OTU5 +WjCBiDELMAkGA1UEBhMCVVMxHTAbBgNVBAgTFERpc3RyaWN0IG9mIENvbHVtYmlh +MSwwKgYDVQQKEyMyMDI0IFJlcHVibGljYW4gTmF0aW9uYWwgQ29udmVudGlvbjEs +MCoGA1UEAxMjMjAyNCBSZXB1YmxpY2FuIE5hdGlvbmFsIENvbnZlbnRpb24wggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfFpgu/ZMNLQAbyt2yKntMNWCC +ARXGEE+MG2eu4EOKS4kq5X4QtAXdbYIn/ib5MKEP6BfJ1wm8WNvbzUnHewk+C2Sv +VGoKN/j19IDn7Jj3lt0ozx0sEWO2oUXcJMemxGv2Fu5bKGm1mLHTnCRoTIA/Tyg7 +Vzod2S8KkK+v3/CvNmsvI/9OKpM5jkfxBhAmoE+aXZ8V7a+vxNrTQlaPbxGOmNr7 +RpczBAsl0K1n6pCGYmrxdJGEJuM8wJIQOEJ8jt15wgDiDI9aQQVrCjriilR+NWOA +Oi/Z7ndW8QkmWXGxKyKensNrLDPKhLAYTEqmb/rt8bJU9ytEk6euIdFrVzr7AgMB +AAGjggH6MIIB9jAfBgNVHSMEGDAWgBROWLuQHn20++ugTATE1iNQ78zdQTAdBgNV +HQ4EFgQU/6WMaiBfJX5I21CaFOkHP81NpRYwFgYDVR0gBA8wDTALBglghkgBhv1s +AxUwDgYDVR0PAQH/BAQDAgeAMCsGA1UdJQQkMCIGCSqGSIb3LwEBBQYIKwYBBQUH +AyQGCysGAQQBgjcDCgMMMIHBBgNVHR8EgbkwgbYwWaBXoFWGU2h0dHA6Ly9jcmwz +LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJREcyTXVsdGlEb2NTaWduaW5n +UlNBNDA5NlNIQTM4NDIwMjNDQTEuY3JsMFmgV6BVhlNodHRwOi8vY3JsNC5kaWdp +Y2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURHMk11bHRpRG9jU2lnbmluZ1JTQTQw +OTZTSEEzODQyMDIzQ0ExLmNybDCBmgYIKwYBBQUHAQEEgY0wgYowJAYIKwYBBQUH +MAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBiBggrBgEFBQcwAoZWaHR0cDov +L2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElERzJNdWx0aURv +Y1NpZ25pbmdSU0E0MDk2U0hBMzg0MjAyM0NBMS5jcnQwDQYJKoZIhvcNAQELBQAD +ggIBAAXp8C9FxPKIDxDdAOWPLTeRBke/PZ3huBBrtAdyDV+nLZmQ/mXEJQAFAMZl +o0W9Ae+oVdjCv38tsoLt/n6S8eHs0JRvkFUaMuunQeLGPZos8nylm2t0nyXXOp0f +xtH4CpBz78NOqJa9lU32GYLE96KZrGpgKutZ+rIIzIRxa58NP6C4C/JARrnrLsMb +srHZkefJixyIw51iPwpUZ+M4ncGwf7RSPSDpNR6QLT1Q9BjXrl/ucYyRCGQdYzux +GvUkRBoUZuvzks8c/+7Yoc+08L8OgL1xJ7/TNrnUEsyjf5/76/9P+f8iOF4Jg3FV +3R6tzQItA1ujlHIx2dtFNJlz/hkOV2mmf/dGEoG5YryFT2KkCtPPxO0Ja550sn+K +85leP7qCIr/QqTleaeF8atKseYskY+qz475+H37KKq8mV+pj08mqB/TsiT2D8BDX +N2s8+2j6XrY2QhTj92v2+xxWT+Ct/4FncbuG1jB4U3kyiiuaAN3BvIZRneNF57kT +bBVd95UCxVH9DWDSyHLbZF50pvzO4b0IWP/mv/GwsuNHhRMqgry2VYEi0wLsQ3nk +TusnKp/oEKvJcKXL6D1rmBpMq5XVtmM1G6vtAWSauMyQbfA7QkdIXFcoKN6Jpgbl +39mMbMKbONHG0imMDr8xV6JIDhEISkI6RCW0J/MYxhf6pGz5 +-----END CERTIFICATE----- + +# O=CLOUDINARY LTD +-----BEGIN CERTIFICATE----- +MIIGezCCBGOgAwIBAgIMF+Jea6/jsSAXU0QNMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDYwNjE0MTIxNloX +DTI1MDYwNzE0MTIxNlowgbgxCzAJBgNVBAYTAklMMRkwFwYDVQQIExBDZW50cmFs +IERpc3RyaWN0MRQwEgYDVQQHEwtQZXRhaCBUaWt2YTEYMBYGA1UEYRMPTlRSSUwt +NTE0ODIxOTMzMRcwFQYDVQQKEw5DTE9VRElOQVJZIExURDEXMBUGA1UEAxMOQ0xP +VURJTkFSWSBMVEQxLDAqBgkqhkiG9w0BCQEWHW9wcytnbG9iYWxzaWduQGNsb3Vk +aW5hcnkuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1U2TFkpZ +dmCtbScIM3jO3XezJMjNYAKevrBwOdbsY5E52rSTpZsWPyDyglYj3T+6AH9/BX6S +mx0OY8tV9PwIm8TDF/RYHmDki/SJg6SElNqPPqa0rMrAz1pTC7SD0A9uUTIc4cYB +moca8DfI1fHLS+9uv/1jO5BBO9to2wsVbyUZsniPBwo+zMLkdU1l3Pq/3r3MtTGP +irEE47B3E1gkGdKi0/SB6DUXkzUrL7DqhDhTQDW3K0jbfaOril7tGOJr5W743hSt +lGpp5rr/pBTjnB+UONIemdA7AQ77fvbppaampEbClhC+GtI1GXRSJzh1ULlmFPVX +cad9iRXj+lQTfwIDAQABo4IB6DCCAeQwDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEF +BQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWdu +LmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYt +aHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUG +A1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0 +MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0 +b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xv +YmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAoBgNVHREEITAfgR1v +cHMrZ2xvYmFsc2lnbkBjbG91ZGluYXJ5LmNvbTAdBgNVHSUEFjAUBggrBgEFBQcD +AgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYD +VR0OBBYEFAYGJFUEnl3RCJIqY9G9L5Q+K/v8MA0GCSqGSIb3DQEBCwUAA4ICAQAg +WJS3bIu8xfjYw1AddrvSHnxVAPBU/tK4qU+Xww4pJbCMLvXAg8pWYLJlUl7QrfeF +HAPQ9OZGEspsXMv1JAruoYW3atSyhAq1JfsnIHHF+Ojb7j8a4nlhdSLzT2D65+0j +ZyOePUJOHVUM6Yxt7OFREWMUZe0DvY35kG1a9mspdkoEigKJj33771bwWW/beXd/ +m25PqkDO+2u+KAFTISho/vg0JdcSgqqHJGMEzVR+g7AqazVm3DN6wJ527keX2umu +VbfHa886ndtaiYOi8BA9Ti5yAeH/xQ+POtd2fLWemhbrvG8u+ls1FqB/YOaoMPww +nvi2TUTtKGHe4EWJDvuVT9n8pcL/JhC5+karO4t8UZZYZD2/H9RfZHLA3IUOd+rD +pZiflpeAbgUZ7r6EEprrJzmEX9aRCni0SXYTBs0kcSquRPpBXrYxHVYg99R6h24i +cquQRY3Sa8i/Zns3rh4B6xva6J5+4uEqfrTqRtTihDWuIo3nH9WW3hbrhuXqAVKU +ZLQWLqCr/scHslBpHMA7tMgbUPOL5jgBA1Q0gAdg70wYnv7sZM6EsPUK2Sbrsxc7 +cBMIYk9llQqsGM2OjDovYNQLEA+m2FJzuqtYZv/NES8KK6qhqYqNKn2EyjnONYKe ++8X0Nh9CKBwxrGJ3JnIGhcKUtALxQeH+rfBXD3m9Ag== +-----END CERTIFICATE----- + +# O=Connecticut Public Broadcasting\, Inc. +-----BEGIN CERTIFICATE----- +MIIFczCCBFugAwIBAgIQBUxhXeJjNxbLSlY5IqTI0zANBgkqhkiG9w0BAQsFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDAzMDcwMDAwMDBaFw0yNTAzMDcyMzU5NTlaMIHEMRkw +FwYDVQRhExBOVFJVUytDVC0wMDczOTYyMQswCQYDVQQGEwJVUzEUMBIGA1UECBML +Q29ubmVjdGljdXQxETAPBgNVBAcTCEhhcnRmb3JkMS4wLAYDVQQKEyVDb25uZWN0 +aWN1dCBQdWJsaWMgQnJvYWRjYXN0aW5nLCBJbmMuMRswGQYDVQQDExJDb25uZWN0 +aWN1dCBQdWJsaWMxJDAiBgkqhkiG9w0BCQEWFXJnYWJhcmVlQGN0cHVibGljLm9y +ZzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMq2Jl3kdi+Rv/ZLpaRV +F4i8lR53WtxFpR21MPhAxqpBxcDf8mEEDVzKlRqW9Fxk49J4rnPZt25JrKV5Kq4u +7jEzIgumQLKpFry8yVgA3aUccDaeE6bPifsR+PGwAv7gbUFr250D6LwGD49qA+5U +o3plOPElyHmv+fUJ4djsqLI8AaR2L13M8/yTTS1PqI28IeFOmN36cDuCXHclWtm0 +kFpZGCxefdcCtIZl7WEvB/JemQo45YAcUe+MC+GAmN6TY6Vkor5s/1KOLaJVuZcL +wK4IybDUx7f1TTR3W8CXAIB8DXZsu/L3yO3oa9FBssy+9Ejo+KPFH40UuLRD7tuJ +N0MCAwEAAaOCAbgwggG0MB8GA1UdIwQYMBaAFKViIFDcu1tXl60jjzXiVGypfvlO +MB0GA1UdDgQWBBSqE6/X6CZaWzg1QCAg1U588IaycDAgBgNVHREEGTAXgRVyZ2Fi +YXJlZUBjdHB1YmxpYy5vcmcwFAYDVR0gBA0wCzAJBgdngQwBBQMBMA4GA1UdDwEB +/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwgYsGA1UdHwSB +gzCBgDA+oDygOoY4aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNz +dXJlZElEQ2xpZW50Q0FHMi5jcmwwPqA8oDqGOGh0dHA6Ly9jcmw0LmRpZ2ljZXJ0 +LmNvbS9EaWdpQ2VydEFzc3VyZWRJRENsaWVudENBRzIuY3JsMH0GCCsGAQUFBwEB +BHEwbzAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEcGCCsG +AQUFBzAChjtodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1 +cmVkSURDbGllbnRDQUcyLmNydDANBgkqhkiG9w0BAQsFAAOCAQEAAaAqnjW4uSEq +54Z4ruWtIZA0ea7+6083dLPV/6QKkAdH5laLTPonEZNuiyuGy2GvZpgQfT2TpM9D +bU/BEbADg9tyJVZeP6w5biVaB5SXs6Zv3brKmVg6wuQMzADgoy5qhn35MkmbaSbj +sKL8FWDa0icu4A6UFpi7ZXQFBDoFRoq+5hrOPuUR2N9DGV5Por6hw9xVAWAtKFFs +tJgCRDhfpfS03ubWtGjTtckiaP+RNBlmouNpe66ytjUg55wnAX2FnzIz9iQmYE7C +h+4r7/sbhpx6vveFfPb08JJFroVYN1Esd80yPrQNBba4+z7wZG9i2tusFDQXJ1gR +aKtX65n6HQ== +-----END CERTIFICATE----- + +# O=TikBox.io Ltd +-----BEGIN CERTIFICATE----- +MIIGPDCCBCSgAwIBAgIMU+5HQdMZ9Qm1KghvMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDcxMDE1MDYyMloX +DTI1MDcxMDE1NTc1MVowgYcxCzAJBgNVBAYTAkdCMQ8wDQYDVQQHEwZMb25kb24x +FzAVBgNVBGETDk5UUkdCLTE1NDI0Njg2MRYwFAYDVQQKEw1UaWtCb3guaW8gTHRk +MRYwFAYDVQQDEw1UaWtCb3guaW8gTHRkMR4wHAYJKoZIhvcNAQkBFg9hZG1pbkB0 +aWtib3guaW8wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDL+tJKA3U6 +cU8rVYdwaV6ueccdtjroTS5vAGAq2mmbWLb96aB1JSfha+ERo/dK17C507mw30Ak +xhUvCenliMOIXbZAGiLIu64PZ0nvBJVu+MbhwhTqDkcsONAlcBuvPd3AV0EZL7Hd +fJe4B5cg+9fCqNnH9vnsrLOfttSCSVqfhMn80zHLamWb1qU11dMfCJX2Ot2anUxF +RuJ28lvh9VAod/IVLE4j2DLm/gbiB8RjR9V0sn0xGHzx17oVyPcHr26Ygn3grqiG +y89iCyAEGdMMYpKJrAhPDL9czy4fxlrNIgMuqFDQ2VhNsWetkik8B/1T5flVjjT7 +PuJYE3n6XtbRAgMBAAGjggHaMIIB1jAOBgNVHQ8BAf8EBAMCBaAwgZMGCCsGAQUF +BwEBBIGGMIGDMEYGCCsGAQUFBzAChjpodHRwOi8vc2VjdXJlLmdsb2JhbHNpZ24u +Y29tL2NhY2VydC9nc2djY3I2c21pbWVjYTIwMjMuY3J0MDkGCCsGAQUFBzABhi1o +dHRwOi8vb2NzcC5nbG9iYWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMwZQYD +VR0gBF4wXDAJBgdngQwBBQIBMAsGCSsGAQQBoDIBKDBCBgorBgEEAaAyCgMBMDQw +MgYIKwYBBQUHAgEWJmh0dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRv +cnkvMAkGA1UdEwQCMAAwQQYDVR0fBDowODA2oDSgMoYwaHR0cDovL2NybC5nbG9i +YWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMuY3JsMBoGA1UdEQQTMBGBD2Fk +bWluQHRpa2JveC5pbzAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYD +VR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFFkW1+DWYlb7 +mP8En1i4sfrXthBuMA0GCSqGSIb3DQEBCwUAA4ICAQBPP0PfiYpdWMawVcttBa/Y +bhRzhOzM0+Z9BWFaeuDiznb5WBLiEtEF/oh4ETcPRbs+IzANU4iQwyRGAz89vyxp +4OxcknVXR0Cyrkv0IPMOf6aWtOmpuCAqPfk9qogUGRXCkimKATUHc/epwtF1qBPy +d8c6/4Yh18oTc5QHr/LiF8ppud+z8ADmOhgnO+tGCD08z99uHSKUfJiLVAjNr3CX +8+1LocWuJ3ZwkXg15Mf4G0yIw/0y8ALpaJLwv4n4ToAZaYSjdcXqj45MTRVgQ6yw +7SqTm59etkl+mFH3Lyglo7aeRTFEOypDSUAZQ5XxHxIPTUgALM2IHwfZliFQ66i4 +DmnpzwWPEXHa8MyLDqakNzobzDLXG5VTPtLcplX50kOAarPg6il6YZEbSl59s7F+ +foQWjGXKR3d3CUoCi12B6XHx9vZEQGr8Ii3xHTuYlu4ra1txvhwFnez3RsO9F7ch +7Rp3hGXNgOVODQ+9HQcbFw0JEww3Tes6Da9u+c8dM5MHXS9JS4xrxbXSIqEzCLii +yCcIVP7kWTPU1gFn6w0cXU5a/Kd1yHgfIasarrN3XOGhoy7HCiNtNxEyoAXDECtD +C5+XQ/X/kX120wWt0BwXg5S3rSEhgD+3trbMAqxgOh2zPThLdewHQNID3AxGdkhN +m+Sv3W3Ur2LJFAJfjYjTGg== +-----END CERTIFICATE----- + +# O=Mentaport Inc. +-----BEGIN CERTIFICATE----- +MIIGaTCCBFGgAwIBAgIMdB5xcmQCYBIdWnWkMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDgyMDE4MzkwNFoX +DTI1MDgyMTE4MzkwNFowgbAxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9y +bmlhMRYwFAYDVQQHEw1TYW4gRnJhbmNpc2NvMRkwFwYDVQRhExBOVFJVUytERS02 +NzYxNzI3MRcwFQYDVQQKEw5NZW50YXBvcnQgSW5jLjEcMBoGA1UEAwwTaGVsbG9A +bWVudGFwb3J0LmNvbTEiMCAGCSqGSIb3DQEJARYTaGVsbG9AbWVudGFwb3J0LmNv +bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOAb8+k0Z6W8Ukf9Pkeb +ReGShqVbBeohDix1y7+zxQVbSO8zdQgs0KdNqh5cQ036TBh5Ete4gJt25/6nKSE5 +Z4aswvViEHF/o2+oNyKo+TiSjeWorbm0fBaqyhlvxwtiuUEKQ7rrahjR8hc3xii1 +xuJF8y85AzcNJ2cFyb60AsF1A2G4V6c5Hl11Q+w0/mqTwQTKMpCrFShxWq5J6LQe +qwIbL25pATIcSLqPWHCPNA+zzUegDEFMlYvB2EbyOeHXEnaxYflVzEkmoM5YLf+8 +i85e7ljmizD9tOYiLB16Od+uTJoFpRUikZ4NSMSUZ0YqRjFkRRKctYwwPLBiHkR6 +fzMCAwEAAaOCAd4wggHaMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYw +gYMwRgYIKwYBBQUHMAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2Fj +ZXJ0L2dzZ2NjcjZzbWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9v +Y3NwLmdsb2JhbHNpZ24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBc +MAkGB2eBDAEFAgEwCwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEF +BQcCARYmaHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYD +VR0TBAIwADBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24u +Y29tL2dzZ2NjcjZzbWltZWNhMjAyMy5jcmwwHgYDVR0RBBcwFYETaGVsbG9AbWVu +dGFwb3J0LmNvbTAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0j +BBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFCZZh0O9Z8pdSV7h +cwlVZQduyj5RMA0GCSqGSIb3DQEBCwUAA4ICAQDA1qerHX+9WfW2qxzpGTPRYKhC +HDnGXGsdFZiXNrJznjBJmSVb6NhdRorYinVXjprwNRmonfAXBD8p1ebq/HibiK76 +2+sNkKGXQB8fiB9z9ISUk4v27L/PCGnqdnA8duChVucM/temIW/t1AA96k0cmjy1 +BlaoGklYcXkiLdr33CAICUNqLqkhFxSTdPaPdkIbFxeINmelu967nVAmoFF5kexL +mB7uu18a79Jqx/8ynEAhpjAAwmNGtLNy3/8vgz83+Yrx608iDGdoYOafkxfg9C4h +vZ6N+1WXjntBIIvBiCy5KFa6oQRhvPINWZSEtp9FF6s7MAxLW6LlX1sUXKsh7hRt +aSXCHAGqWzme3fALPQycK2/GCFmt7w6eA322IwQlbipbE6gUd0JG1Z3xr/r2S1JA +1f0SX7R68TKjkRIXQpIUQoTDcihhXqElcOH5qAFQGcePT9hXwrwJ92XqPFrESr1g +xgXfB7ugZ+65qbl+Op6ghH09Dm6ZWnExZhKTn2CffNemKnFrz7mPmwdCpzNhnPQi +bNaQPsqlyeE9NQ0U6BS7s8ttwU9h4mxRLh0UetgkrPFPY3LGIeXqAKfebfTj+27+ +aEddi0GB4ISN/ljt/So5Uzd6GG4ZTS4Ed6Z3zw+mEcF7qm5B7bzViBiXImY5bJS8 +eSh7GqpQ9pE32s7yQg== +-----END CERTIFICATE----- + +# O=FRIENDS OF JUSTIN +-----BEGIN CERTIFICATE----- +MIIGYzCCBEugAwIBAgIMLxx3XMWtHwmaoSfNMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDgyMjEzMjQ0MVoX +DTI1MDkyODE4NTAwM1owgawxCzAJBgNVBAYTAlVTMREwDwYDVQQIEwhBcmthbnNh +czETMBEGA1UEBxMKRmFybWluZ3RvbjEbMBkGA1UEYRMSTlRSVVMrQVItODExNDM5 +ODQ5MRowGAYDVQQKExFGUklFTkRTIE9GIEpVU1RJTjEaMBgGA1UEAwwRaW5mb0Br +bm93Ym90cy5vcmcxIDAeBgkqhkiG9w0BCQEWEWluZm9Aa25vd2JvdHMub3JnMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtQeKJuX1dgHvyqr2pUR/m5tZ +roEjDjZJagQedpWruZenmoHro0wBkO+/ei6c7L7gbXGv04C84YbdILblYmPFZX1+ +briNzEjH5QL6oQaAmNkS8kGvh5SDEbBt7UDqSeb565GiXZBltYosghmzR7AsVRC3 +aaweyFJCdqwRr7awww0Fq83SMByKCRwJxOO1yzx2L5TgdXU5dz2vItNyvKyVeTfL +GIfAjPGsSKsitFgvTxwjgmQDgjy3q2hLcbpaGTTlv0xU5cDYa6IT9rQDqDQcPviY +/x+ScHQe3QSBlPXW2heZB7CxBcr7RS3cXBkOmvWHRQ1tvc8c88MetemiuZNw+wID +AQABo4IB3DCCAdgwDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEFBQcBAQSBhjCBgzBG +BggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQv +Z3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYtaHR0cDovL29jc3Au +Z2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUGA1UdIAReMFwwCQYH +Z4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0MDIGCCsGAQUFBwIB +FiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzAJBgNVHRME +AjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xvYmFsc2lnbi5jb20v +Z3NnY2NyNnNtaW1lY2EyMDIzLmNybDAcBgNVHREEFTATgRFpbmZvQGtub3dib3Rz +Lm9yZzAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAU +ACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFP+zsgBn5BWfFZ9FQ5gwnjJg +hezuMA0GCSqGSIb3DQEBCwUAA4ICAQANdaTpPxfFunhesPh1i0xJSaFVoOKg3zCn +dVo5Du5KlX0bLtU7luCx+fVlQbIGgGC+tuqwn3tLz3eB72+zyKrcbb15oV4rAFAA +BBuKjf+eQkJ4Z9VxGSWqtFvJlT4ScVRfn58XU+HkZDUor0WLenv7YPJ748CKaM7a +STicHJS42NU+XcIUF8wFa7NAXJ58rpbQyHtUFRLbS5tJ0jvYKpzxjsQbC0qTFRgL +YWUUaf4uYiJdMPIzDBJEf/biu/AAs65DDlTX0c+tWMSf0Rw9tXwt2VAA9lLtOuCt +y550liOUFZpbCIEKvbSwhR1DsITC1XafjUH78QMz1CtOqFnrlZOqqDlRl/6t9DgX +oHXILzHzP6cCg8FCc2kKynfu9j+uNAkPwbQGBsnsJEmHtyFiF8hH6jXMisw7VRPB +p83AJXwRQegwGNHns99vGI+EFdFYo9HVecuJupV+k6tOy0u1Id0neizsgXu5a1UZ +xbVqIINIsQwlNBVv9YbraJI+VuMP/HY9TJF1gAwMqQXn+P7v+c9FAkQ72dbcfw1b +5aYIr890CbDvbD6x/Tt6XD20dNFw9kdH/X/3SrleHI4sjIszj/130Pqs2jg8ncCP +lO8IgIzBp9Ovg1RAVXVPgAZfEmaYt7gc5wkqwCLsmwdoYzKZdhOBuhQLs0Hihx46 +W1QFT3N96Q== +-----END CERTIFICATE----- + +# Amazon Bedrock (DUB) +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQD4zK1CTzNcz+XampTEWtgTANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDgxNDAwMDAwMFoXDTI1MDgxNDIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABNmlkm6nPnLgcdspg907Kgwml1sSj3nBukB1 +/DsuYLhf6HVktQwvchRTmMLQlBjomupLlOrgDLkKi3lojX3+JjS2OkOvkzD8A+0b +9rxFB6xRusHRTt4LQYfGXE39NEQEn6OCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBSNgmAfFhZyYrxAqZnVHEr9Xcwt+jAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBGOENDQUQ0MjRGMzM1 +Q0NGRTVEQTlBOTRDNDVBRDgxMA0GCSqGSIb3DQEBDAUAA4IBAQAB4wNVL6fm2g7+ +2FCXOlFgs8+jTx8GxU1lwQXx8GfBNYCC8h8kGY6FMoF7GG7p3QHzMhr/P+FtgK3g +KzGbZtfoGxeXNlb2dyme8U7gZA4Jo+dUtE5jQ3Qq3HFvLD2XeFC5oqTaL8wwJ+6s +Y88xFyt+qgzfzDyQ6dazVcsKuwZpSD5glvekH4UsVfdWEzy//DK+nqu/Q+PL0YnW +ppTzsIk9c36PgvqhYoLXoXHpxP/18DM7UX1elxnv0anTt1vaDrdUFc9ETu/egiWD +6g4963XkvRFEcaLh32Ym2GxMxhN2wHb+4/1lmDM/xgZ3A/LmeDan6HztijPyuFao +sJWBw39f +-----END CERTIFICATE----- + +# Amazon Bedrock (IAD) +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQDoTxo1cQcFRgZuCjsA1tYjANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDgxNDAwMDAwMFoXDTI1MDgxNDIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABEKUt+neiVgWfp5cqjhkwUXwKOkU+mSWU6sa +2YEl9/DfL/0JlPOR9ntsUmsg679LtVPYcEtqqqgIOjJ9redxuAo90VLM01xWT+nk +qUUdtHpBVPRODS3ZrBpECNavldmvQ6OCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBRkOTg3sqb/0k1bHUE+AqFxzLmpqDAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBFODRGMUEzNTcxMDcw +NTQ2MDY2RTBBM0IwMEQ2RDYyMA0GCSqGSIb3DQEBDAUAA4IBAQBqDwAfeE6JQfbs +S/6hwSNN5i2SWYg7z8W7KV2wxVyP9oSxVALvV2r9Eaomn+JHs8ZDi/667gvUDRzX +BRusP3pSOIyVT5tzMk3oGSzZUM16bM4o64FebC1MRpNz2u8yDYhxy9g9QXVCpjTk +WT7hDe7xqsn4aNulNJeS9K4hED4nksTbyYZ6Ef6O9mTgpcwoP5DlVAOH4uYzGZrT +Ixa/eUI8b4JlDCoip+ifl8Kf+qDYiukGa8fYqPQfhY5Od1e8i0u6lcnTZ8gACLZc +gM3ZQIfMugdhMaijqWvdqteMB4rl02cR9mvTQZAQRSdOHbfZfFxtHQ/HpDT737k2 +faRY7r6c +-----END CERTIFICATE----- + +# Amazon Bedrock (BOM) +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQC6vZ69B9VeAkP37XCvozMjANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDgxNDAwMDAwMFoXDTI1MDgxNDIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABGwupmp41Zir6Bbtq4zkvDeJ2iMl3DQP+sOI +ahhRBWgt21Y+TDqPSnzuuecvaY5geUofyO0oX6dxdA2UxkzlFaBNqEANsN6k4nfX +B4dVhMiHBJ3pbJ6gzwwK7TtZXDHF7KOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBThdQh3KeCdUXo20zygjSuujkxcvjAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBCQUJEOUVCRDA3RDU1 +RTAyNDNGN0VENzBBRkEzMzMyMA0GCSqGSIb3DQEBDAUAA4IBAQC/eGuRFX5VUf9A +zG1r4CbXi7hriPhEaWZcT77hyaVjFa1YWL7mLZZ0VEE4cKreVWjDkSMrxRau08rU +vBOnyTzUvWOiHHWfTI2qCgFosALnpR36VsDHWGoxs2IyEuxdOuS77NVFzOb5+Usf +t3W2mNgGApLEJBowDUgM7tJUItVLxZpzFehE3VyYuDv0+myJAxgOFTqH7DeXQ0mN +W2UmNcWrieP8cMKDZivc9ZpfjgeYGf2xJOGONADNs7/W5B9q0WK2oM6m6ADLZFO9 +RC54JBBgS8nEJGV5UhBaui5dWz9cfnoVqgrChFSwCEC2BiJ5DK1EXY0Gg+9EVzwt +Tt2hvKsV +-----END CERTIFICATE----- + +# Amazon Bedrock (LHR) +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQD4J6m0FEHa5Te/vRS0NdBDANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDgxNDAwMDAwMFoXDTI1MDgxNDIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABOkJiMSgoUDsUuZNP/cjLOnB+yDlqO+GiUqz +LIpKNbAAK3y4a/ospgZCEkB/vp1flYlN1Sqq2T50RxgurOfGOprBkZBbOjsIU5PP +X1iacys5z+zLVazBDDHjobsXZazDvqOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBRDEzCA2x7hBubUttkCQh/Jn0kHdTAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBGODI3QTlCNDE0NDFE +QUU1MzdCRkJEMTRCNDM1RDA0MA0GCSqGSIb3DQEBDAUAA4IBAQAqs/1PZGeWe4xK +xfTIirhDWmcnZj2a4kk/9MECxuMrUVXWDIZm9uixbk84VK4QWYMbQ0ESLsPhsD6d +0UODfOZcj/1Y6sSwv4U6hrGm4TWOX+JCmtFzl1/7oKgOxjVF6aNasKU0xgsgjA4n +GXu/f6otONCLe/ZrMLLzXsfHOwAYQh78kKd4igp+yDIpcls/hKryCIY9DeW6lB2P +fXysL5LwLiaGBrC1to9RkFSqNRIGbeGboceq1xCQ2u8qfNqCNAzNna9BBlCkEYu+ +Ivko4q9e5BxRuEycX+8HPqNIQKp/J319L82g1v6wCFjfryoC+UbX2/R/7R7U+bA7 +F9QgglYd +-----END CERTIFICATE----- + +# Amazon Bedrock (PDX) +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQDQAnrAIe+SNGVeWqHIQ0QDANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDgxNDAwMDAwMFoXDTI1MDgxNDIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABLALMRCxpb/bry9DVaSnvDLHOckGmfeBUBSd +T/NbHt+UgLtkDrfcBshmz8fiw/1a3aPBJORv7nOPpq8DvSgFrQ8bu6Z7a8WIslQt +sxZ14FpYpDsD73QlaLLfzEE9f5fszaOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBRm1TijDNu3++xbaE4eu6aa0Lbn8TAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBEMDAyN0FDMDIxRUY5 +MjM0NjU1RTVBQTFDODQzNDQwMA0GCSqGSIb3DQEBDAUAA4IBAQDBnrUP1hEDw5SR +3QTkNDoNyr4x/Ka/vVgsG0QMUV8BACQWqR4Hz8AyxtvowUd8j9JbBMbGhnkDKWFz +PqI4yoEwTx/jNTf2UUiyOJSdLrExroPNSWrzAvZj25C8my4+PVvYrpXRRLWSyD+L +Qm/UoY/u5M181Qu1v7yHVuN/RJqU0SkJw38nhpIGAqOXwhXR98xj0vjoZFjkMgYy +bxnhAGyXS/jaJFbfRvgoFc9gxFpQuxzbbwZHldt4tm2WKCeWW+5sZF19XwLB5xe6 +VlMud69/l+FOJAMkExSODnk7YpWD6q7kp75uVvT0LYcjPQ5qmanNHs6DQjqU3b69 +V2dcIzat +-----END CERTIFICATE----- + +# O=FRIENDS OF JUSTIN +-----BEGIN CERTIFICATE----- +MIIGYzCCBEugAwIBAgIMROOJNOus1DXrj7b1MA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDgzMDE3NDAyNloX +DTI1MDkyODE4NTAwM1owgawxCzAJBgNVBAYTAlVTMREwDwYDVQQIEwhBcmthbnNh +czETMBEGA1UEBxMKRmFybWluZ3RvbjEbMBkGA1UEYRMSTlRSVVMrQVItODExNDM5 +ODQ5MRowGAYDVQQKExFGUklFTkRTIE9GIEpVU1RJTjEaMBgGA1UEAwwRaW5mb0Br +bm93Ym90cy5vcmcxIDAeBgkqhkiG9w0BCQEWEWluZm9Aa25vd2JvdHMub3JnMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwfaIxSKZciKqJpqBgvbBDGb/ +yZBHduEW7LsEQuo2J5+tymjP44DDm0EIj5tA4zs8sj9k1BivViGebzjoZAXu0Q3U +GJJPiSBJuNsIV0s9CkDatXgUJho7TJdbQs4GwqAEy6nCGE6nLBG/1/m7w150gRzC +7bPbnvfQUnYFf4QVID7YUUo0daHSzi8yHOlO4yIJzHJNUBjtTi6z00VtGRLl0iPU +oQQb3Mf5jbLuafs2QQDJwhFCeCGy+ZTZulD60UgD0KnjR4qD/U8qw0V7uFnwRK/P +i+L4Bo9mw7iZ8e1EmJDe29iTqpnxvUYklLrPSJo5XMUsjY3Exw4ex7GQZUfgHwID +AQABo4IB3DCCAdgwDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEFBQcBAQSBhjCBgzBG +BggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQv +Z3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYtaHR0cDovL29jc3Au +Z2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUGA1UdIAReMFwwCQYH +Z4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0MDIGCCsGAQUFBwIB +FiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzAJBgNVHRME +AjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xvYmFsc2lnbi5jb20v +Z3NnY2NyNnNtaW1lY2EyMDIzLmNybDAcBgNVHREEFTATgRFpbmZvQGtub3dib3Rz +Lm9yZzAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAU +ACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFK/O7NLdyPS4F+XRxrwk/YlU +hVCdMA0GCSqGSIb3DQEBCwUAA4ICAQBmFsQsFKfIa8n/8kTupR3eh1oovpz89ftm +0HYrJmqP/IWv57qM40YPiJcQItIBAnQbQ0nKKwZBn2KMofDbn6H285eLshvR3lok +aDH862cLE6k27mvIXM+3e/nkhQLPMXBt43LBgO31o9VB95YrC4mzUv/ZsMf0bccS +PMUQtyCy+9gh/FtKeNagQSYcwTVDOO7Kit7GrKy7krZsJyv9HuPGCQViXjWSnLZZ +d3hLFRcoJA1kAUiXVhgAMwfg71TAFD9MZaxL01Zu4EkGi4BOZzcddvoAYtisMzLO +C9H+UCMPjY+t73rmAgu5PLnMw9LoUCNoM29eRxs/iGYpXtZhA3kr0ozTPMCFnfvU +sB7wyPSwosVl0/6loapWb4a42NzWt3/8JSko/gzLYsuAM1BGoG4jcc7GA/fnCJfM +AnQUap9SL4pdymjoHwwIcRW3fo8Lk3NkyQVMODVqUO4iFbciM/upyQR0ZncctxXs +hukxURHThxXScJF5OCdHT7VWJZArlXQREp+ON8PNQszRmEW/yLo3hWWwDNNbXnLQ +mVCf9bEwIlkDWFaePNFos/FWmJg39+V5XOjVWhI4sKD4L14aMLkQBpq3THDQLWgo +acotxTqFqnXvOnsVmidDKzC0yM2OvgBIgnWvSipze7N/ZBw6J3iK9OXFO4B+3lkw +6P0jJ9wqaw== +-----END CERTIFICATE----- + +# O=Westdeutscher Rundfunk +-----BEGIN CERTIFICATE----- +MIIDVTCCAj2gAwIBAgIULuqLr/Y5BXkK/urtyL2da7HVaFYwDQYJKoZIhvcNAQEM +BQAwSjEaMBgGA1UEAwwRV2ViQ2xhaW1TaWduaW5nQ0ExDTALBgNVBAsMBExlbnMx +EDAOBgNVBAoMB1RydWVwaWMxCzAJBgNVBAYTAlVTMB4XDTI0MDcxNTEyMzMzOFoX +DTI1MDcxNTEyMzMzN1owgYExCzAJBgNVBAYTAkRFMR8wHQYDVQQKDBZXZXN0ZGV1 +dHNjaGVyIFJ1bmRmdW5rMR8wHQYDVQQLDBZXZXN0ZGV1dHNjaGVyIFJ1bmRmdW5r +MTAwLgYDVQQDDCdUcnVlcGljIExlbnMgQ0xJIGluIFN0cmVhbWluZyB2aWRlbyBQ +T0MwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATZgxxfdvV/WH6mu4NOvoTtjr7F +8Ed/zodvSxOg9z0HDrQ6KIOgtg9dYUSrOqf+YxqsyosfTtpf7OLbVwiZteESo4HF +MIHCMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUWh9rZtOU57BBg32cDHtdxXNL +S7MwTQYIKwYBBQUHAQEEQTA/MD0GCCsGAQUFBzABhjFodHRwOi8vdmEudHJ1ZXBp +Yy5jb20vZWpiY2EvcHVibGljd2ViL3N0YXR1cy9vY3NwMBMGA1UdJQQMMAoGCCsG +AQUFBwMEMB0GA1UdDgQWBBTVqME82mDKChKQj1GKEOxj2Ma0KTAOBgNVHQ8BAf8E +BAMCBaAwDQYJKoZIhvcNAQEMBQADggEBAJwvjhuw3+j/ZOchY4i0fEor89wL2WlX +yYS6REwK0g8cAyGbQtzhJASvu6g8qNYyOLNiOdloiSdcxsJk/pHF1xUvTUULpJkf +1TZ/HGQHBRQC/734Pi4PscMdR6Vlr5QLNelpEDRuBiHH6zhGUBH7G+OkZRep5K+A +/G1M6EWOBzijeBV/UN3JCT16zRFHYF64+m0lCqx6z0aW46vZ2djlMk+LbV65tnDY +kaavcgJb/7Zua3RWTQbAe5P7MTlNUlMvEYWm54+JvDY99ocmo0k9oYmxdxuaNGNI +UUMUriTQ877PbJklZzg4sEtWVVQKxl2IcXviq/l7INt9wwepW3hrFQc= +-----END CERTIFICATE----- + +# O=Black Forest Labs Inc. +-----BEGIN CERTIFICATE----- +MIIGejCCBGKgAwIBAgIMSQ9FR5L79nV4Vi3qMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDkwMjExNTEyMFoX +DTI1MDkwMzExNTEyMFowgb0xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9y +bmlhMRMwEQYDVQQHEwpNZW5sbyBQYXJrMRkwFwYDVQRhExBOVFJVUytERS0zMjI4 +MzA5MR8wHQYDVQQKExZCbGFjayBGb3Jlc3QgTGFicyBJbmMuMSAwHgYDVQQDDBdp +bmZvQGJsYWNrZm9yZXN0bGFicy5haTEmMCQGCSqGSIb3DQEJARYXaW5mb0BibGFj +a2ZvcmVzdGxhYnMuYWkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDX +f3Fpujr8FLrF88BVU3P/bJlmNbLmyj31bEHriUuva+i7JPqWn2jw3RL0RO8M56al +x/fQWc7/wHb6YzFzMy2uEjnvO8/ZxDnl8j8ZmG0L++dpUqR4BEx14Q1KykoTITgu +lLP7iC7cMM1qITbHK9VWnl62k5CF6OKwJuptYvlpiVaBDVWYRVmXSIKqf3gvWEf4 +xJusm+S9+3GiIbt6DujLRIqy5cZfrXlQSLdDFz8iIVBIiYibWr8Mkujy4h3MwWPc +ZUiPi12zLvCehUB+tc3kdaii71l7FdPopQVlP0naNU6t9QWcZAypflNCbda1pUiC +4X8tm1/jpTZXlJht2DvBAgMBAAGjggHiMIIB3jAOBgNVHQ8BAf8EBAMCBaAwgZMG +CCsGAQUFBwEBBIGGMIGDMEYGCCsGAQUFBzAChjpodHRwOi8vc2VjdXJlLmdsb2Jh +bHNpZ24uY29tL2NhY2VydC9nc2djY3I2c21pbWVjYTIwMjMuY3J0MDkGCCsGAQUF +BzABhi1odHRwOi8vb2NzcC5nbG9iYWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIw +MjMwZQYDVR0gBF4wXDAJBgdngQwBBQIBMAsGCSsGAQQBoDIBKDBCBgorBgEEAaAy +CgMBMDQwMgYIKwYBBQUHAgEWJmh0dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3Jl +cG9zaXRvcnkvMAkGA1UdEwQCMAAwQQYDVR0fBDowODA2oDSgMoYwaHR0cDovL2Ny +bC5nbG9iYWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMuY3JsMCIGA1UdEQQb +MBmBF2luZm9AYmxhY2tmb3Jlc3RsYWJzLmFpMB0GA1UdJQQWMBQGCCsGAQUFBwMC +BggrBgEFBQcDBDAfBgNVHSMEGDAWgBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNV +HQ4EFgQUhpapbE484V7g1cVntGvzogJqZN8wDQYJKoZIhvcNAQELBQADggIBAJmb +zEylsj/FxHaLcDJ9CtQIcUzCXhiT36L+l9c0kPcmMHIAGWAimE81+Fp/wsVXZFAI +DbaWBL6NoYrB3fngaDzqCSa5rDl55YLJ9AWx/n7TFEO8Y9mCE1od9qO2AOOCdrrq +tTuK4ykQLUQytMDkbFVaFpd6rBCg+AVLY7DoDTQBT5Wwwq6SKB4f9T0aKM5aU6xx +5l8/gIOwZ8jYRsgQoh+h6bgRqIZEmop6t9hM+594fjzZAAe4EIs/4O/6OD0ui8Qb +k9/dNycU5fRecfSyoaD7+bomgf4aXeafh/4/CaUSnxphDmNTxJE8rCvhzd0DWlii +D6Y8/mwnsVPp/TAhZ5SgujOpMHGQzj7hK2eQGNi/X8mHt99QBufEHNUjBlqXTjDT +W8/JI+hXThL1F3tjj7wV2Cx+xU+KxK6RFRINhgY6zQF1jA3uc8ncYF0gnO8BMT6B +LBcEMujTM3+vdf0eAxCVjKieOWQKBaKqH7615FO9emd4wSzxx2eOa8kStc9mNQsR +v6HGgOI6j0F/4j1OnjAzyh9GsMzI9tYzQsRQB1jqbKngJCX3urCPt7RX2QyeXDKr +RwpQu1xaUkkCRk/j6ciWgOmiOSNusiMX4B7TY1b5gw+i1oBdUd2qFVOKCKFiXNXa +PijSPwMfHn5lMAIWbhG+j19j8HoJqICUHFsfxbvf +-----END CERTIFICATE----- + +# O=DVIDS +-----BEGIN CERTIFICATE----- +MIIFZjCCA06gAwIBAgIQAaNT/MkC2QFlBAzo7vjo2zANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjQwODIzMDAwMDAwWhcNMjYwODI1MjM1OTU5WjBlMQ4wDAYDVQRhEwVH +T1ZVUzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCE1hcnlsYW5kMRMwEQYDVQQHEwpG +b3J0IE1lYWRlMQ4wDAYDVQQKEwVEVklEUzEOMAwGA1UEAxMFRFZJRFMwWTATBgcq +hkjOPQIBBggqhkjOPQMBBwNCAATI7HzKK0P/R9OeAZiKodulJHEM0e85BBFfuvgg +vUMQ75pjZ5zMj1/P2Wx9ysA677nIYBE1KV0mV1r/5DMtxVZLo4IB3jCCAdowHwYD +VR0jBBgwFoAU95uiTtOXxfQ0D0MOgYXOkZMyr/kwHQYDVR0OBBYEFM5eclTRxjSO +FpDIDk8cdIBx/EBDMCEGA1UdEQQaMBiBFndlYm1hc3RlckBkdmlkc2h1Yi5uZXQw +FAYDVR0gBA0wCzAJBgdngQwBBQIBMA4GA1UdDwEB/wQEAwIDiDATBgNVHSUEDDAK +BggrBgEFBQcDBDCBqQYDVR0fBIGhMIGeME2gS6BJhkdodHRwOi8vY3JsMy5kaWdp +Y2VydC5jb20vRGlnaUNlcnRBc3N1cmVkRzJTTUlNRVJTQTQwOTZTSEEzODQyMDI0 +Q0ExLmNybDBNoEugSYZHaHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0 +QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAyNENBMS5jcmwwgY0GCCsGAQUF +BwEBBIGAMH4wJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBW +BggrBgEFBQcwAoZKaHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0 +QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAyNENBMS5jcnQwDQYJKoZIhvcN +AQELBQADggIBAI6uwBW9FHvVfv4oIo0VwjXXNBpAgFsh/FZfAluTBRb9LUi6Zsec +IypfD1YTZlCbv9zcCG/5RjjjR9MZv88Cyt1IZZKpAlAyrSjspa0IP0xT23A5+OkT +KATrQH/uc4U9xyoUan9kxkXKDefzNtxv656Xlr9uSOFptXvxNV0UC440OecP8fFc +1jfWtE8ZzoyzDetaMJegEchQwQhSNpYbmyaQIvuOgkNrQCgKX+WPVf19JzyCFsYz +H8/R3zqsgMWQZNVj1j8dRunrOA213kRcKyojFSK9hmWFRG/f6aBWr8NvcoKsWr54 +hACjwqlqrbg+72sKmAK6riEWIkZUv7kj8qV92yJQsIt49xPOPkW0/2NcWFG9IPuy ++nvZ6EjtQ4zFtspBexLmOnZaEWt3J4ioF6kCRcX0bAQQWHtXLUy0mXoyjGxcQ/HZ +zxMTUuf786qy70JOtlqXzAkQ5AgZ+z16qIQGxx8NfUi6WFrODrFkmXNTzbMjD1+D ++eawNMb/4Cf407hrzniie6HKAjZognwIOIASWs5xsMZfBwWtn9/cTySD4MHKjMtL +c8SRxNcRPwF58kS94d2+8m1k/znMFxcnKmC/vB6sxQgmNgdnQlWjYKJvOaTYv/eL +vz6vdktB+UhpyiECEgyI5n08Gu8HxK7k6cvoBtBvuMkIthjJQ+ADaOZ1 +-----END CERTIFICATE----- + +# O=TrustNXT GmbH +-----BEGIN CERTIFICATE----- +MIIGOzCCBCOgAwIBAgIQB08ebTKRKxg4ltSVVQgEiDANBgkqhkiG9w0BAQsFADBO +MQswCQYDVQQGEwJQTDEhMB8GA1UECgwYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEu +MRwwGgYDVQQDDBNDZXJ0dW0gU01JTUUgUlNBIENBMB4XDTI0MDYyNzA4NDIzMFoX +DTI1MDYyNzA4NDIyOVowgaoxITAfBgNVBGETGE5UUkRFLURFSzExMDFSLkhSQjE4 +NjU5NDELMAkGA1UEBhMCREUxEDAOBgNVBAgMB0hhbWJ1cmcxEDAOBgNVBAcMB0hh +bWJ1cmcxFjAUBgNVBAoMDVRydXN0TlhUIEdtYkgxGjAYBgNVBAMMEWluZm9AdHJ1 +c3RueHQuY29tMSAwHgYJKoZIhvcNAQkBFhFpbmZvQHRydXN0bnh0LmNvbTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANewXEY/7XxPYpO0e9MEiPVob3uF +HTXElGvKGiBvC0yu1bqxmxyp7iXHQbBwlI85f/1J3MvQ0/6VcO6uvahC9Lds73hd +Yy4EF7XWNNXqg3ESsh96OPcNuP8a/QG7Qsn7uNiJt61MYA+A/apD3S8hTK2EhbPZ +vi1sC6dnf3fSMU6Rn4Nwxvm6vPCtHB25sKKw0EnQ6jpcf0pjk6tyffAvEgKX4K3E +BNQu9cyk0Yfo8cFR0/mGnIUX3UNx7IRPZqi8F8gBP474ypLOsKKq0ps3bjOM1+33 +XOU7u2jaIavSYsrxdQBavlNHazbHiDAvtLegrd0xNzcGymAXyGsBjHJs73sCAwEA +AaOCAbYwggGyMAwGA1UdEwEB/wQCMAAwQQYDVR0fBDowODA2oDSgMoYwaHR0cDov +L2NzbWltZXJzYWNhLmNybC5jZXJ0dW0ucGwvY3NtaW1lcnNhY2EuY3JsMIGDBggr +BgEFBQcBAQR3MHUwLgYIKwYBBQUHMAGGImh0dHA6Ly9jc21pbWVyc2FjYS5vY3Nw +LWNlcnR1bS5jb20wQwYIKwYBBQUHMAKGN2h0dHA6Ly9jc21pbWVyc2FjYS5yZXBv +c2l0b3J5LmNlcnR1bS5wbC9jc21pbWVyc2FjYS5jZXIwHwYDVR0jBBgwFoAUZvvD +D770v+CcyatN3kcZvcDKpmgwHQYDVR0OBBYEFPzsexlyLRf8kL9hxymo9fl/1G11 +MEwGA1UdIARFMEMwCQYHZ4EMAQUCAjA2BgsqhGgBhvZ3AmQDATAnMCUGCCsGAQUF +BwIBFhlodHRwczovL3d3dy5jZXJ0dW0ucGwvQ1BTMB0GA1UdJQQWMBQGCCsGAQUF +BwMEBggrBgEFBQcDAjAOBgNVHQ8BAf8EBAMCBPAwHAYDVR0RBBUwE4ERaW5mb0B0 +cnVzdG54dC5jb20wDQYJKoZIhvcNAQELBQADggIBACkaeXPf6PoIN/WVdE9v6v4Z +uLNA9ZAeFXx9R76OKo/+oFrR2k06hz2kO+AEiRAaACy8Vuj0zBUL82C+lYEG4mDA +cW9i0K/J2APsxze+wLrymNw4eHcwoB930pMdBBHGYX93QJLOQfm7yl/rLXwW7EwQ +bKmpuG0zCqUrpHbWDONrGYYk2JvaC4hMLiIVcJCITGFpzehF6hTHMEbhCyeMR0sN +e61ziGBxNBzD5agn0mlqmqxiaAlZHzA3056IAU5B4a+gBYA5zBDPdHb92Pj33auP +W3gcHPyPlhGriBtWcYr2jPw71V+9bXY0t9fl0EJTmdrmkGbyO/09udiqTQv03NVQ +Ro+xHy4fvbQI8/ovZemFfWkXJ/XKCXXwn8dN7jW+1yMFZPvIMAkqkC9Z/wrijP8A +gsmWkd6rawM8mG9ufh4CA9Ss2JM/OSLNknu+3XfYAhdM/735IUUqg/BrcROfiNtZ +LH6CmJ/ZHHRpdsGGiViu3LzUbiEpZaPF6aBAoChJ6kqU01EP9ZeFvwL4T/oxtEf/ +NBTm+exBFpeJV3GgqfuG2F08xL5LwFMJGWzNqRmzaWGULcISikM0Ew2FGsLkAeKz +AiRb4PZS9zscc0HBG67ppV0OQZWQnOHaXYR+IJdq4mPIHBZKPrYK/CythGyh/QiI +/xbCKG+OmLMI3REBO4lD +-----END CERTIFICATE----- + +# O=Contentlens.ai +-----BEGIN CERTIFICATE----- +MIIGWjCCBEKgAwIBAgIMLxVE3C0qjNZHwC8TMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDgyMzExMDIxOFoX +DTI1MDgyNDExMDIxOFowgaExCzAJBgNVBAYTAklOMRIwEAYDVQQIEwlLYXJuYXRh +a2ExEjAQBgNVBAcTCUJhbmdhbG9yZTEYMBYGA1UEYRMPTlRSSU4tMDMwNDM1MTgy +MRcwFQYDVQQKEw5Db250ZW50bGVucy5haTETMBEGA1UEAxMKUm9oYW4gU2FodTEi +MCAGCSqGSIb3DQEJARYTdGVhbUBjb250ZW50bGVucy5haTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAMrCGWAx4LfBSB1iFNDDtpe7/8K02vpZ6mFJYDKr +t8j+z1ITucYdN7oY7H6PqvUvhM8s3H25l0N00JVWVor6sIJOK19u0KXwGLn1SetT +ypmXhwoOODsUCtAhvX+dVyoVZScSn5Ba6OAJMcTf9zFPI1+ywIhfpVRAuE8jn9pQ +hOpAZN/MQJGEKRt9VWJjsbkqOlOqsnS5jVZeG5qyrVzrAv/2G00HmHDK3BMdRRPa +PRLvvg3DM0SWimW8N0+E85n213PMpAUn0QqhFSIFNasw6FLql53ehnlCUvnSg1SO +O3wNPCD5vhd2ZRH5K+gvI7wQi3qHmXVbulauBBeHoYgIic8CAwEAAaOCAd4wggHa +MA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYIKwYBBQUHMAKG +Omh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dzZ2NjcjZzbWlt +ZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmdsb2JhbHNpZ24u +Y29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eBDAEFAwEwCwYJ +KwYBBAGgMgEoMEIGCisGAQQBoDIKAwIwNDAyBggrBgEFBQcCARYmaHR0cHM6Ly93 +d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIwADBBBgNVHR8E +OjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dzZ2NjcjZzbWlt +ZWNhMjAyMy5jcmwwHgYDVR0RBBcwFYETdGVhbUBjb250ZW50bGVucy5haTAdBgNV +HSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+v +LVAt26AjhRiwoJIwHQYDVR0OBBYEFBwuyw4+T0Hwv8VsCkSa2JQpbomHMA0GCSqG +SIb3DQEBCwUAA4ICAQDByowC+z6v6MT3/wRCoqzlQeMtyrXJDvctS3Y1DPnw/wX0 +hKjHTdzSExPKeReosei9BhVIVMCMyZp/lDAv8vtmsxn3rbM8RPYtNZ+V1Tbwf0R0 +KGyEQZ4Lw6kx8t/cSD7JHU+cLu3Gwf4GQy3lHAWxw1ZZTIoEKAtaljc77+4tzCOL +T+tSl1E7hOx1+4L0Oig4RCjnXblIPkipKBg6X/ALxdtQhgj1HvALj+aeC5JciAb7 +qMKEX+co2wrBxU7gnwcDBOeLq2zXBqBgtpf4jFYjP2IF6jNFNFYBznnbMRWNXTLI +jpXcgCB0g9MHqjK7swjFMqtW6fkbnu8YAt4sFR95S3vheL6uygJPL6MGGBsxVAAV +vNCssaBINmByTfXNzqfxj/Re+21xgdUu2oFjLcMuOfq+WKwZJuvTBtHaz9EjzYfE +dC97uzT6GngryresVjR0Io0PjYxg2BNjhToR5ryqhtF5QKZMURMrmj2fIdFfjGZv +XL4ESpVUanqWLmhUClmcTYx4A72nU2YKj+sNVbVa+lid3WtJBYgUersNRTP3bZi9 +U9LOA40fcIgeW7j9ybaYkv4UAmiO1PLYyk2BHhD96TOyA8m4SxqewTQgwyB0Wbd2 +LuVvF7QAqnUnlloQMDO1IIgSqN9PS9hOP91vXlfQht0r6CqMpszQ4h76iAf7wg== +-----END CERTIFICATE----- + +# O=U.S. Department of Homeland Security +-----BEGIN CERTIFICATE----- +MIIEzzCCA7egAwIBAgIQBuDIB3tS+1N4mpyHDJN88zANBgkqhkiG9w0BAQ0FADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDkxOTAwMDAwMFoXDTI1MDkxOTIzNTk1OVowgZ8xCzAJBgNV +BAYTAlVTMR0wGwYDVQQIExREaXN0cmljdCBvZiBDb2x1bWJpYTETMBEGA1UEBxMK +V2FzaGluZ3RvbjEtMCsGA1UEChMkVS5TLiBEZXBhcnRtZW50IG9mIEhvbWVsYW5k +IFNlY3VyaXR5MS0wKwYDVQQDEyRVLlMuIERlcGFydG1lbnQgb2YgSG9tZWxhbmQg +U2VjdXJpdHkwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQl0+zEo3dpjONZ5r1E +kDmIUHVrBcnyz8QqFsNN1O3zTH5MwQGyoJ/qm6ofSPcUBFfLYa/2nGLOuT/027a3 +ngHCo4ICCDCCAgQwHwYDVR0jBBgwFoAU7841k872hsX4hPUM51pv2S9L42QwHQYD +VR0OBBYEFF7i7TlMQwLniqJwY6H6M3u95EJUMBYGA1UdIAQPMA0wCwYJYIZIAYb9 +bAMVMA4GA1UdDwEB/wQEAwIGwDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUH +AwQwgY0GA1UdHwSBhTCBgjA/oD2gO4Y5aHR0cDovL2NybDMuZGlnaWNlcnQuY29t +L0RpZ2lDZXJ0RG9jdW1lbnRTaWduaW5nQ0EtZzEuY3JsMD+gPaA7hjlodHRwOi8v +Y3JsNC5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS1nMS5j +cmwwewYIKwYBBQUHAQEEbzBtMCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdp +Y2VydC5jb20wRQYIKwYBBQUHMAKGOWh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNv +bS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLmNydDATBgoqhkiG9y8BAQkCBAUw +AwIBATBZBgoqhkiG9y8BAQkBBEswSQIBAYZEaHR0cDovL2Fkb2JlLnRpbWVzdGFt +cC5kaWdpY2VydC5jb20vMDZFMEM4MDc3QjUyRkI1Mzc4OUE5Qzg3MEM5MzdDRjMw +DQYJKoZIhvcNAQENBQADggEBAAbnAlGi1oE0Nd4Tq31zkC/q/VjOibl7/He5KiXm +v5ySSBwhcSmxq3MdDIzk/BNZfb+UXX5GmyJeoKga6Li8UaUyMxUogAYh/A55wpJ6 +fZSfULYOhtKAEGzroGI/4EsntNNJ7Ku/hlCrtXFcGRfuQI++47o70ZNKJxN4nAbX +IZ6KaI+vt65t18uIf9uRT1rhfhJjmE+KYof+Fqc4FLYoAW/CLxG2XK6x40aewnul +Li3Ly3CCk9frTd1f3Vja8EKlmMlSjzTMjTWQ2hbbygQ882bKUh5zGdafzyvpc2un +i+VcqXlmnwkC/4nuZiwaIFyqxpmWCu2qFRr+4727XyPTKBY= +-----END CERTIFICATE----- + +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQDRe+9AbKWewjUc6ytLjkIDANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MTAwMTAwMDAwMFoXDTI1MTAwMTIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABG6ClM/aAML0Fu+gDXRRNrMIf5wG0DXtY8+p +HHU3n+RXHiKpjiZxOb8algqE2lvcTPvKMLu9FUVZzPw4glkSivhn3GmcY0W+QV0Q +u4dRC1LCLLpIZYeXfbjxFUuzhXaB1qOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBT5PUOVffGYX/e+VOqil4M5X75yRDAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBEMTdCRUY0MDZDQTU5 +RUMyMzUxQ0VCMkI0QjhFNDIwMA0GCSqGSIb3DQEBDAUAA4IBAQCYA7Er0d7XWcDx +M529+DFUyI+Y5hcLGAMm/7NHFGEnLdEcMwSNkLdW4cbnuof8wgqHiR3mweRxBEBe +7VDFBmjr4C0REUaPt2f9FaMrSJb4ETklDzHlhz3MyNA+53J+Ffm+6RawXXq8P+8t +a0Yut5GwpiTbonh30iIKizRY4idRdI2W0RiIMIG7nAdHdgHOHQ/lBRNwhA6Hb6h4 +ZibkNfBq3I9n3SCQdUK8/FIkWfZUT3XIKt4zn6kiUy8WEcARLw1PtuF3p+JMFyzA ++e93CW6Pu3wbzHmOhxzDuE3cjGoNajRlBlu3S8jgXzfCy+Yz15JbH9/1JqAwfX6y +YKLpmNkG +-----END CERTIFICATE----- + +# O=NIKON CORPORATION +-----BEGIN CERTIFICATE----- +MIIGrjCCBGKgAwIBAgIMXmToOsNbbMSU1Yf2MEEGCSqGSIb3DQEBCjA0oA8wDQYJ +YIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIDBS +MQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEoMCYGA1UE +AxMfR2xvYmFsU2lnbiBHQ0MgUjYgU01JTUUgQ0EgMjAyMzAeFw0yNDA0MTUwODEz +MDJaFw0yNTA0MTYwODEzMDJaMIGHMQswCQYDVQQGEwJKUDEOMAwGA1UECBMFVG9r +eW8xEjAQBgNVBAcTCU1pbmF0by1rdTEcMBoGA1UEYRMTVkFUSlAtNTAxMDAwMTAw +ODc2MzEaMBgGA1UEChMRTklLT04gQ09SUE9SQVRJT04xGjAYBgNVBAMTEU5JS09O +IENPUlBPUkFUSU9OMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvBZ9 +3mrxFtzPIiKSB6FAc+0pDbh9w2GxISQ39R4ovkKDyS+6+8gDT9tFZBxDAFQ5245p +zrrWVRi/eiXbFhHkcQLEAEHneteWG6+CRAyfYfhlDVQnlMJ+w8aJpvxTJfeN0Veb +ZO3xC3OTv//nPazjuxo3XgE84v/WK9Lhd5E9QdogkI396tH1KynyFykfgftkmaIg +A3gSIaqdowxzwkIai8ey0t+JH4GpBvQ/eJMAl06ZOpFKFQpDOpzZVIHIApKVj02q +0LAhIi/BL8+maL9o5G9LTasv2cfBYOkCZYDAuU8Cfga2chkN4NBXrj3Wu5OOt7F1 +iZ5GCHsOaZI8chPzPQIDAQABo4IB5DCCAeAwDgYDVR0PAQH/BAQDAgWgMIGTBggr +BgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxz +aWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcw +AYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIz +MGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoD +ATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBv +c2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwu +Z2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAkBgNVHREEHTAb +gRlrYXRzdXJhLml3YW1vdG9Abmlrb24uY29tMB0GA1UdJQQWMBQGCCsGAQUFBwMC +BggrBgEFBQcDBDAfBgNVHSMEGDAWgBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNV +HQ4EFgQU8ucoURD5uAcFlrrKQ5vrorNpNgUwQQYJKoZIhvcNAQEKMDSgDzANBglg +hkgBZQMEAgEFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAKIDAgEgA4IC +AQAPOK4QvsuWN1aIP6D+P6JeEEQH0JWnjM77QNcVRcQ4oIpcMW/o8RJ98ZugrHcv +TRCT+qYghTXS7o7LjQRuFUJRADdoVFNc3luiniI/bjtRr+yBorxHPsz9N6QJCvcm +RQD20p8MpMrm/LVo1hm1/0fsQEgSksGVszSeSOyapAu6PKKkJUtcthdax9gcif9g +spfKA0GeFFnz5dJFhz8w+yLNBH79r/p1zl6C/u6KCZ/IP8XPE4VZCp2Mn0skuCgz +eO+MXist4OCaSK8tsBmKLcV9JuBScCY+nnYd7mh1st6k4tLK6E1nd+93tduaj1ea +xII8iarqYRVmj4ZMe/bqCCp9oITohdS65kH5eYhwPGtCTRC1dOe5oeR4g+HoOvVn +Fv7ohNBk8TDvKxK/eJM+5Wxkvi48BQoMVcv2f/dc0LDv3aibfV0uR7DPtr8dRP2U +4PeDb2nHrezJADRPHWc0ncnyYmHWHMbDQ7kUf15P/6eosppgYB9TlrVWOp2Kr4ml +G8DUrNQ7hxfl/9LyaT88RRygZkvXEyCUl+6o0N7hRj/Gzfg4TpQKZvk62oVia79/ +mQux3F2Pp6hQ+Xl+l+ivq2U1BI97zbrkkSuFNlfvJCeyUaAbRzy90CsDWcyke1xw +t7OzqGE85C0kux5+ja0HrJCJs+h6OEXfv9p8nmRlJzmk8A== +-----END CERTIFICATE----- + +# O=NeuralComs SRL +-----BEGIN CERTIFICATE----- +MIIGZTCCBE2gAwIBAgIMYiQfR3qxOcKRucjbMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDYyODE2MDgxOFoX +DTI1MDYyOTE2MDgxOFowgaoxCzAJBgNVBAYTAkJFMQ8wDQYDVQQIDAZMacOoZ2Ux +EDAOBgNVBAcTB0RvbmNlZWwxGTAXBgNVBGETEFZBVEJFLTEwMDU0MzY4NzAxFzAV +BgNVBAoTDk5ldXJhbENvbXMgU1JMMR4wHAYDVQQDDBVjb250YWN0QG5ldXJhbGNv +bXMuYmUxJDAiBgkqhkiG9w0BCQEWFWNvbnRhY3RAbmV1cmFsY29tcy5iZTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK9KdPZQ+jTI6CqhMoRoNaeffDLh +BOrC0VMAQOwL6UMxuM1pf9vLNyf+SPBvbghKA782U1TcTvpRSrZUzVgefmj04Xo0 +ASAmjbrPDfS3bOoysnp3kC4yO/7WC0TABo102dMEAuftu+cTsELoqm06j+ptTqi2 +xgceuJDwUtFM/93eI1e/RYGeJRgddDqcHK8RnSNQTQPDuV3KFHACQWumkubVNXE4 +Onop+asBxTtQ+P/USLC1z2+W+fp4FHx5fLzWS1IG2utFr3liHjhvltjCcOn2nupl +dqwNvkEDdlUY9UopNLraU/kKrL6fH3eNwH1NICAWSbfAJC8ECnsuXZtRvpcCAwEA +AaOCAeAwggHcMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYI +KwYBBQUHMAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dz +Z2NjcjZzbWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmds +b2JhbHNpZ24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eB +DAEFAgEwCwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEFBQcCARYm +aHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIw +ADBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dz +Z2NjcjZzbWltZWNhMjAyMy5jcmwwIAYDVR0RBBkwF4EVY29udGFjdEBuZXVyYWxj +b21zLmJlMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDBDAfBgNVHSMEGDAW +gBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNVHQ4EFgQUsCjpO8KZkra8RTCCRv1g +IGhQCPowDQYJKoZIhvcNAQELBQADggIBAGp/e4gWeuCWDAMbVWStY0jfBIfJx619 +q9I8r/e+57k8KkSvuoi6cfweo8uFj2acgFyWDphnsyrHQhLRjcHIVYOJcRETY98A +RaZTsucZgB6Ue63V3yXjkAAhlD2zOUlHRJtrQhD6Mn5RZ14mMH9qq8zaGunAvNG9 +qJlVA8jKjJ8gF3MWPjyvHPP8lFg4+M67xG2gIYfafYxzL9rZPhmXNLpXU3M4wvLq +MVe7oNxsAigJ0nTxCt7QYeGAGehWMqqa5tiOl9dxwqE8LtduoBee3Mj27B6M1d5F +Lmxf1Gp7BkDR8dI9FGjwmWMr6oguYnf9v90uLmUCY5x+MoCbmBQtRS8OZcs4CjRJ +PmZAJN0KrZLSj5C5DWjTlW2puK8qkH8r7qULh1urWgIz3tx1nGJXy9dW1YlmZGTN +Ft2BWppAdUqYIOUwz+O79pyiJpPOCvQfPqJ1gl4+qQV0dWf79YdKFc3GVJN3Wa84 +RCuwULdOVWvQawuEp+40enW0PTiAmHC9M5awcJcCqKMDBrqWWBbAph3wpJ+uw/RL ++5D8O4kgi4hxAl5pcFfvytoZFSyokrelGP90hluDsmMuCq52o5R4Y8GAqrH3RIDI +vwYoI9IX2iK44RHLKEzKaweAj07bfg7Yxo+XrI1HCU2EAOplRGJq9g+8I8FmQCee +b5OjWkwHOT4+ +-----END CERTIFICATE----- + +# O=Stability AI Ltd +-----BEGIN CERTIFICATE----- +MIIGYDCCBEigAwIBAgIMQqRYXyTjPw9Ic8cAMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDkxMzE1NTgwNloX +DTI2MDkxNDE1NTgwNlowgaUxCzAJBgNVBAYTAkdCMQ8wDQYDVQQIEwZMb25kb24x +DzANBgNVBAcTBkxvbmRvbjEYMBYGA1UEYRMPVkFUR0ItNDEwMDI5OTQ3MRkwFwYD +VQQKExBTdGFiaWxpdHkgQUkgTHRkMRkwFwYDVQQDExBTdGFiaWxpdHkgQUkgTHRk +MSQwIgYJKoZIhvcNAQkBFhVzZWN1cml0eUBzdGFiaWxpdHkuYWkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDsdK+z+MofM2GtTwItj3ewgBKAjON2Vy0I +Bh7bQ7Xg29bRYSVsRU0KbQrJVZpUQC3ecio2ajWmHa2puzj1z70ZBJutoZ+vmYIS +pyIDZP6t32CK4XsURT7anGQr3ODYoWmAVzPovjh8Y94dCGBwzxpSDaGLyfAvFSr9 +OawjTjW4VUYYjg4/Tf178jvFoEDdaQIDgLwf21N9ykKTtonsiGaf0QcqIMa2loo3 +7KG6k3/EufZ5+HgK7HDqBwf9kbNjnCpJw6sMfkhZvMlgVkhwdxx2I4w5JpWkJiT7 +HDJjErUhk3QfReOll3L8TXQ7YAmRP9FBqbtupRF/Xw4EkgknAO01AgMBAAGjggHg +MIIB3DAOBgNVHQ8BAf8EBAMCBaAwgZMGCCsGAQUFBwEBBIGGMIGDMEYGCCsGAQUF +BzAChjpodHRwOi8vc2VjdXJlLmdsb2JhbHNpZ24uY29tL2NhY2VydC9nc2djY3I2 +c21pbWVjYTIwMjMuY3J0MDkGCCsGAQUFBzABhi1odHRwOi8vb2NzcC5nbG9iYWxz +aWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMwZQYDVR0gBF4wXDAJBgdngQwBBQIB +MAsGCSsGAQQBoDIBKDBCBgorBgEEAaAyCgMBMDQwMgYIKwYBBQUHAgEWJmh0dHBz +Oi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRvcnkvMAkGA1UdEwQCMAAwQQYD +VR0fBDowODA2oDSgMoYwaHR0cDovL2NybC5nbG9iYWxzaWduLmNvbS9nc2djY3I2 +c21pbWVjYTIwMjMuY3JsMCAGA1UdEQQZMBeBFXNlY3VyaXR5QHN0YWJpbGl0eS5h +aTAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2 +nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFMxIWxCXwHf1Unk92W4yp6FO+gqG +MA0GCSqGSIb3DQEBCwUAA4ICAQBcr/+O9cYHVjH63AKZvRRYTrSEdqBJ4SphsG2I +9ewAOAv5ga3jrtLIB4Ylg6392b6OuKQBlCWybjtqwR95XmRwvu3gpSSmwei8xpBV +dyrU1slPlEGD3lHXMRpyEVRG7XXUo2i+4o7vtLqr+5iyMGS5tiV8bLGOpjs3KptW +Uc8PnzJMvy2NRFHUsxEKktWX9nNxtYdSDzo8HrlHQ7k8pM4SSUwI6J6Ud+ehVT3y +dvSImppXDfTDRwPLIbufcDOIqQeppsfTRJBVgK/WhbVA8Y18LnLUchmgwFJMKDde +27gKwlYPVrJfZSoUXcSmXhOazJGBUYmt+YnxjrvDtra1M0bGuX5A3CYI2HmJMnnz ++kmADAjFKaavq25oatbnLxjfktLnOrAAuAQTEdH+5DOfNoxuyp1rJps/wIvt9qEX +9PMdmjrX47+Iw6egRw9BGnYF6I6GOqlnZMJZ7KrEb4o6xYNRbHvbcnKw9Dex50UN +mBD2KdSBo9ZxQWTZQj7O5z8htztmHRPmdDFasQlrEpR16jAobgWHg2Yja0HkUa// +42ugWM4rEljgYiv4t9t+kVa4tjdBJTMpQLqlzeQZ9Sf4IzgsHb62NjVaaouVWjr/ +J2kTcPAR2pln71EM96annU3DcxTzkUWq3GWo5O0QBo9de1sitPsaW9qnVik0kic4 +w86RHQ== +-----END CERTIFICATE----- + +# O=Insys Video Technologies Co. Sp. z o.o. +-----BEGIN CERTIFICATE----- +MIIGRzCCBC+gAwIBAgIQXJ9B/M9B2WGARLesAlhu+DANBgkqhkiG9w0BAQsFADBO +MQswCQYDVQQGEwJQTDEhMB8GA1UECgwYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEu +MRwwGgYDVQQDDBNDZXJ0dW0gU01JTUUgUlNBIENBMB4XDTI0MTAxNzA5NTMyNVoX +DTI1MTAxNzA5NTMyNFowgboxGTAXBgNVBGETEE5UUlBMLTAwMDEwMDUzMjgxCzAJ +BgNVBAYTAlBMMRYwFAYDVQQIDA13aWVsa29wb2xza2llMRAwDgYDVQQHDAdQb3pu +YcWEMTAwLgYDVQQKDCdJbnN5cyBWaWRlbyBUZWNobm9sb2dpZXMgQ28uIFNwLiB6 +IG8uby4xFjAUBgNVBAMMDWMycGFAaW5zeXMucGwxHDAaBgkqhkiG9w0BCQEWDWMy +cGFAaW5zeXMucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDjS4ba +Wng3/QO/d0TP0JcIzTYVu9uziHR8JVXdQ2RxDE24kJjfq/OTIo7oLGJx6b4Sh7Cq +rE47l15HhNMdfkWaIVNxucSWvvW1a+Y6uFMnJsgX1MLYKszbvbsysWRFEsDUBoTm +a+vOPK2EcDMkjEligjjrjlZYMqeNg/zQB29NxGxi/bTj6U86atU7cPzNWAmA0J5d +8fWEryTeJ3XhYr1S62eFoGPZClA4TK/+nyZTsPI1lPUdYUY6ciAji/n/2Xx2rS/2 +aoojcqteZ/y55YAjeaMLbGgeLgIQE4ETNSqLNF6WvWY6uhE+qmb/ZXSUBa1aF9w6 +WEHTLY3JTcQACbsZAgMBAAGjggGyMIIBrjAMBgNVHRMBAf8EAjAAMEEGA1UdHwQ6 +MDgwNqA0oDKGMGh0dHA6Ly9jc21pbWVyc2FjYS5jcmwuY2VydHVtLnBsL2NzbWlt +ZXJzYWNhLmNybDCBgwYIKwYBBQUHAQEEdzB1MC4GCCsGAQUFBzABhiJodHRwOi8v +Y3NtaW1lcnNhY2Eub2NzcC1jZXJ0dW0uY29tMEMGCCsGAQUFBzAChjdodHRwOi8v +Y3NtaW1lcnNhY2EucmVwb3NpdG9yeS5jZXJ0dW0ucGwvY3NtaW1lcnNhY2EuY2Vy +MB8GA1UdIwQYMBaAFGb7ww++9L/gnMmrTd5HGb3AyqZoMB0GA1UdDgQWBBQiXpyl +ZPEjlLW7ALm08Bbo46gcbTBMBgNVHSAERTBDMAkGB2eBDAEFAgIwNgYLKoRoAYb2 +dwJkAwEwJzAlBggrBgEFBQcCARYZaHR0cHM6Ly93d3cuY2VydHVtLnBsL0NQUzAd +BgNVHSUEFjAUBggrBgEFBQcDBAYIKwYBBQUHAwIwDgYDVR0PAQH/BAQDAgTwMBgG +A1UdEQQRMA+BDWMycGFAaW5zeXMucGwwDQYJKoZIhvcNAQELBQADggIBACQk0v2g +HncaYcmvPrMzbFdh0F/M0CExtSc7O5VO1bBd+dDYC6Sk4MeqQdbJ1Fyg4m2t6ZMG +vQBTqnAoFnkHe67MXW2jiovRFGv/vK/a2mRsewTQNVqGflMsis1GfLDMihcqIBbS +BN3ZHOLEeHk5qVB6gnzMbI9QD4vacxk7yKKhX3kPQkX+GI5vV4c6Conh5Hzh6kNP +DaQSjtYVutIiHqJOPjwxw1hV1TlGqU3zryMeYWDDSKhfhfhcQ0HJlVtpgY+SaU9Z +gFbO3OnRq++fIveUJSYVhBb1BysZHSye21tfLR4FkgcllLgB655FUSwcbddH2ZBD +XPGluKCzKMXIwXgmQy9nY8c5/HfSpXCnA24Sa76DsQ/Ig5wvKxDEVYmvwAzMfhRo +FajS+7A6DE+qQRIsHDoFV4g6qqG8sJ8y0zczm9ZlqwxtgJFRw0Fb3Jz110jqALAF +S/COOgsJpWzUO04qk/5ZIAsfKHig9oQYwryiaAJ8ZstH8iqj69FUyvsx7kwYUNcd +ny42xKEeus6udKUTEbDHKOaxh0nbR316iDgsF/UTjQa9wVWNhllqDN/cxn8rvkOD +n6WVeEBOpHmSjLHPV7hKxFJLkxpekNWVfV+SjMiL3lm9O+KKlSQ1vzQ1xavgHFwF +BJlhS84tO91vKQXVXSPbEMdxMVNujnnddLvC +-----END CERTIFICATE----- + +# O=NIKON CORPORATION +-----BEGIN CERTIFICATE----- +MIIGszCCBGegAwIBAgIMRKXAjiIEluvMFc0KMEEGCSqGSIb3DQEBCjA0oA8wDQYJ +YIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIDBS +MQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEoMCYGA1UE +AxMfR2xvYmFsU2lnbiBHQ0MgUjYgU01JTUUgQ0EgMjAyMzAeFw0yNDExMDUwMjQ0 +MDNaFw0yNTExMDYwMjQ0MDNaMIGKMQswCQYDVQQGEwJKUDEOMAwGA1UECBMFVG9r +eW8xFTATBgNVBAcTDFNoaW5hZ2F3YS1rdTEcMBoGA1UEYRMTVkFUSlAtNTAxMDAw +MTAwODc2MzEaMBgGA1UEChMRTklLT04gQ09SUE9SQVRJT04xGjAYBgNVBAMTEU5J +S09OIENPUlBPUkFUSU9OMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA +vmAlcZykwxDoCtC3zw4FlEjD9j6kNYudlWAlH0GHfHsDj1mnfAHnuZjuGFkZjBFj +X8nMzWyb4HMdgrz9FYPeR1okay8zZgALxpfcR7Kj0RWNrxVQd8Cb261ep5rONGkP +D7gpcYq8Gb+HDplRV4wwdZJMimYkzGTG+5sPujcXN8nUofjE9HHEylEwtawOMIJY +rcnaIadBgvcrK5l0aU+Er683oO6lhtHTZDySndd/UELuu5VyoIHE6XNUUlZyyCqa +siS52U/Ko02ujC64q036gJ/xpGdmKnNx6AgZ0z3Okw7uc6mAQ74loVQYBr6U7wZg +ECfQlz/6ud5br9X3nV+gbwIDAQABo4IB5jCCAeIwDgYDVR0PAQH/BAQDAgWgMIGT +BggrBgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9i +YWxzaWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEF +BQcwAYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2Ey +MDIzMGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGg +MgoDATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9y +ZXBvc2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9j +cmwuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAmBgNVHREE +HzAdgRtnYXpvcmFpcmVraS5rYW5yaUBuaWtvbi5jb20wHQYDVR0lBBYwFAYIKwYB +BQUHAwIGCCsGAQUFBwMEMB8GA1UdIwQYMBaAFAApNp5ceroPry1QLdugI4UYsKCS +MB0GA1UdDgQWBBQ8Wc5x4b9EXHpIUbyO/cE7uQWI9jBBBgkqhkiG9w0BAQowNKAP +MA0GCWCGSAFlAwQCAQUAoRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAogMC +ASADggIBAKuZ9RfiQhGwmNuPsaeUfnXFoBPLooHFzeiY+ljHmiSC7Ar553wC6YDA +SPTHMZI/+8dHkSRzFnyOysDNA/Aujik8asYbFWsZNU/oZnHln9vFDmimBDSZsdVM +DjjhrGVVK3UX+HueHXpRlryoyiDN1XD4euWGNtfXwhRGtWItzKVMGvnMkIDs4OWv +3OuIutMB1M+pBwnin6F+dI6/HhLFpqWl4ZGPoRdfxehefnaqctSWHVXTT65BVDxp +KsOoYgPSulLzHTiOJvk1LHXL+Kr/919A0tSbdXvz9IJ2vdCPJ/0M0PVb1iTLoySN +kvmafqpYES9uwHRcK9lrAvWnnNUX8w/L25I5rEsFKYKxFC9wDWae89/a35aFyUek +NlpaNEM7J1bOBzjriaOOT+kZHif9SupcK6qkGdARxw8SsxByv4gklBgKMx6AFJsp +VKsRrPoPMs2pBph2KYIA2UxEenJAdUG4EIewZm6lhZF10yRhVgR655vnOURvIGCc +9XwQDoPkrlIif2z1WFleXOHR/pDZbfCZrteSqeAGUmaICZrSWuMUnUdjWo4qV4kW +6avZ6htGfHIHqcPBzFUx6ff9+NrC4dx72H/ie64mBYiw540nvkcIzdUdTea2Sggv +mZ8DW5lUtiOMyXHYESj+IX1FnKU9UWCHA82+Ef2GWCozSo6BPHE3 +-----END CERTIFICATE----- + +# O=NIKON CORPORATION +-----BEGIN CERTIFICATE----- +MIIGszCCBGegAwIBAgIMaHGUL73wA73TVZJbMEEGCSqGSIb3DQEBCjA0oA8wDQYJ +YIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIDBS +MQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEoMCYGA1UE +AxMfR2xvYmFsU2lnbiBHQ0MgUjYgU01JTUUgQ0EgMjAyMzAeFw0yNDExMDUwMjQ2 +MTJaFw0yNTExMDYwMjQ2MTJaMIGKMQswCQYDVQQGEwJKUDEOMAwGA1UECBMFVG9r +eW8xFTATBgNVBAcTDFNoaW5hZ2F3YS1rdTEcMBoGA1UEYRMTVkFUSlAtNTAxMDAw +MTAwODc2MzEaMBgGA1UEChMRTklLT04gQ09SUE9SQVRJT04xGjAYBgNVBAMTEU5J +S09OIENPUlBPUkFUSU9OMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA +rJIqjgZz6fNZgTXqG5x3aGjwXHrlWvQF9xEqHCNclbT5O9wZLW3SxTtomF62OFml +WNpAMK5JREAO2wz5Xb9SQyw3kSVdXv9J6O4S+hOSl4u/Kjj0QDLBwBeSUAfw8xrw +RzqdykUEod3SctI+iBGPcN4vzzFn5674SmQGyQ2uLSJmjgWfMsMAO+oKRM2EvEI+ +Xy3+q7mLxkJGdNLL8me6ukfBCnbptua81KLSUxcmPk3eR+e+xIwlkOTWCxyHX4jt +hIUmvZ9Ydjjz3FvgYaJqNc//WRJfXDeSSw9Zy1o5QHD4cdG78IFLiDHDw7+dMTOT +GKelbCbuSvjS33qcKsQoWQIDAQABo4IB5jCCAeIwDgYDVR0PAQH/BAQDAgWgMIGT +BggrBgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9i +YWxzaWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEF +BQcwAYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2Ey +MDIzMGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGg +MgoDATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9y +ZXBvc2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9j +cmwuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAmBgNVHREE +HzAdgRtnYXpvcmFpcmVraS5rYW5yaUBuaWtvbi5jb20wHQYDVR0lBBYwFAYIKwYB +BQUHAwIGCCsGAQUFBwMEMB8GA1UdIwQYMBaAFAApNp5ceroPry1QLdugI4UYsKCS +MB0GA1UdDgQWBBRyRMHgoz//Qkqdg+1P5SMH8fhs1DBBBgkqhkiG9w0BAQowNKAP +MA0GCWCGSAFlAwQCAQUAoRwwGgYJKoZIhvcNAQEIMA0GCWCGSAFlAwQCAQUAogMC +ASADggIBALuJR4BFgWdkIcQ7vc9/iPXc0oKfJdO/wK+ksvIrDXosbwoS0Vvf4h3d +5qhd77JNsNPMHluq1bJfDCf1V9gPw2Gk9hxyGrJ2JXyEdAbZAknUI/boaukWg4/C +Cc+wbL4EY/9nMlsjN23ky16uNW8VykjChzPtxkfWfREltzF8ZukD8IxlGm6p1xYA +59M8D93qqgdd/RIodtQC0mKFPa7XbFVO0zjSvyDsLTh55gnQvQtP/CWNKistu7n1 +JNTJaYSgaXp+5irA3xpnZKWmDqrs1JKGxlrDy/yfBrd9gFIINkzoXRSk//JKMGSp +Cgo9HUTiAnyuzcmn9CoQd5P38zYRJNdBuoTge9xJeBhUe4eYCmrkZ1Ku6zTgFcvY +2+K/m3Fs6eWgqx3q2S5USy3apCW+/1lpW31A+AvjH/drXsAkMYpNvRXhN7PsTJhB +UrQBF8ten9edaDdaRujf1jOZ0ng98i1Ls+HbRxWwigScdIa/Vz36C1wVIjc5Hz65 +tWxu6Z7UlPcpp1We/NwMwCEp36EcRYS++haFXvq1dpY0NQyYkLhtnzCuwL8/RFcu +Ai6pu4KwvEPaSfKWyMRSkbxGNCS4KTtR4tGAvtcvfbDy0XOBo68msD7upNubWiue +uukvOtk47924bH5zvBB/+IL06xCwyw8NgTdnBoED3KMWR+brrK00 +-----END CERTIFICATE----- + +# O=ASUSTEK COMPUTER INCORPORATION +-----BEGIN CERTIFICATE----- +MIIGbzCCBFegAwIBAgIMYebvV4btKqUtu8udMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MTAyNDA5MTgxM1oX +DTI3MTAyNTA5MTgxM1owgbUxCzAJBgNVBAYTAlRXMQ8wDQYDVQQIEwZUYWlwZWkx +DzANBgNVBAcTBlRhaXBlaTEXMBUGA1UEYRMOTlRSVFctMjM2Mzg3NzcxJzAlBgNV +BAoTHkFTVVNURUsgQ09NUFVURVIgSU5DT1JQT1JBVElPTjEdMBsGA1UEAwwUYXN1 +c2dhbGxlcnlAYXN1cy5jb20xIzAhBgkqhkiG9w0BCQEWFGFzdXNnYWxsZXJ5QGFz +dXMuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3sHY9umYbfvI +KTeMCEYCklau5lq7/dP5t4fxzSeLOo+99p8kCNvY/QIQkEfDniOm9syB5PWq9nH2 +RqcFUT7a7VGA+2yhfsTv5KROm70ivr9jV+GTQpfqjufCNnI1pW4PN9M5e/UDGsXc +pzK3MEDnTbX2JqfUV6feBWeXV6hyje3+qgsDUdAGv93L4gkovE4EL1JsqKZAEvy9 +qMCZs8f2atgMkl8w33IbKSVjWwiw2FBnTI12waU5BjYidjjqqZ/B2GU/71z9PxY1 +aRQh+zCOmkyX/pb4rNSZlwyp+75kJxPWL/+tv+7CX2YwL1tmT91wIljwP9oaChu1 +S53mZ4KbkwIDAQABo4IB3zCCAdswDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEFBQcB +AQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWduLmNv +bS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYtaHR0 +cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUGA1Ud +IAReMFwwCQYHZ4EMAQUCATALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0MDIG +CCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5 +LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xvYmFs +c2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAfBgNVHREEGDAWgRRhc3Vz +Z2FsbGVyeUBhc3VzLmNvbTAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQw +HwYDVR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFLjwbR54 +5AEBI+jZqbx1iHP1rKm0MA0GCSqGSIb3DQEBCwUAA4ICAQAiE9CMeUAzV6bCYmnd +wnWs72twmymzdmT5iwUHF6w4YPQpYADAoXv7P3Bb50zM87xpt9pNuC7/nj38mi2q +HHF1cW4t6fzGeNDDTnHAwzIB5KK7TNe8ecdoUvn9a3LpRSPi4fueiOb2HdAfVFrM +AlacQE6oNhjcnSzayM+0SlJd6ese+HFr3iKoT8EkmNchFswFljc7vbeuWpm5j47B +FVvgRLuBV6bT035jfOUQZnPNC5BRptOCeUFFwJxGJR3m0kTejHr3ZvNYFcK5aB0C +lRSJY/2SRJaqUiwloYsg4+GD22Ei7+kBkrD64wMdnZ60aKKRyeRb8EdiACKdp5LD +v0fIwzpzwePxhQ/B5RRbsc7JnTwvoniQbdS2B3O+ve6J9CviZAWh7G1StT7Ke1g/ +0SigF1mt3qE/9HJzb00P0uQEU8yJ/w5CcYqM+vnfxuK9qDUX527w9QXOQiHyUiWp +ku3E3RLwIPVnQj9+GgOMvmaATafWwKhla6cXt2HY2UjSiRXVsdl49ZC0BWEggy5d +6mTyk0ndOUhRVFwzNKc5Rgee4zGx859+MMkgf4ZzKq9PIbmZuCtbqVBfTN9diOf8 +bC0DhAG7NF4v6w3lJnnkG1s63ugpqKFiByTWniIwJV6Gq2kb+6l7A7kJMyKRpFqx +JntJyvZbn7P8eHf7fTbXa+SRLg== +-----END CERTIFICATE----- + +# O=AGENCE FRANCE PRESSE +-----BEGIN CERTIFICATE----- +MIIGczCCBFugAwIBAgIMSB3x5Ig9N/8fhhMrMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MTAxODEzNTkwNVoX +DTI1MTAxOTEzNTkwNVowgbcxCzAJBgNVBAYTAkZSMRcwFQYDVQQIDA7DjmxlLWRl +LUZyYW5jZTEOMAwGA1UEBxMFUGFyaXMxGjAYBgNVBGETEVZBVEZSLTczNzc1NjU4 +MzU0MR0wGwYDVQQKExRBR0VOQ0UgRlJBTkNFIFBSRVNTRTEdMBsGA1UEAxMUQUdF +TkNFIEZSQU5DRSBQUkVTU0UxJTAjBgkqhkiG9w0BCQEWFkRJU1ItRG9jdW1lbnRz +QGFmcC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDyMjx5Bdp0 +6Qj0RwXBjTNLmDOj0DAHop4yWphqJZuC97h7nhNzCy7L6hBRnIbRKw1YXf+PJQm8 +z3YibJgWEl9GvhY92nJLpQCWcKnLy6xcyUruZzZY10lqwmNfItHGXXYPWyIqSjNP +WQzrUTpQjxkatqVAcLp2GxoU9ID42yEP54WeZVknhFW43/ksgvzxaXmc9gB4XYXT +EQsYvVhiOLIuD0veINBax0VloilCNFSOjNZeJSf0rUr7mawUHlb0CMFNLSuYjYIv +f31mLFh8cwFiGgJJHSw5LTy17RfjPC0MdFeOHUS9l0NZJ80YeD1E0CbRHe0lW7Nb +/qD/1biAVYErAgMBAAGjggHhMIIB3TAOBgNVHQ8BAf8EBAMCBaAwgZMGCCsGAQUF +BwEBBIGGMIGDMEYGCCsGAQUFBzAChjpodHRwOi8vc2VjdXJlLmdsb2JhbHNpZ24u +Y29tL2NhY2VydC9nc2djY3I2c21pbWVjYTIwMjMuY3J0MDkGCCsGAQUFBzABhi1o +dHRwOi8vb2NzcC5nbG9iYWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMwZQYD +VR0gBF4wXDAJBgdngQwBBQIBMAsGCSsGAQQBoDIBKDBCBgorBgEEAaAyCgMBMDQw +MgYIKwYBBQUHAgEWJmh0dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRv +cnkvMAkGA1UdEwQCMAAwQQYDVR0fBDowODA2oDSgMoYwaHR0cDovL2NybC5nbG9i +YWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMuY3JsMCEGA1UdEQQaMBiBFkRJ +U1ItRG9jdW1lbnRzQGFmcC5jb20wHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUF +BwMEMB8GA1UdIwQYMBaAFAApNp5ceroPry1QLdugI4UYsKCSMB0GA1UdDgQWBBRK +DkoetIX4dy0Yqt/O/9dxMZLqDDANBgkqhkiG9w0BAQsFAAOCAgEATORHMeIrQ1UO +tuMFeyiGwgz1ci3VES9IDJmkHhDrn+szi6+5sUduJTAf8l/eW+4J+2BMl9uX3JSU +QI+0wFZTA2rsOQVfWBJ0zRI8mbAjOnSPYOChEI7/tvNgdAx167FAlh58RluCJ+7P +Rbo9juHItZnWXZvihHAt4+Xf9lt6dhvn0oPyRL9U3VlKpHtkoGXemJXxvDOgPww8 +cO51cADsBwiznApCHJA+A3pTEI1T2Ztpgw19YfvBcMX9B8bFxj/AEpbLxnMhT9wH +hNrw7Pr1SdCRcwCMNL24RJvy11DjYeJpyZ6TRdUdPbqvKKzP+alLtJDCNsXh9So0 +4i81SOxFmX5rY0LPhBXP+FoTfbFPInxIwtjVTa6vZdWaT48LZ4R6wvfj6whu62vt +210vDtr3bO0SVdIpqPxraKMcCPWlayMhB3N+ruY1coK2z+IMFASiWTcGPxkhuV7N +KgXGQBwjEcy+B9WE8eXzgjGSR1GnS+ohv1dkDpqT2KPTmG+DtdeoyzLjTOlrsbb1 +s4pIDiy2eNxPEU6y6kL2LlXHUVylJibCvQ6tATME8ZXDOP+QKVoZBG6M9aNqEv29 ++kfrMkv0HK7UIcToAPe9G/b0/m5rqZkx2zAfcDrmjg3aQJm+OwCNXEeLsOP9HHLr +YfYpZhuYlinydft4xSeURyCisAaYycE= +-----END CERTIFICATE----- + +# O=Long Tailed Leopard LLC +-----BEGIN CERTIFICATE----- +MIIFcjCCBFqgAwIBAgIQC4zOWBJ1ced8HgRGpGOnFTANBgkqhkiG9w0BAQsFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI0MDkyNjAwMDAwMFoXDTI1MDkyNjIzNTk1OVoweDELMAkGA1UE +BhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExEDAOBgNVBAcTB0FyY2FkaWExIDAe +BgNVBAoTF0xvbmcgVGFpbGVkIExlb3BhcmQgTExDMSAwHgYDVQQDExdMb25nIFRh +aWxlZCBMZW9wYXJkIExMQzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AKO6z00BcLyni6CyxbNovNQTuVAM+UU/Mw4lqIA+f51bwQRPBDHo417kRAt8GDno +MK+/Fvo1NDgSYqRkq7e594yEtVXAlrKI0wUk6yEGQA158V0dJv2MkccqKJLUrdrp +bhYnYbwwff5wX6WPZ2XPWaBWoBDYFDXJbsUNZF5KVWV+i5qNB1yoqEi23w9QrYvz +0BPuRl4UpAqKt+bC7c+AKx3EZ7TV8BCHUxatA6ntNgaykdOxOSc4eERbfpBPIo41 +HmrlnlwV/32xb8/SxAf90hwWEtniL2VgXoIFfFHQinGeIbHBTlkgKMwthzjge5JD +/ewSrlBIRQX/mcWdhmwlJ00CAwEAAaOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBSnzhuEaLnbXGwT6C4ncLi81HorgzAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBCOENDRTU4MTI3NTcx +RTc3QzFFMDQ0NkE0NjNBNzE1MA0GCSqGSIb3DQEBCwUAA4IBAQCfqeIroKhaOScm +YBnBW0MBWVtnDdVRt8c2AA+efq/9UrLHBKZMQuSVJqAmhdhCmcTtPLYp1BLbE+Ni +C3bq+OQVPtjeEX9kAaoDDByMAe3mWNRZImTAzdU3m55ffsuJ6NA7sehD+d/thYA6 +HfLNHgDdWzlpNC6w/zb2iwIx4b4k3cSzF85vGB+XPEBEJsWLLI1mMg5jT/MXtJzK +s8EU+8zTBaAZTkEwsMnUiAPxYzkY99xxD1GfnCZk5IKDDrVnYBkYWfKRlMjz4U9W +LFL1CdYDd37ZsLIj7q91Az7S1/OGKCvj9FU7jgIT76e61Ty4ot6QFQ9Cx+/+lsyW +fMRNhF09 +-----END CERTIFICATE----- + +# O=European Broadcasting Union +-----BEGIN CERTIFICATE----- +MIIFYDCCBEigAwIBAgIRALt8Os87UX/VnSUsNZoje9AwDQYJKoZIhvcNAQELBQAw +gZYxCzAJBgNVBAYTAkdCMRswGQYDVQQIExJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO +BgNVBAcTB1NhbGZvcmQxGDAWBgNVBAoTD1NlY3RpZ28gTGltaXRlZDE+MDwGA1UE +AxM1U2VjdGlnbyBSU0EgQ2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBTZWN1cmUg +RW1haWwgQ0EwHhcNMjQxMTE5MDAwMDAwWhcNMjUxMTE5MjM1OTU5WjBlMQswCQYD +VQQGEwJDSDEQMA4GA1UECAwHR2Vuw6h2ZTEkMCIGA1UEChMbRXVyb3BlYW4gQnJv +YWRjYXN0aW5nIFVuaW9uMR4wHAYDVQRhExVOVFJDSC1DSEUtMTA3Ljc0MS4wNzgw +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGWOEzNccIBbCggmilFAJk +j9Wl9Yke+Rc6X5MnbDFIneqSXL8Hrmts637r9Pzejd0quiI1Y5S8OAYXe3k/d8Ko +1v4W5jwYKxQJTQr59wEFoA3UE+Mut8UlExr1H9PjYK22vZytl5Zrg90aoWE+3YHg +A7bMOqczvVV6hP5Wkuk8vSLwqMf19PuQYf/h7qlNzvbGNaZnuBzXaIp/+lyOkadp +oCrtilG4i1VCXWPH7vAXLOkDNduG2nLpX+GZ8DKSJLhS1p/JaasUiNj/1EBszKIN +nCnR7FS9ESwJUOpxTHsDj1d2lG9nG5xGhRGD5JYsICP1hNyijw4COcnoMu2edZ37 +AgMBAAGjggHXMIIB0zAfBgNVHSMEGDAWgBQJwPL8C9qU21/+K9+omULPyeCtADAd +BgNVHQ4EFgQU3lA7jc469NzfV3sHM2ZxGNzerNwwDgYDVR0PAQH/BAQDAgWgMAwG +A1UdEwEB/wQCMAAwHQYDVR0lBBYwFAYIKwYBBQUHAwQGCCsGAQUFBwMCMFAGA1Ud +IARJMEcwOgYMKwYBBAGyMQECAQoDMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vc2Vj +dGlnby5jb20vU01JTUVDUFMwCQYHZ4EMAQUCAjBaBgNVHR8EUzBRME+gTaBLhklo +dHRwOi8vY3JsLnNlY3RpZ28uY29tL1NlY3RpZ29SU0FDbGllbnRBdXRoZW50aWNh +dGlvbmFuZFNlY3VyZUVtYWlsQ0EuY3JsMIGKBggrBgEFBQcBAQR+MHwwVQYIKwYB +BQUHMAKGSWh0dHA6Ly9jcnQuc2VjdGlnby5jb20vU2VjdGlnb1JTQUNsaWVudEF1 +dGhlbnRpY2F0aW9uYW5kU2VjdXJlRW1haWxDQS5jcnQwIwYIKwYBBQUHMAGGF2h0 +dHA6Ly9vY3NwLnNlY3RpZ28uY29tMBkGA1UdEQQSMBCBDnRhZGRpc3RAZWJ1LmNo +MA0GCSqGSIb3DQEBCwUAA4IBAQASPPqTtwpR/VCBCZT5Z4ay3tYS/0w+ErVn9y/3 +zJorBnRqp98vCojVYZnBgOMRA0UHVLgQlscL6PdwRep3ghDK5wSdUMF3C0mlL7pG +ZaBiZfZikYwDya181UauzBKvwq4EueQ/EdOFo63vSmj8jxmDabcZM/8D/eg+vVXs +F1BmxCTCUgLp+zzCW9zNDGMBtzNaov1Txug2jx465xnM+W/UyDiJX/xurdwIu4VG +KDbdA7X7dejDIJ35Tz/wdGMnzxjGsS/XkpXjpbEcUio83aN+fiK7oZZbopO6WMUu +GF7BVZ02vwjT5v7D/3tq29ZWTreGAq6+QOXdzo/glbqxRu16 +-----END CERTIFICATE----- + +# O=Cloudflare\, Inc. +-----BEGIN CERTIFICATE----- +MIIFmzCCA4OgAwIBAgIQBz6fYa3lmb4SiwLtxb0r3jANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjQxMjA2MDAwMDAwWhcNMjUxMjA1MjM1OTU5WjCBkDEZMBcGA1UEYRMQ +TlRSVVMrREUtNDcxMDg3NTELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3Ju +aWExFjAUBgNVBAcTDVNhbiBGcmFuY2lzY28xGTAXBgNVBAoTEENsb3VkZmxhcmUs +IEluYy4xHjAcBgNVBAMMFXJ1c2tpbkBjbG91ZGZsYXJlLmNvbTBZMBMGByqGSM49 +AgEGCCqGSM49AwEHA0IABBTsGzR4J3gNFXKPBwAqmmW5LWNZd7x3JhFVyFxoNWb/ +Fixi1sWqfhcINUe9fFv7pnXOGc9K44pr9N8fV0vrI1qjggHnMIIB4zAfBgNVHSME +GDAWgBT3m6JO05fF9DQPQw6Bhc6RkzKv+TAdBgNVHQ4EFgQUQ3nKYniFLFvnwQPp +UnPLWmQQx9UwIAYDVR0RBBkwF4EVcnVza2luQGNsb3VkZmxhcmUuY29tMBQGA1Ud +IAQNMAswCQYHZ4EMAQUDATAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYwFAYIKwYB +BQUHAwIGCCsGAQUFBwMEMIGpBgNVHR8EgaEwgZ4wTaBLoEmGR2h0dHA6Ly9jcmwz +LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5NlNIQTM4 +NDIwMjRDQTEuY3JsME2gS6BJhkdodHRwOi8vY3JsNC5kaWdpY2VydC5jb20vRGln +aUNlcnRBc3N1cmVkRzJTTUlNRVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNybDCBjQYI +KwYBBQUHAQEEgYAwfjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu +Y29tMFYGCCsGAQUFBzAChkpodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGln +aUNlcnRBc3N1cmVkRzJTTUlNRVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNydDANBgkq +hkiG9w0BAQsFAAOCAgEAaXXHaPDUCrtrEBt7lXhCmqMK5OMHCcccW7YX42g4jEFr +GPFGBSkrTZPeIHKNYa88zIjh7OLN3COfjzmug6yNjXSy6TaQQvGdSkHaF6KhqKjw +2+zqaQkjwdYhYOG9QEdKYD6JUeVv1TC++ODNbSygB/AJtm2sLDO3fdxmlLrZJtT1 +NEalDJckr8Cqp4hNgBn8p709paShi/DkYTcWEODlTJlQFUIn6HcqxYZWw9VWXRov +ztquLI2Gw5jraoZaCUjOTNDGtCg2CuyJO9SXIT0aZDJxnuICxiVNePcjr1vImhYx +X6IJTgWhw0LQXDYCuC6xta1I4nzQ9+PFFf146ExQn8dRAO53Lu2wGoHAsUnF8ofj +TfgyXSJeQqjwkal11LPqAuTv5PbPoLyThYcxj6oLNqk9z1GKg3NArk2oB/fH2lvM +63UQ9omJOirzHD6X6YdOYT9rcclzJuL57yxbz2WMt5j7KPRhaHCI2Ko8gJfcKYPz +poi+eh0QKkOECGrLk2fCprfj4CoU9ngz0XS4bPKYJIssU3h8ce02cYLpBaVpfGce +XsX9l75c8Lh5KGtXt8dTKoWSIZM4HYSG23cUYcJMao3J4k7Woud67Gqr2Jfbb8y9 +5gsoMVNmBhW0N0THBMQ7lD4PAQfoROnNW17S9OGuoghUjgqhzPNryZtGo5Q1c3M= +-----END CERTIFICATE----- + +# O=OpenOrigins Ltd +-----BEGIN CERTIFICATE----- +MIIGWjCCBEKgAwIBAgIMS8Dkt2gj2fts5TY4MA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MTIyMDE2MzkwNloX +DTI1MTIyMTE2MzkwNlowgaExCzAJBgNVBAYTAkdCMQ8wDQYDVQQIEwZMb25kb24x +DzANBgNVBAcTBkxvbmRvbjEYMBYGA1UEYRMPVkFUR0ItMzg5NzQxNzM0MRgwFgYD +VQQKEw9PcGVuT3JpZ2lucyBMdGQxGDAWBgNVBAMTD09wZW5PcmlnaW5zIEx0ZDEi +MCAGCSqGSIb3DQEJARYTZGV2QG9wZW5vcmlnaW5zLmNvbTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAL5ZqIMPY/p0CuByHJ191sNqRDHmo8YrMMNS229W +06Q+zmvXvi5yW2wEtrezpFjfzC7ilEMLXtRW9U7i4fVcMdzcbfjzAB6MjNkcv8yM +Z+RCV/STTGCdTpPiXNMkteJDTiIL+C5sGH43z1iRrGK5JuECOyaJt+HiYZzM7lY7 +7k6U/jkZwWFgsZJgeq5pI5DoKBFYZK4+6PXg41p0SqTL8zAthLuWtKse1q/INKko +3+bphET0RNc/Vd/Tf/32w0tfFvMNezU1toGgX1XGrVpeyJw8I6A2daWgT2KH5AVz +xgpv+8d9++vwhQJoHBMCKkSQj9XsXeNZZqCjRlyJTwVcPBkCAwEAAaOCAd4wggHa +MA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYIKwYBBQUHMAKG +Omh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dzZ2NjcjZzbWlt +ZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmdsb2JhbHNpZ24u +Y29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eBDAEFAgEwCwYJ +KwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEFBQcCARYmaHR0cHM6Ly93 +d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIwADBBBgNVHR8E +OjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dzZ2NjcjZzbWlt +ZWNhMjAyMy5jcmwwHgYDVR0RBBcwFYETZGV2QG9wZW5vcmlnaW5zLmNvbTAdBgNV +HSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+v +LVAt26AjhRiwoJIwHQYDVR0OBBYEFCxGUHK/IrgITKt2yoEeqETX0gLlMA0GCSqG +SIb3DQEBCwUAA4ICAQBfqp+xIF30LJfTFej5WzGBI4lEH3Om55pfti5bjQ5/Xrcb +5x/FrLgf+LdtzoTERcC+w+5SMwOWh/Uv45sEquSIrSpDysAsEEuOho2mzgK50rHg +n7RL3lduvjFk7OzQo451EvZqFkmQdVJ9SVmq91jMJX8jU0Sq52PRP4Nv0MOONoHK +oEsv0XYeDulbrnGiVfuKbIsL47TbuMdVg6ht9OOkjbSA+S5BVsHBmJPeSW/+o/Bi +VA//OkEUKuy7gXrBHAuxFlHGIotOiddcNVwj2UvMBIQR+buWtdm8PjUBGiH1JCbe ++AmqyNVrUJZ+A2I4M5TdKM9P4/QLH8Bu3r/xpQzCPmuG56GlUl4FQbVs0+7Qkyf2 +iUmxX03aEIFhYGjoUQH9boB1xMt0D0TI7qkfmTeZY8S9hmFXkf1vw51XIKCHV2PV +L+5losOXy0SwknVCVnhbjHdbx2MWUBFItj8wOYMFo0+xtgGrJgOoRJoSjZsREYzN +fmYUql3lGiHow8PmmDejbJfBOmH4xOMNWAPUR/am39tp6YwQUIw1npHpx8O9krXB +F0T5/qlsH8lL1ww8EMPf7arcRr4QZU55xQ21riq9/FblkxQ8zo+s8DJdBYWs+be0 +6ZWd4d4uAfjIUS/PNlkhwfCyb709PFSsKA2lH6CzWb3OsH0hqpytKbLmFRi+/A== +-----END CERTIFICATE----- + +# O=Pixelstream\, Inc. +-----BEGIN CERTIFICATE----- +MIIEfzCCA2egAwIBAgIQCNzNE5FUOYFejD3FO1sefTANBgkqhkiG9w0BAQwFADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yNDA1MDIwMDAwMDBaFw0yNTA1MDUyMzU5NTlaMIGGMRkw +FwYDVQRhExBOVFJVUytERS03MDE4NzQ3MQswCQYDVQQGEwJVUzENMAsGA1UECBME +T2hpbzEPMA0GA1UEBxMGQWx2YWRhMRowGAYDVQQKExFQaXhlbHN0cmVhbSwgSW5j +LjEgMB4GA1UEAwwXc3VwcG9ydEBwaXhlbHN0cmVhbS5jb20wdjAQBgcqhkjOPQIB +BgUrgQQAIgNiAAT8eLshB2Dkyx/dcaKQdqPHRT8vXXEk6OyJlINkfFQatdcchoe0 +o41sRipC7J/Ilb3OQcPGIuwBM5QORWv11lXjqlPX8YZ5kaofmdL0b9xPsItRcUS9 +TysCc8qIUI31dEWjggGwMIIBrDAfBgNVHSMEGDAWgBSlYiBQ3LtbV5etI4814lRs +qX75TjAdBgNVHQ4EFgQUuc8NTIC4nhvCLltkyA/JRvjcbdEwIgYDVR0RBBswGYEX +c3VwcG9ydEBwaXhlbHN0cmVhbS5jb20wFAYDVR0gBA0wCzAJBgdngQwBBQMBMA4G +A1UdDwEB/wQEAwIDiDATBgNVHSUEDDAKBggrBgEFBQcDBDCBiwYDVR0fBIGDMIGA +MD6gPKA6hjhodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVk +SURDbGllbnRDQUcyLmNybDA+oDygOoY4aHR0cDovL2NybDQuZGlnaWNlcnQuY29t +L0RpZ2lDZXJ0QXNzdXJlZElEQ2xpZW50Q0FHMi5jcmwwfQYIKwYBBQUHAQEEcTBv +MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wRwYIKwYBBQUH +MAKGO2h0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJ +RENsaWVudENBRzIuY3J0MA0GCSqGSIb3DQEBDAUAA4IBAQAqL0r5zP+ytdsh82Tu +eOevj3HVibdbyW7rPE0rtMbx6tVOdn7yAk6RdRFb/iEVIP4yeqq+s6eJw8/abP+Y +1YxBNYTb+AD2rwYOHfcc+ye+PCwnK0G5GyoH5IQ3GbiW4tkmXqXV1XOj3l72IM9G +DGZ64dCplO9zmoZIG3vQMNtBJj72tbNCqguoZGYc4OzVeaEuzPGCbBxo8dIoe5s0 +eQxZbvkizVs13xIqRygb1sxAD3hMT7Hj2jg2Syiced7dOVww2BKiWJFsdFBbYsPA +tAGYRC/GE772KzF6qX1Dvy+V9kjh5VB+FQwe+1uo6nWvMlLnLxsdKKfIPD48eni0 +TJ/W +-----END CERTIFICATE----- + +# O=WMW PARTNERS INC. +-----BEGIN CERTIFICATE----- +MIIFuTCCA6GgAwIBAgIQB1wpCy2dLvaLjxpJTP2OWjANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMTIyMDAwMDAwWhcNMjYwMTIxMjM1OTU5WjCBuTEZMBcGA1UEYRMQ +TlRSVVMrREUtNzE1NTIyNzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERlbGF3YXJl +MQ4wDAYDVQQHEwVEb3ZlcjEaMBgGA1UEChMRV01XIFBBUlRORVJTIElOQy4xEjAQ +BgNVBAQTCU1jR2Fycml0eTEYMBYGA1UEKhMPVGlmZmFueSBXYWxsaW5nMSIwIAYD +VQQDExlUaWZmYW55IFdhbGxpbmcgTWNHYXJyaXR5MFkwEwYHKoZIzj0CAQYIKoZI +zj0DAQcDQgAEEkXpuQKaW8kMHeSHuEXjuRQMuH0Php6WR8lXmZVRB2XphM7QGqHs +l+k2pudEukmtLsKeLlZQkDU06D43z7KqPKOCAdwwggHYMB8GA1UdIwQYMBaAFPeb +ok7Tl8X0NA9DDoGFzpGTMq/5MB0GA1UdDgQWBBR85prq1o2fyGQufjhRucujF5y3 +3TAfBgNVHREEGDAWgRR0aWZmYW55QG1ldGFweXhsLmNvbTAUBgNVHSAEDTALMAkG +B2eBDAEFAwEwDgYDVR0PAQH/BAQDAgOIMBMGA1UdJQQMMAoGCCsGAQUFBwMEMIGp +BgNVHR8EgaEwgZ4wTaBLoEmGR2h0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdp +Q2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5NlNIQTM4NDIwMjRDQTEuY3JsME2gS6BJ +hkdodHRwOi8vY3JsNC5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkRzJTTUlN +RVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNybDCBjQYIKwYBBQUHAQEEgYAwfjAkBggr +BgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMFYGCCsGAQUFBzAChkpo +dHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkRzJTTUlN +RVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNydDANBgkqhkiG9w0BAQsFAAOCAgEA0LE2 +P5BgHEKynurz2ChdWIve3SdysW8iO9wSONf8lPc+tWmuhMxdO1R0SJ4umahgTFv6 +c5aHWOeLHz1QKcOGrRfEPAMOpY27jkr5QJFkHSolEK7KxO5XsR83VLbp+giFr8jz +9FikIJqBhgjfLmZFHmTTvY4WUkMwr7J4RuKce5vGVUAt7qo9uJTo7ZpZoquieYq6 +kBpGzE9lGwltBD9mBjcBO8Mcf9hOsFjzY5thLtOT+AbRYOCf/4nDhF3A1vrNzRtV +e+EYzdbdhyLflg2K9N5ep1GVOMI3e4VOtudpNmYNkQs7HcBMPttwH3I2N7sJXqdA +wlhbLZN2LgU6lVzDJMZ/nhxs2bfSkrPr0A1OI5tlqgxrd3l0khW84wOc0bF06oNh ++Pao5D5B/5oTH+aQR0v3xd37+zptPrUbQ0goX3CKB4dG+gFzhl584Mi1oNzwy59K +o62+r00wjWNJEOmS72fxKQDraEcutijPSBHY2H8LdfFiUEJrf9+qGHmDu+HzolC/ +R0F1YzQEbgrgMRATX2MxSxBzX6kZ9q9xscTcn3DNrBJA7v37h4qg0Ld95YxolQJy +erOvuL2DKSyFftnF0+zmLddUZ62sr0QBwuCKaeq0c9tFVuRuBllpbI9/n4qgXIpr +f2VWJfEnUy+bkFn5mW4nK9dQnNImrbb6hH7V4dc= +-----END CERTIFICATE----- + +# O=TrustMyContent +-----BEGIN CERTIFICATE----- +MIIGljCCBH6gAwIBAgIMDnqCc0hGr4RtCWWfMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MDkwMjEzNTkzMVoX +DTI1MDkwMzEzNTkzMVowgc0xCzAJBgNVBAYTAkZSMRcwFQYDVQQIDA7DjmxlLWRl +LUZyYW5jZTEOMAwGA1UEBxMFUGFyaXMxGjAYBgNVBGETEVZBVEZSLTU1OTI5Njgx +NjQxMRcwFQYDVQQKEw5UcnVzdE15Q29udGVudDEsMCoGA1UEAwwjbWF0aGlldS5r +ZXJ2ZW5lY0B0cnVzdG15Y29udGVudC5jb20xMjAwBgkqhkiG9w0BCQEWI21hdGhp +ZXUua2VydmVuZWNAdHJ1c3RteWNvbnRlbnQuY29tMIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEA0VYr6+XXJPh/YfMpyO74XD970ZbGYMmk9itx9RypU67B +RAjJ1vi7GsE/rL5dD55POerGn1W2w7iSthz7a31ihNuhozcybTVsRSLEQLZRihBx +skMCeRiaKCF0gO4t3U8MWsdMbWFJmieajRzfsKRjxcrdIYzm9GYdt939qVFzsaF5 +sdIcIKnIl2ELP35ykXCr75/0KkQqFSikEA4m4F55AzYgFZGj/Qfoi3/le+asLqbo +REGyKnfshj7VPaZDpzj8ZWBguS7Js2qFbRbrxT00RXvRMHh184IXFCBSmmHXbZho +Pew2ByiAyfLsY3BE/jtu9wNimF6q+Eo8JDEaazrXHwIDAQABo4IB7jCCAeowDgYD +VR0PAQH/BAQDAgWgMIGTBggrBgEFBQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0 +cDovL3NlY3VyZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2Ey +MDIzLmNydDA5BggrBgEFBQcwAYYtaHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20v +Z3NnY2NyNnNtaW1lY2EyMDIzMGUGA1UdIAReMFwwCQYHZ4EMAQUCATALBgkrBgEE +AaAyASgwQgYKKwYBBAGgMgoDATA0MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5n +bG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgw +NqA0oDKGMGh0dHA6Ly9jcmwuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2Ey +MDIzLmNybDAuBgNVHREEJzAlgSNtYXRoaWV1LmtlcnZlbmVjQHRydXN0bXljb250 +ZW50LmNvbTAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwHwYDVR0jBBgw +FoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYDVR0OBBYEFI2tq5xKjwCvY2Ph4iKw +QCqgvEOHMA0GCSqGSIb3DQEBCwUAA4ICAQCrQtny16nzlQcYTgx361AdcEi2RFri +mEgJ5qpP+fWIKeCeG5VuBqgQo3vkp7qv3K5VUWFPt/TStdDxHPP3RytMtssAkntC +0IWwRj9du1coElL+MAubofEOFuNC/GkiTGf+IruyWxSsCxwDs6d+3f5obyRcK68w +V1JdAqRXhiVTHO8xOOUVg2lG19Nit3QZFHIhMKQb4rReDxSzeZW82rLVtTDl1S0b +COoNKxNAUUrrAQMUcZ00zdVqunyD55QihZ8KUs0h/xZCpJM0Ia41g+pzrJzc0R/8 +PVyYezzZr1JYbXC3ppXEchdKNeSlIu+M0u6pVx+UNEwOJ8z9X0I0EWCL8GZ86nWQ +ceije3Y6c92Duw/xbi2syY875wpebvjefFNH/KhRXOc2d0XeX9ob2vpwWFXVyHq+ +0Lzu7uYXVTk10htjgfCKyRyvpzVpwJK+grov55hrsNReFS7oc1I4Z7MRSrHJhI5u +x5dI2AUkCB1xZSWhyOtBclxrZu6UA0QbEmBFT0w1wPqCy6X4nth5Rv1KyEDvMXG1 +5FFE3W/uLYKJ0CBkvIKXG+OUB6o2xEr21NMvLDbOhHMYlKKW7hsmV7kG5VeV5y+p +/j9L64l3OeAgXKFwlXOXbQ/GKvAAwxuCYE+EjLJZ+iCXCy6my1m+dpKOQGBN4i5i +XBr0Eg6TXRTvrA== +-----END CERTIFICATE----- + +# O=Wacom Co.\, Ltd. +-----BEGIN CERTIFICATE----- +MIIFfDCCBGSgAwIBAgIQAwEa4btLhYVmLGBrw/VwGDANBgkqhkiG9w0BAQ0FADBq +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSkwJwYDVQQDEyBEaWdpQ2VydCBBc3N1cmVkIElEIENs +aWVudCBDQSBHMjAeFw0yMzA0MDUwMDAwMDBaFw0yNjA0MDUyMzU5NTlaMIGaMQsw +CQYDVQQGEwJKUDEQMA4GA1UECBMHU2FpdGFtYTERMA8GA1UEBxMIS2F6by1zaGkx +GDAWBgNVBAoTD1dhY29tIENvLiwgTHRkLjEiMCAGA1UEAwwZY3JpLWVuZ2luZWVy +aW5nQHdhY29tLmNvbTEoMCYGCSqGSIb3DQEJARYZY3JpLWVuZ2luZWVyaW5nQHdh +Y29tLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALfXX5eDHhlw +r62HSMU0tHAgUrolOBxDNIY0h+zPk/W+i4AOm5aDm8m8AsOCmy9nGo+RF6vR3pYm +oSz+V2xW6weI7vSvIbC6eFKTvp44AzcIDileoif2OJ+LnZUZh9BJyjUzIMah1tuA +mFidJJ12tIQG+ZkBO0mtBxum/mYWh6QfMdrBr6sJ/lX9+wKcz5nGpl4l2kePPE2I +m4Y4GiWCyTpMI/8BvBB0L3iYQh9gcqgxBhH7/4BWuAPqbB1Pya1nXirsUyNmbvhn +bsbCFY5jOuP8cmFQuSPPYbIhKURj6nDkqPQdkTF+Y9LwQUkFiWk9p+aVY90ZPLHn +MDphc78GCGsCAwEAAaOCAeswggHnMB8GA1UdIwQYMBaAFKViIFDcu1tXl60jjzXi +VGypfvlOMB0GA1UdDgQWBBTjrhE0HbBUNhIxP9q77U/HGiPPzTAkBgNVHREEHTAb +gRljcmktZW5naW5lZXJpbmdAd2Fjb20uY29tMA4GA1UdDwEB/wQEAwIFoDAdBgNV +HSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwQwYDVR0gBDwwOjA4BgpghkgBhv1s +BAECMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LmRpZ2ljZXJ0LmNvbS9DUFMw +gYsGA1UdHwSBgzCBgDA+oDygOoY4aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0Rp +Z2lDZXJ0QXNzdXJlZElEQ2xpZW50Q0FHMi5jcmwwPqA8oDqGOGh0dHA6Ly9jcmw0 +LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRENsaWVudENBRzIuY3JsMH0G +CCsGAQUFBwEBBHEwbzAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu +Y29tMEcGCCsGAQUFBzAChjtodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGln +aUNlcnRBc3N1cmVkSURDbGllbnRDQUcyLmNydDANBgkqhkiG9w0BAQ0FAAOCAQEA +U/9VRTCd18YgjQbxXILRPBQNYdXgZCDDwS6eUTDPnw0gKVR3yrQ86bPOaIX9veJD +ohUVFmncU21Gjw3zzSusstIoc4a8Xhgu/nplXQTVKZSJftJzx1qyLdZFoB32MgeV +ABOnsoU7S6kAdfME0hN8UfBqRw3J7R4VXH9pWnqJWjih8r2KtLTiX2I6D3vZj5lW +KgCO/DBSXUfyR0nDC1TY56Xoo69XvbRrsXD40StV+mNSUwOd22QuqxL3uVYhQRjX +8ogzMj8Kbc2ZgZkHSVVDAvLZ0eH0zid2x2Qlt/5js11G914zlhsmH702uIf8Bu1I +P60JfmN+qG0o8kGKofkC6A== +-----END CERTIFICATE----- + +# O=Pixelstream\, Inc. +-----BEGIN CERTIFICATE----- +MIIFpjCCA46gAwIBAgIQC0p7MU/nXlxXdgfio5WxJTANBgkqhkiG9w0BAQwFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMjEwMDAwMDAwWhcNMjYwNTA2MjM1OTU5WjCBhjEZMBcGA1UEYRMQ +TlRSVVMrREUtNzAxODc0NzELMAkGA1UEBhMCVVMxDTALBgNVBAgTBE9oaW8xDzAN +BgNVBAcTBkFsdmFkYTEaMBgGA1UEChMRUGl4ZWxzdHJlYW0sIEluYy4xIDAeBgNV +BAMMF3N1cHBvcnRAcGl4ZWxzdHJlYW0uY29tMHYwEAYHKoZIzj0CAQYFK4EEACID +YgAE/Hi7IQdg5Msf3XGikHajx0U/L11xJOjsiZSDZHxUGrXXHIaHtKONbEYqQuyf +yJW9zkHDxiLsATOUDkVr9dZV46pT1/GGeZGqH5nS9G/cT7CLUXFEvU8rAnPKiFCN +9XRFo4IB3zCCAdswHwYDVR0jBBgwFoAU95uiTtOXxfQ0D0MOgYXOkZMyr/kwHQYD +VR0OBBYEFLnPDUyAuJ4bwi5bZMgPyUb43G3RMCIGA1UdEQQbMBmBF3N1cHBvcnRA +cGl4ZWxzdHJlYW0uY29tMBQGA1UdIAQNMAswCQYHZ4EMAQUDATAOBgNVHQ8BAf8E +BAMCA4gwEwYDVR0lBAwwCgYIKwYBBQUHAwQwgakGA1UdHwSBoTCBnjBNoEugSYZH +aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVS +U0E0MDk2U0hBMzg0MjAyNENBMS5jcmwwTaBLoEmGR2h0dHA6Ly9jcmw0LmRpZ2lj +ZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5NlNIQTM4NDIwMjRD +QTEuY3JsMIGNBggrBgEFBQcBAQSBgDB+MCQGCCsGAQUFBzABhhhodHRwOi8vb2Nz +cC5kaWdpY2VydC5jb20wVgYIKwYBBQUHMAKGSmh0dHA6Ly9jYWNlcnRzLmRpZ2lj +ZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5NlNIQTM4NDIwMjRD +QTEuY3J0MA0GCSqGSIb3DQEBDAUAA4ICAQBAWElBB5PNdHqbY/zvno39x5zaKUZK +FJ+YhCTU7ii+bnpRdB7PZ+yy8PinoUloU5UCCibUnq2q5PyCpBxdvAX/rSOrDH7X +CyTWwpGsf7Qz+2jMd1tf84DTQj7nzGgAXBNOVeXB/anAlLe/5fdbcSBpjIX3PBK1 +Bo/yx2CLzbHpOoQHGnkJwHs1btJey3DfXnTlyfR4RwHgO4vBntfO2IFZJwuz7Cp2 +Mj3iZfRBw370Eejb7T1pAKA7yPzebu7/dQZHocCDsa3j6CU03R+MCOtLCCyhEFK5 +L6fRYlkJnv3SFIgmpE4JjItJooAC5nIIhp5ROZKJg8bbnJjrs6k13BWyWu83QAJu +lrZXvWgoPkWOdfChRZKM/2ZL94xrFK5ujpEODcKIUNSPX5+jcCwwpPRnhalbHJYX +nAhHwPnG6amEz24Pan2ieU9xYyXtdniJmiFaY9+AreJq5Xc9PDG1KSXo0UPixLLC +yw7VJPsRtWrSkUlCkIBGt+FoS9BOs0uLUADXu/WWPmgT9Oo6AIYNxeDKNZvJfanT +De0iFuT4zd3SMqgkad51W6HRh29ajJIs748rYMawucamXvadYQeSoITXr51hIVQk +qnbz3HrPjVqOmKKSHSgNLd+MR5TcXcmwK07Qrc/O2sfR/um7t4QgM5upEsu119fp +hMGHflwor1mv0Q== +-----END CERTIFICATE----- + +# O=Agency for Science\, Technology and Research +-----BEGIN CERTIFICATE----- +MIIF0TCCA7mgAwIBAgIQUUpa2wSWsEDVMQKRgSa51jANBgkqhkiG9w0BAQwFADBO +MQswCQYDVQQGEwJVUzEQMA4GA1UEChMHRW50cnVzdDEtMCsGA1UEAxMkRW50cnVz +dCBFbnRlcnByaXNlIEVtYWlsIENBIC0gU01JTUUyMB4XDTI1MDEwOTA0MzcxN1oX +DTI2MDEwOTA0MzcxNVowgaIxCzAJBgNVBAYTAlNHMRIwEAYDVQQHEwlTaW5nYXBv +cmUxNDAyBgNVBAoTK0FnZW5jeSBmb3IgU2NpZW5jZSwgVGVjaG5vbG9neSBhbmQg +UmVzZWFyY2gxDjAMBgNVBGETBUdPVlNHMR8wHQYJKoZIhvcNAQkBFhBjb25uZWN0 +QGNhdG9zLnNnMRgwFgYDVQQDEw9DQVRPUyBTSU5HQVBPUkUwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQDWyQYwd70c8U7DlY1atvBdlvZTgyOCaelWj9uX +mRG20yhzWE0dyAOY35dWIx/f5lf5+7OgKikczxzmbk7RinCCz3XxVjOp1D9MoqEf +s7EWW3vnTxJ0SwvnCDjbZvwFQdGPzcOGlJ2h/tH1DsLgdILSBf6Up7NEN8blfHJW +yDwxe3miVs8E2BqMyrfE3nS14sPpz0jEhDwakHMvQxH8i7MOKWiO4kKrZHmnvUx/ +yc1aSSre+a1OD7A2liMlQN6oupDxBJzB+9TCB7jmmRMeq80bAPvMizv8LIBhLcdD +GHgD93lFYgotwla8PAweu2uoUiXyJ8FddqtIjD1M1nTzY5OXAgMBAAGjggFUMIIB +UDAMBgNVHRMBAf8EAjAAMB0GA1UdDgQWBBTzl16QboVDz0w31StzgU3YDOzv2TAf +BgNVHSMEGDAWgBTgiBXxxYqRnb+V6OZ2rXHNB4D4fzAOBgNVHQ8BAf8EBAMCBeAw +HQYDVR0lBBYwFAYIKwYBBQUHAwQGCCsGAQUFBwMCMBsGA1UdEQQUMBKBEGNvbm5l +Y3RAY2F0b3Muc2cwaAYIKwYBBQUHAQEEXDBaMCMGCCsGAQUFBzABhhdodHRwOi8v +b2NzcC5lbnRydXN0Lm5ldDAzBggrBgEFBQcwAoYnaHR0cDovL2FpYS5lbnRydXN0 +Lm5ldC9zbWltZTItY2hhaW4ucDdjMDQGA1UdHwQtMCswKaAnoCWGI2h0dHA6Ly9j +cmwuZW50cnVzdC5uZXQvc21pbWUyY2EuY3JsMBQGA1UdIAQNMAswCQYHZ4EMAQUD +ATANBgkqhkiG9w0BAQwFAAOCAgEAgHXXWQzgDGKezMoUCtZZT+8gjNRxsKPv7UPr +knb2JAjS0Vm/KIuVhx7PjYYiA3ZOfdh64SenAXDD3xSbRR1m61kmnzSqGeYh57dT +TJfTAJLRs01zyQH+aU+L127/pbGzgF3pZgPJpor/FOc8DwqEC4hcDYlT+5ttC2Od +JvO4U1g6fFz20//i4BgcHpIgjW+pQydYy3+jn9BzoC3IK1vQ5qnrSwgunLdXT1AG +2KrijSAykaeHMYnd7NulpLKtrE8YkVokaQzu0+rINsFIslKCjpihi8L6achHw+YY +8uiKE7+OCEG3zfydeGti48Xa6vWMxeeS8YUp+bF/K1YqhJxm1xN4wJEbVjjuJOam +PinDiaHNjHp/f/xRv8m2rVDTy//XVLBIfB0p04Yi/wN9K9c1RsEekNw7gZngwDuJ +n5Ap20z64X4ZEqEt5zW06ks9+dQvlfVjOtxK/M3gClnIteKPiV+zE4ZgHyIscNjN +mX41VMWT/0P16ZiA8WrrPTakbs3EFg1VgkSHr6F3AR6E6Do9o3kRLCbQxJIN/y5P +4UVV5dyp0ao91zgOqcJnKfl5VQ2infD3ffDhrkrJFmbz8CMS9rB9ib9/KdPEojDc +XYXcC6J3I4e1w1gTp4fQAANCuGPdqMusY0QErjEWrNlR6z/goKLI4PqdSEJ7/n0c +MehfkNo= +-----END CERTIFICATE----- + +# O=Typeface Inc +-----BEGIN CERTIFICATE----- +MIIGSjCCBDKgAwIBAgIQAjD7nSLEoOAaRyycpK4SeTANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMjA3MDAwMDAwWhcNMjYwMjI2MjM1OTU5WjCBgzEZMBcGA1UEYRMQ +TlRSVVMrREUtNjc5MTY0NDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3Ju +aWExEjAQBgNVBAcTCVBhbG8gQWx0bzEVMBMGA1UEChMMVHlwZWZhY2UgSW5jMRkw +FwYDVQQDDBBpbmZvQHR5cGVmYWNlLmFpMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEA0i+5eyZu7eBTs0jb5TjcdVXyrs6liakQHPVXkyH2CzIJgB9PauWx +WHxVVw8cEa5kKoHjXIcdvv2dfXL/Dduh2WFpzRMsfUOie/rXK8oJifn+BL3X8qrx +pE0bCXLDh3EWT1f53nisg7LwUlZaxFPimXLqzirNK+OzNIDM3EisSanwXPWXLExZ +lCQAEU42WEOfAwpOEs94Gw+pJfG5OUGXRg34rXJHTqqUV9FjX0ymFW4nIyTiTW7Q +PpR8TTTgxGvJKQj9+gbrNmx5FblGbk/bFxwbng1XSfWfFLuQVGTwkoWrT3S3aqeo +iv7lRE1hxgD+Sc0co6ztmpEWfrx0znEGEQIDAQABo4IB2DCCAdQwHwYDVR0jBBgw +FoAU95uiTtOXxfQ0D0MOgYXOkZMyr/kwHQYDVR0OBBYEFCpZ1flDcO1ehkQqQ4fq +1R83LD2EMBsGA1UdEQQUMBKBEGluZm9AdHlwZWZhY2UuYWkwFAYDVR0gBA0wCzAJ +BgdngQwBBQMBMA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDBDCB +qQYDVR0fBIGhMIGeME2gS6BJhkdodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGln +aUNlcnRBc3N1cmVkRzJTTUlNRVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNybDBNoEug +SYZHaHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01J +TUVSU0E0MDk2U0hBMzg0MjAyNENBMS5jcmwwgY0GCCsGAQUFBwEBBIGAMH4wJAYI +KwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBWBggrBgEFBQcwAoZK +aHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01J +TUVSU0E0MDk2U0hBMzg0MjAyNENBMS5jcnQwDQYJKoZIhvcNAQELBQADggIBAE6D +i3m8huMkiH2dNzJ1Lra6ra9N7i72ijLQQ4cthxRnzUbw6iIqs0ZHmo8x1Wg7qazO +GtRpl+0is9G5Z+Nd54iEXO9Bd6zM3KfpTZqb5NN57A6CLB9i1tByrQfk00nOWpMV +KWFdTUUobVyTzWSBc4OT1H4f12AfA8GImvw5VvzG35yiNlWhwYMLo2YtbljmertX +UYM7Q2KO1T5gwKPEhbvu6H9TTaTZvZRKfPGTBCCsbHy47Irqd4WC8jpbQqS1jDjO +YhkoVcZ81Ke/zssWcq0zCgUcXOPKv6dc4L6A8zZkA+/PFQT4QkPa0USBQnj1SCIM +S5c11GjC0f+NZZ9zShAD6W4cnecaioKZJCihERMT6Y81L4eNXIpef3kZzw8MsWYz +ErhZ8D7NoGAZdsxKtpyR1nVlP1QREjl3VmP4FtcF3mSgroRZ6Gw0aQ+0PKfOkH36 +4vdwKd6WRbHzItAPloY16M6SOr3vgKFcvS9b7hmt7Rfg0fOWlFRliLDrmpqjUy5q +1e9k4/es34Ilw44200gudXUXa/6PYeGciozpjU7dE0Sr7Z3W+s77pr8QHQiBP51o +PYAlzSwNQdgcoKMcpvwnG67NEBCkJj0XirHE5m0FjKVXkUOQxHkojnK2Zhsa7wKJ +x17eff3OS1q7P/Lye8R2994b0o8cMiwPdN9L/4DT +-----END CERTIFICATE----- + +# O=Metapyxl (WMW Partners Inc) +-----BEGIN CERTIFICATE----- +MIIFwTCCA6mgAwIBAgIQBM+8qoOonsRn6+7rjCzUuzANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMjIxMDAwMDAwWhcNMjYwMjIwMjM1OTU5WjCBwTEZMBcGA1UEYRMQ +TlRSVVMrREUtNzE1NTIyNzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERlbGF3YXJl +MQ4wDAYDVQQHEwVET1ZFUjEkMCIGA1UEChMbTWV0YXB5eGwgKFdNVyBQYXJ0bmVy +cyBJbmMpMRkwFwYDVQQEExBXYWxsaW5nIE1jR2FyaXR5MRAwDgYDVQQqEwdUaWZm +YW55MSEwHwYDVQQDExhUaWZmYW55IFdhbGxpbmcgTWNHYXJpdHkwWTATBgcqhkjO +PQIBBggqhkjOPQMBBwNCAASODOJ61s3n66H6ddCHdsWukEgmCg+nYZcLy+uvjZzx +QUJ0a8hrvcT7poolNrRluqPjc6lS8j5LCjnlP5S6fFiyo4IB3DCCAdgwHwYDVR0j +BBgwFoAU95uiTtOXxfQ0D0MOgYXOkZMyr/kwHQYDVR0OBBYEFOonV/vpikR/3uAt +dBZEucJWilHKMB8GA1UdEQQYMBaBFHRpZmZhbnlAbWV0YXB5eGwuY29tMBQGA1Ud +IAQNMAswCQYHZ4EMAQUDATAOBgNVHQ8BAf8EBAMCA4gwEwYDVR0lBAwwCgYIKwYB +BQUHAwQwgakGA1UdHwSBoTCBnjBNoEugSYZHaHR0cDovL2NybDMuZGlnaWNlcnQu +Y29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAyNENBMS5j +cmwwTaBLoEmGR2h0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3Vy +ZWRHMlNNSU1FUlNBNDA5NlNIQTM4NDIwMjRDQTEuY3JsMIGNBggrBgEFBQcBAQSB +gDB+MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wVgYIKwYB +BQUHMAKGSmh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3Vy +ZWRHMlNNSU1FUlNBNDA5NlNIQTM4NDIwMjRDQTEuY3J0MA0GCSqGSIb3DQEBCwUA +A4ICAQAlJIjs2SVgraIeqCtcXQln72VhgC7TFPrDQPfGy3YsH30o1Zf/NprbL2tf +BayriVgJVv1ZaGIVaQbbtxqlF6Myn2fb9Gx0Oh5sxj/YZLUpBiCHZ+9G9iUVeD0R +sMJAVCEfNxUupXtO2rLHIhKy5YRuNaw7X+/3aPGE/LAEf0OeBf3He3KxLGzneI6a +WTQ1vWs0mXjV5AtmGNo62izWhZVDuJIywizBefR6RVe7cZ559dADES1Rm5W1rbpM +jt3jf/FVQtPhDTdQzelXjvlycRPVgczBw+buNvBS716jNn+NjeBU/rMtcCW4NcU1 ++0nd2jesUd9/UaI97gYbruLEe35naLgIyGteboJmM3JJgDAF7bWgraAbiNeiTI1g +CFL6Mt/oYaeuQENz7RggekgjrgXUo0h1pfLHFMGoIZUiLMkEpeo5ZcahE2Ze7k9K +UZDkG30hNF33/RE65DWFCBAMl0zOHHJ2xME0m3ptsjS0s6RApcsoNmH9zrUJiXBv +pTaT6XTrnKhLoe5o595V0LGaIWgS+ugPAyVPuOfBOriD5mefj+YbAsRJiIUjjR3/ +biC70/qsEZUsOB2Jmz9wrD8S+KSHy8Tnr56cp6M7gLbocBOsUrhvDzqMWwv2T6L2 +qXBlJtx1o+XK+tCuPDh9zdxkArunsJ5Dl9bbz1UqdlauJ+zynw== +-----END CERTIFICATE----- + +# O=Numbers Co.\, Ltd. +-----BEGIN CERTIFICATE----- +MIIFqDCCA5CgAwIBAgIQBs9SdeeO5VtXvDLQagxBfjANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMjI3MDAwMDAwWhcNMjYwMjI3MjM1OTU5WjCBijEXMBUGA1UEYRMO +TlRSVFctODI4ODU5OTAxCzAJBgNVBAYTAlRXMRQwEgYDVQQIEwtUYWlwZWkgQ2l0 +eTEaMBgGA1UEChMRTnVtYmVycyBDby4sIEx0ZC4xDTALBgNVBAQTBENoZW4xDTAL +BgNVBCoTBEJvZnUxEjAQBgNVBAMTCUJvZnUgQ2hlbjB2MBAGByqGSM49AgEGBSuB +BAAiA2IABMJO/BqEmQxOQwNAh+2GlqbtFCKZ3baG5ZihMG/gJX1xCHiG/35o0x2j +rENnkD7d3knRX2QOkn5IF9LOy/Kisej9CIF4bkkstkUL5acW1IfvOf3gwxveYXN7 +gVjsvPXWZaOCAd0wggHZMB8GA1UdIwQYMBaAFPebok7Tl8X0NA9DDoGFzpGTMq/5 +MB0GA1UdDgQWBBST5VAh1DhhDMAV4xe/GVL2lv5/2DAgBgNVHREEGTAXgRVoaUBu +dW1iZXJzcHJvdG9jb2wuaW8wFAYDVR0gBA0wCzAJBgdngQwBBQMDMA4GA1UdDwEB +/wQEAwIDiDATBgNVHSUEDDAKBggrBgEFBQcDBDCBqQYDVR0fBIGhMIGeME2gS6BJ +hkdodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkRzJTTUlN +RVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNybDBNoEugSYZHaHR0cDovL2NybDQuZGln +aWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAy +NENBMS5jcmwwgY0GCCsGAQUFBwEBBIGAMH4wJAYIKwYBBQUHMAGGGGh0dHA6Ly9v +Y3NwLmRpZ2ljZXJ0LmNvbTBWBggrBgEFBQcwAoZKaHR0cDovL2NhY2VydHMuZGln +aWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAy +NENBMS5jcnQwDQYJKoZIhvcNAQELBQADggIBAGhTAL59P9tSkcsgX7iEyIKgiQxC +hOrA4v0BRy+8SP1VJVOnnyFtRKwroIXAXeMbxqJOolyMEEUdoBa4RPVr5yt/V856 +wUvvw9/e4Hkr4b18rmFUQIkZm9co8SSoPuIShtXRqFE/+ms6s7hHEAzf3lZ/0qE7 +sX+iVx0FNke2PDZgBh0VJnXOPyr8jQC/hAFMcoaNHarHijRsyK0x6PxnHZ5YoaSu +L7tgSbm9sTY+4Ycdh46fDWf0xU1X4wx6XRwkTgOvSzPEMGdlKiLU4bxYtLbugH49 +reYj+3NAXe0JsQ5QETphhzHSQXnRS4FPPE3RjMgSClf9Bjyqkfpr7A4UKNIOB5JG +zf0axuRwbnpiFUNr2nLLQdr3LTXNfC8vHhQDd95nfbP/17fMRtzgjkpGrTp95HAH +HxbCDliiirDc64kluf2Nvh6RWnyZ1sV1u04HBRaBRVxdbTmslGOFlM3nHhuIy2ua +nbAls5EBw9sGGXu4zpxKztfN2ZMrwv4XRVK70FIdZkDDJ58pUQU0yVyVOHxKVyvN +4uR9U9cmAFk3wvw3EH4SXZtAorYVCii9o3Qr+Uywrdh5D2aFobO2CA23cs5rUufb ++dORaEd5XRR2nTuJs3t7gcRz42kCAR6eFo31BmNXoqkiaBIIKjVc036Wox2+nQQm +ZerXHKIRZ+Bp6vUQ +-----END CERTIFICATE----- + +# O=Amazon Web Services\, Inc. +-----BEGIN CERTIFICATE----- +MIIE4jCCA8qgAwIBAgIQCySJ9pK62dbC/FLziulA0jANBgkqhkiG9w0BAQwFADBm +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSUwIwYDVQQDExxEaWdpQ2VydCBEb2N1bWVudCBTaWdu +aW5nIENBMB4XDTI1MDIxODAwMDAwMFoXDTI2MDIxODIzNTk1OVowgZUxCzAJBgNV +BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdTZWF0dGxlMSIw +IAYDVQQKExlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRcwFQYDVQQLEw5BbWF6 +b24gQmVkcm9jazEiMCAGA1UEAxMZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjB2 +MBAGByqGSM49AgEGBSuBBAAiA2IABG46yjUaDGBnhPHrI7fE+QOlWiuj/y2KUhFC +K5L+uH8cwKFaU4xa40BBH0VspBhNDRFVcA0jY84kBp/i/egrz3MtDQA2eLi8qZiV +1Soq7gtwzJx4RekNffu/Rnq78HzoCKOCAggwggIEMB8GA1UdIwQYMBaAFO/ONZPO +9obF+IT1DOdab9kvS+NkMB0GA1UdDgQWBBRx1Uj75HmDkeO+lzFqKceuXxvGPzAW +BgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCBsAwHQYDVR0lBBYw +FAYIKwYBBQUHAwIGCCsGAQUFBwMEMIGNBgNVHR8EgYUwgYIwP6A9oDuGOWh0dHA6 +Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydERvY3VtZW50U2lnbmluZ0NBLWcx +LmNybDA/oD2gO4Y5aHR0cDovL2NybDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0RG9j +dW1lbnRTaWduaW5nQ0EtZzEuY3JsMHsGCCsGAQUFBwEBBG8wbTAkBggrBgEFBQcw +AYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEUGCCsGAQUFBzAChjlodHRwOi8v +Y2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnREb2N1bWVudFNpZ25pbmdDQS5j +cnQwEwYKKoZIhvcvAQEJAgQFMAMCAQEwWQYKKoZIhvcvAQEJAQRLMEkCAQGGRGh0 +dHA6Ly9hZG9iZS50aW1lc3RhbXAuZGlnaWNlcnQuY29tLzBCMjQ4OUY2OTJCQUQ5 +RDZDMkZDNTJGMzhBRTk0MEQyMA0GCSqGSIb3DQEBDAUAA4IBAQBN2V+TGam5tDZf +EoO9l8OdmsftXLg+4uHrv22GQiKPWQti85MgxYXoT2VQ5PQ9BhW91XtwOn5dAKNu +qR30KSrzGURFkhTYNPK7Eb9bFYr2LqsmiYPSprGf8jEeLknypj6bhTyEDG1fcR8p +GqdlVHxfCsIDWB+3ESLGGY5gqs5MDor4t65xeug0DBrw1GDDT/HWhOepl2NtVhE7 +aein/KmH94+M6TOw/+XN+uAJf0bBGKvXUQiLsQ2akSXkzkkG6AT+oGto680vTiPt +Q2a/QVmM38WoT4g7pZyuFxpkUPi8j8dcSoe1hWJa7d283U6Cp6sAg5E/5nMZ/S7a +FjzXvwoV +-----END CERTIFICATE----- + +# O=Comite International des Telecommunications de Presse +-----BEGIN CERTIFICATE----- +MIIHqTCCBZGgAwIBAgIMIjT3029Guo5iFu/ZMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI0MTAzMTEwMzUzMloX +DTI1MTEwMTEwMzUzMlowgfQxCzAJBgNVBAYTAkdCMQ8wDQYDVQQIEwZMb25kb24x +DzANBgNVBAcTBkxvbmRvbjEjMCEGA1UEYRMaTEVJWEctMjEzODAwNU9YUFlVS1FL +UEZNMTAxPjA8BgNVBAoTNUNvbWl0ZSBJbnRlcm5hdGlvbmFsIGRlcyBUZWxlY29t +bXVuaWNhdGlvbnMgZGUgUHJlc3NlMT4wPAYDVQQDEzVDb21pdGUgSW50ZXJuYXRp +b25hbCBkZXMgVGVsZWNvbW11bmljYXRpb25zIGRlIFByZXNzZTEeMBwGCSqGSIb3 +DQEJARYPb2ZmaWNlQGlwdGMub3JnMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAvj1HKdsXZEi2IAKlUkTi2IwVb+y/oRx4ZA4K/80f7+2G5lGNwKEDHO9Y +XbnTeBg66VlVyWykdY5kcI/BApk2JFGdKcDDlneNdQXmzFp44dvQGSntQMQqy6eu +fsCYTjAAB6KJY+Fp1p+f5hdtSH8B0wTuG9Tf3ujAGNUaUqGq5cliUnXZ7abqHZA9 +46tuKX3P6Zp/4pIo3/yd+iFbcdiGEQbDN3x+hAjQD9bh16nU/No9GfwEGNHLrDMC +wEEkIqccjdRygaiLxA2ODbJVjhMeQwcKGD4onT6xC9EVsUOuXPILaLOywDL2LSGn +hzV9ufjyVwYF5A9bTacF2ghhrCITuOEqLY5+izZu23+KRx6V9GIL9vdwaohnvFQ+ +DjHZWC10Qw/Pv+ybHzks92C9k9MqP5+MkpsxRFmVeiQRaWgkhVrM+GTUScvegnvu +TdnWQaMiXX/x4PDaMOlIPdzidCI6iEmMvSEX4gqECaRa51VRY6xq2vJr7oEQea/Q +4gFRqb1IixRj1sRyeDv2bc54Qo0Wb5F2zVtbD5Ima1teZPyGmc0GpkHzQLN2GHtY +9CZue6sLZ/ZMPM3IwEWMPz5azv1o50X6VinjLMkW7EAtleeOwW3VVu1q5mgqAyr2 +RAE1M6xe6XWgVpsolMNf3InzvRKS2LInDC8eJjPAeOXknPibA/ECAwEAAaOCAdow +ggHWMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEEgYYwgYMwRgYIKwYBBQUH +MAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20vY2FjZXJ0L2dzZ2NjcjZz +bWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6Ly9vY3NwLmdsb2JhbHNp +Z24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAEXjBcMAkGB2eBDAEFAgEw +CwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggrBgEFBQcCARYmaHR0cHM6 +Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYDVR0TBAIwADBBBgNV +HR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dzZ2NjcjZz +bWltZWNhMjAyMy5jcmwwGgYDVR0RBBMwEYEPb2ZmaWNlQGlwdGMub3JnMB0GA1Ud +JQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDBDAfBgNVHSMEGDAWgBQAKTaeXHq6D68t +UC3boCOFGLCgkjAdBgNVHQ4EFgQUS7cjrGgKRl/D291UQIwaOkkiAQYwDQYJKoZI +hvcNAQELBQADggIBAFSimzqwuGLBRbGVfW4nedzrwbIBhflh/hZCpe3nMZP7nR1D +X+3viBXCrbMDQfND3eQIQ2uiB3E0W2d+ngxmZi6u5iA1qnUgg3u6yB63oUuo+W0e +dAMvwHE16cQIzDQ8xclY2N6YrqhghKfYX8HFFvM7I2yrqieXRjwfNZ5oxUNMpIqO +C3uIpO4ZM7/szDHBJDnzkyKntHZ53kgRSSphnvTk97IS/xvRN4Sv5Vj2vyFXKeey +MfMkTOYTqBebJsUEYgMP1YnHPSNmRsgrSIF5xQ2EQTeQbCmXinnpNs5gxWjSdJUq +Pzo+ZJwMcIeMlsZ0q52qbj6PwwuZkGmkUNTfVwQxilz+S/aZsL9hgNgB9uLyIzxm +bDPRn015Gtdj/f3HlSQE/R3/ZhqNpvRBTRlzMu2n1vdQcbvxxaKDzOa06SzPV9br +bKyACvuxYtV40gwoJOtqF8ss+qQSy3crMGz+jk3gM3TNXvo8Lg2GEbN299pcLfO2 +pIEj9Ww3T5QRF4ReXK58jkbjX8FCFZxcrUU2dR5vzyXJUWMrHow1OHIq0dEQvrZF +QmZ0GFvYd+4NsEjaSu74cSHNDYMsdb0kvavrwtGm3nASCNZVjB8hPdoxZF28uxJ9 +yOaQSZXo0ryxgO8EW4DdvsAgfFxrsSTHrcll3uR88Elx98gBTzeUOT4cr3lR +-----END CERTIFICATE----- + +# O=Mondelez International\, Inc. +-----BEGIN CERTIFICATE----- +MIIF0zCCBDugAwIBAgIRAIHABJyIwnHnoiFKyN8wEsMwDQYJKoZIhvcNAQEMBQAw +WDELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1NlY3RpZ28gTGltaXRlZDEvMC0GA1UE +AxMmU2VjdGlnbyBQdWJsaWMgRW1haWwgUHJvdGVjdGlvbiBDQSBSMzYwHhcNMjUw +MzI2MDAwMDAwWhcNMjcwMzI2MjM1OTU5WjCBrTELMAkGA1UEBhMCVVMxETAPBgNV +BAgTCElsbGlub2lzMSUwIwYDVQQKExxNb25kZWxleiBJbnRlcm5hdGlvbmFsLCBJ +bmMuMRowGAYDVQRhExFOVFJVUytWQS0wNTUwMTc5NjEhMB8GCSqGSIb3DQEJARYS +aW5mb0BhaWRhLW1kbHouY29tMSUwIwYDVQQDExxNb25kZWxleiBJbnRlcm5hdGlv +bmFsLCBJbmMuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAipL5mPne +ZpAZOT+v6TskKIMyqPg5Hi1NOtpDFxttjQlT4ATQwvsioDsUxo56Pqn2RG7GsGg6 +ro6tI8cl5t7DfvtKMZ8x9zxRx7Ygp5Fb+6btB5XU70nUCSQBmV7VUeZfymXmUg4K +w03xi74OZ5hE++HwghSJ9f3N0VVcXSu84YO4RLk0pAGvigML0qbiH3FXKyxgrW93 +lrTfkrwq7ddlRtdFW+x2v5PTuQ7NGIzYP35wbOhEtyuUh4RjY2vRk8ityyL12VWD +NZYLneUSOZAH4ou0dbrCQbYCagbXPw7cfb8WiChCZoUC5F74TyizWPm+42vOV9ew +JhJcM7oVhV8y5QIDAQABo4IBwDCCAbwwHwYDVR0jBBgwFoAUHwSkfkz2MrEJ4pF8 +4WzfUr/PLv0wHQYDVR0OBBYEFK5C6/7cvXr3rmGokftKw510/1y9MA4GA1UdDwEB +/wQEAwIFoDAMBgNVHRMBAf8EAjAAMB0GA1UdJQQWMBQGCCsGAQUFBwMEBggrBgEF +BQcDAjBQBgNVHSAESTBHMDoGDCsGAQQBsjEBAgEKAzAqMCgGCCsGAQUFBwIBFhxo +dHRwczovL3NlY3RpZ28uY29tL1NNSU1FQ1BTMAkGB2eBDAEFAgIwTQYDVR0fBEYw +RDBCoECgPoY8aHR0cDovL2NybC5zZWN0aWdvLmNvbS9TZWN0aWdvUHVibGljRW1h +aWxQcm90ZWN0aW9uQ0FSMzYuY3JsMH0GCCsGAQUFBwEBBHEwbzBIBggrBgEFBQcw +AoY8aHR0cDovL2NydC5zZWN0aWdvLmNvbS9TZWN0aWdvUHVibGljRW1haWxQcm90 +ZWN0aW9uQ0FSMzYuY3J0MCMGCCsGAQUFBzABhhdodHRwOi8vb2NzcC5zZWN0aWdv +LmNvbTAdBgNVHREEFjAUgRJpbmZvQGFpZGEtbWRsei5jb20wDQYJKoZIhvcNAQEM +BQADggGBAHo1YUSeOfkP6H417w3G3tyjhiL1XUwXkIkw4SMIk92L26X7fHQG4PcO +bE3n4Z/tRnN0bQc+InHITdUBkdvEqSfaWpNG3X/kNKZwNr57nC6/HAgTxD23Rsfl +kytJcb2tKJpCDS7iczCVI+lHr8PDljEqVE1VCrCu1pwyJEQRDrGu9XirBgDDtkkU +pyOB3qsKmMevHg9W5sksNm7dui/Zlk4LqWJmnWH1mYi6yPcDNQiwHi5C1EPGIGaI +RYxeebBX19pUWogGFNvAgzKyDFubCBPZkfRtU4I8U4UcZnruDyNG+Z+/pNyj7E+V +vX8uC43RkeJJKvSAilV0PGVtAKOODxWw/pjeihGrcGlVWO651A28lWmh2+7u0Edt +oig0mLncscI+WFcbU6u2EDoHm0cA/SEdc07+t8lPjTlXcrWox4s0LBFQJfjJc30D +it9MFD5hzVuLS0SWAV3L2s4M8aEINtNLt5yo+a5PKq7zMdDLSue+E5ueq6KEV6W2 +CQctrJc+mQ== +-----END CERTIFICATE----- + +# O=Vidyard +-----BEGIN CERTIFICATE----- +MIIGOjCCBCKgAwIBAgIQBFJDOx8l7DYb9mV7LChDOTANBgkqhkiG9w0BAQsFADBx +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xSTBHBgNVBAMT +QERpZ2lDZXJ0IEFzc3VyZWQgSUQgRzIgTXVsdGkgRG9jIFNpZ25pbmcgUlNBNDA5 +NiBTSEEzODQgMjAyMyBDQTEwHhcNMjUwMzI1MDAwMDAwWhcNMjYwMzI0MjM1OTU5 +WjBDMQswCQYDVQQGEwJDQTEQMA4GA1UECBMHT250YXJpbzEQMA4GA1UEChMHVmlk +eWFyZDEQMA4GA1UEAxMHVmlkeWFyZDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC +AQoCggEBAMMkxOJsO36e8xyOQRGXVo8AGQv7BJxlARETbtH2It8GkjSsg7PMkG9m +4iIxaHDNZF2/yJX9imiQZ6+Rar1ATsOkhef8y3IdHurLnEo7ZFU+W5IK55HldzNM +tGs+4gGsTZ7wyBHrHPY52SKRPY51P5g6/2W/YXUsxC3IhutlbLiu0vPCpw41PIpi +mOMWgPzd2Ihl05VwbZuY2EETapiy98/139rzRx3OXHs9hQUMh1vZws5BUmfWOXn3 +rX12BShZLE0Z2l20fN/u1eR917WJkYB4RVjdyzlx3nGXK1TioizDJi5Ql6W1xxtm +mpUBQylORvdN5zTUhXuAKXWwmMvLeaUCAwEAAaOCAfowggH2MB8GA1UdIwQYMBaA +FE5Yu5AefbT766BMBMTWI1DvzN1BMB0GA1UdDgQWBBRBt5BN6Ye5lzV63UsWlPVZ +uXjHzjAWBgNVHSAEDzANMAsGCWCGSAGG/WwDFTAOBgNVHQ8BAf8EBAMCB4AwKwYD +VR0lBCQwIgYJKoZIhvcvAQEFBggrBgEFBQcDJAYLKwYBBAGCNwMKAwwwgcEGA1Ud +HwSBuTCBtjBZoFegVYZTaHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0 +QXNzdXJlZElERzJNdWx0aURvY1NpZ25pbmdSU0E0MDk2U0hBMzg0MjAyM0NBMS5j +cmwwWaBXoFWGU2h0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3Vy +ZWRJREcyTXVsdGlEb2NTaWduaW5nUlNBNDA5NlNIQTM4NDIwMjNDQTEuY3JsMIGa +BggrBgEFBQcBAQSBjTCBijAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNl +cnQuY29tMGIGCCsGAQUFBzAChlZodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20v +RGlnaUNlcnRBc3N1cmVkSURHMk11bHRpRG9jU2lnbmluZ1JTQTQwOTZTSEEzODQy +MDIzQ0ExLmNydDANBgkqhkiG9w0BAQsFAAOCAgEAE629TN1azzzAew/x93StA5b0 +dZZVhB30HxuWQkqHYfd9cxjh7vwnb04Iu4Q3vQewrfhVeYJsWXpwncAhQYtprnNS +3YLnW2u28ZcJ/kYB6k74Eho+4lP/MvqmPRUlFW6dE6nWqIbFIsBop++9DIMyBWbA +vedlJwBGgoosYVs49ACWRQgWfJ38Mqsh5JCFB35gCZnmxIBaaR4IYO7fS+kvI10V +b20HLX7r6el8E3lnlDUkjkE2W6CeKawtNWAw12Ka5XvvxBX2Z8wPKJ7ekpTxcEBJ +ds7uTQuZFf7FwDRjGAPDNjupeb3g2Aoy7POk4Vd4sRa9//kIhpVjnxJ30ufOHWlW +oh0QHAMhJ0kPL1A1HTGdNwtNcjiRQSwbzT+4L6gGkSUyUl5K1jR5DMVfPXqqEZY1 +PocmV8x6qyeNxeK5A73BG1t8kthWbaPz2j9MOI1gYUHZ/Gle4bAFim5PjDVz7gCR +3p68OuD3ARIlBlMJqyG3oC4ep/sXovlj5gTBUUg3S9sWvXXYpwOus2VT/1oDbn7K +teAhfPZJCWT85isFRsGqkYdxFy1CgCmaQyA7SOm9Tuhbik2cALWeUSffKdyKf86D +C7ZHod69ii+3Xrlsioia48F6P9ytZz5gG5MUQc0l79pPXgTifU6vejY/RH+iFHT6 +cVNvclvclNsmRWlu2A4= +-----END CERTIFICATE----- + +# O=EZDRM\, INC. +-----BEGIN CERTIFICATE----- +MIIGazCCBFOgAwIBAgIQBXde8IrFtW+xE5RHXXpT8TANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwMzMxMDAwMDAwWhcNMjgwMzI5MjM1OTU5WjCBpzEZMBcGA1UEYRMQ +TlRSVVMrTlktNDEwNjQwOTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCE5ldyBZb3Jr +MRIwEAYDVQQHEwlSeWUgQnJvb2sxFDASBgNVBAoTC0VaRFJNLCBJTkMuMRQwEgYD +VQQEEwtFaXNlbmJhY2hlcjEOMAwGA1UEKhMFRGF2aWQxGjAYBgNVBAMTEURhdmlk +IEVpc2VuYmFjaGVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxz78 +JwL0OIdlnk5BEwmkGggEJll1pre7/TBxPLZt8d4YPrWch/izQR2bCSAT3vXqJFPa +CY02cVTeW6U9QzHve42298MQF1d68HAKqZ7n+z9sPe+CIahEoA6q6YMJbtkteNuM +5PlHVGUT0ppAW0Tod1xRclHrwdnmd4ketUtsp1Nsm8y+m7P81bw3OTbyPnI9KbB+ +w/e2gX9B+oHWcNcqvC72WbihEypRGzqxhp4fwjekeWaqTPRo21W511rP8VhVihNV +ZNnRo5RloIu582s/upt3BdxZTuyDq+7jmxbABvk/2zy1AeuqzJKphUSVlsfDcPR1 +kmcfbaBxt+l9lzT5eQIDAQABo4IB1TCCAdEwHwYDVR0jBBgwFoAU95uiTtOXxfQ0 +D0MOgYXOkZMyr/kwHQYDVR0OBBYEFM5VacO+aAHTN7EGzffYBCcHKeRKMBgGA1Ud +EQQRMA+BDWRldkBlemRybS5jb20wFAYDVR0gBA0wCzAJBgdngQwBBQMBMA4GA1Ud +DwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDBDCBqQYDVR0fBIGhMIGeME2g +S6BJhkdodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkRzJT +TUlNRVJTQTQwOTZTSEEzODQyMDI0Q0ExLmNybDBNoEugSYZHaHR0cDovL2NybDQu +ZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0 +MjAyNENBMS5jcmwwgY0GCCsGAQUFBwEBBIGAMH4wJAYIKwYBBQUHMAGGGGh0dHA6 +Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBWBggrBgEFBQcwAoZKaHR0cDovL2NhY2VydHMu +ZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0 +MjAyNENBMS5jcnQwDQYJKoZIhvcNAQELBQADggIBAMMIa8wEyuj93DfpqPi40+hs +HufzcxOc4PkbuO4shDbV1HAeVmWOnhf2YLi9gcsWmpo1QhS8yEQOMSJYFQaQxXY2 +YgRmUnY47WsiNzoHditVcrhG17E4tr1b8rdrDEYJvHJnZg8u++Ma30cqP3kkzPco +et0RsTlxXk6o6J34RSTncqhflYQlYhu0/1i+dEmlhZUMS+2FEQYW94eDEkKFae7T +HLo/tFJSoPpQn4VfsOZptCbPubxjOgXY08FyU7RJH9qNMUnhcE1x2X1wlybOnigd +y2eoWYHioF9eSyEUvJeBX9g5p1Leq1KU9HN21rblqUmIbsqrhJ1f+Zkg7lqHhxC8 +yM9XEvdlRvQ8RyoVBKtqTaD8x2xWqlSiIHuNXE+dQayt4sX6wQ/pQ6JghZZI0qn0 +9p/VOEOr2otzJn1o2SC5pI4/9Gg6z0jNYqQQ3kj0qGzCCkJUG+8MIbqG6yEebG7h +NKtSiEu+WsUMUIpiBJHX2GrbVxvV4jKAkCGWV5YPBL4ex5kCkw+YG1wmifU+s+2Q +C8Hx0flyYHdxfTbySyRHVfwJbF3eRVMadRam9i/Lf7jbMY9sJViX0a0nHpPDAZVF +Vql27UIahNN5OjDVpRnSJeoDKt9VJjw7n3uKytbvwFVORnV03iiS3HxPfxzHc3NH +UCWFbuKx/DT/Em4UIJk1 +-----END CERTIFICATE----- + +# O=DigiCAP Co.\,Ltd. +-----BEGIN CERTIFICATE----- +MIIGcjCCBFqgAwIBAgIQBCrLUeyRkzwTX/kLMNEWLjANBgkqhkiG9w0BAQsFADBi +MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xOjA4BgNVBAMT +MURpZ2lDZXJ0IEFzc3VyZWQgRzIgU01JTUUgUlNBNDA5NiBTSEEzODQgMjAyNCBD +QTEwHhcNMjUwNDIyMDAwMDAwWhcNMjYwNDIxMjM1OTU5WjCBoDEdMBsGA1UEYRMU +TlRSS1ItMTEwMTExLTE5MjgyOTUxCzAJBgNVBAYTAktSMQ4wDAYDVQQIEwVTZW91 +bDETMBEGA1UEBxMKR2FuZ3Nlby1ndTEZMBcGA1UEChMQRGlnaUNBUCBDby4sTHRk +LjEMMAoGA1UEBAwD7IugMQ8wDQYDVQQqDAbsoJXqt7wxEzARBgNVBAMMCuygleq3 +vCDsi6AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC8q0izZS+u8Uvx +M2o4ZmOvnLyfjkR4LNzO9l+dHmgKgCECbUE9ZZQfq1GolVfbsbzlRLnTh4fEsIWU +S7r09zz7wJDCTETt2FzfV/zH5ItsXGCrPXIU1rDphQ9tBq2pPww5XcJIf2Qr7OmS +pXala/uvumOpO7dRIyJhjB/nirGH+s77H16mk5N+Qk8k8iF+hYFATcLGNqdqLwPf +lWVruZAA5plMA3U1ST+SEujSc14RWH32+LASaadn8juTb994v0oUAkvpb4QxmXB0 +NNX+zITQ3sWWQ3KDByeQGPzqPeyV3tCXMaVZQrp8J20w3pbiTx4dUxErxH/q7kON +f2YoBQX5AgMBAAGjggHjMIIB3zAfBgNVHSMEGDAWgBT3m6JO05fF9DQPQw6Bhc6R +kzKv+TAdBgNVHQ4EFgQUlCZ2tZNYlF+YbrRAsgXdzbCRhjMwHAYDVR0RBBUwE4ER +aW5mb0BkaWdpY2Fwcy5jb20wFAYDVR0gBA0wCzAJBgdngQwBBQMBMA4GA1UdDwEB +/wQEAwIE8DAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwgakGA1UdHwSB +oTCBnjBNoEugSYZHaHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNz +dXJlZEcyU01JTUVSU0E0MDk2U0hBMzg0MjAyNENBMS5jcmwwTaBLoEmGR2h0dHA6 +Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5 +NlNIQTM4NDIwMjRDQTEuY3JsMIGNBggrBgEFBQcBAQSBgDB+MCQGCCsGAQUFBzAB +hhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wVgYIKwYBBQUHMAKGSmh0dHA6Ly9j +YWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRHMlNNSU1FUlNBNDA5 +NlNIQTM4NDIwMjRDQTEuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQDUjCEvfdK3PUCL +vRUkfLzHe5cJZgpUiCM34IbrSpuch9fd4/6ifLs9HqC66ha/does8R8esbcaxaSh +u90B+0S9SpvEswqNrlePy9pPPc6gC2mKZetQUahVLdIFtPMKwl5JSbkcSNX1FC8V +ae8oX1vX0g9ZwdxsfBMURImPxBopn/QU1HJLajuaxyZ/yWmU5nAOrZzTgkDqOLdJ +na9kWmk7V13OPOPlaoqYiPXj5rHqiv6lQQP/pfRel8qZ3SaycyaIzMyLdTR0FWgd +H4rsyDvP8hM8aFBV4ZwtPCbPkB4jLOaZFK0UHZfj61ktBvXBTA14On01ThTiQNjG +AzDLPsbAwjHoWFzOgdDHmdl3E8V98IbqWl2kHXK2fJ6Lior/+n4UIgDtuYHSPDjY +wLRk8RJUjtj/s3k0Bs6Rnfs1bSIrXiiBQZmrER1K2Y4SVgNb5xAbHDEAA3bCVFdt +nxkhCGMbVLf6YIEQL5kKQ+Ct8MgZDAXkvUQo29m1nUkrL5Yh5+0iwc9DNO+6VrF+ +S5i4iHqsicd98oLzKRLH52RS6YjNsyYpFnN6nPnbIKUi0PR+RhuLsJNnz22DPvHc +nCYeMbixEiQDmcHu03tjw626We5sfh9dwNMk065E/EdmzKvazyo4ibT8qGSubEKN +XsH5rrmvKwcBZj1t/MZqGFMoK/z3fQ== +-----END CERTIFICATE----- + +# O=France Televisions +-----BEGIN CERTIFICATE----- +MIIGdzCCBF+gAwIBAgIMYK85s+iq0wE5uP8GMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI1MDQxNjEzMjUyOFoX +DTI2MDQxNzEzMjUyOFowgbcxCzAJBgNVBAYTAkZSMRcwFQYDVQQIDA7DjmxlLWRl +LUZyYW5jZTEOMAwGA1UEBxMFUGFyaXMxGjAYBgNVBGETEVZBVEZSLTg1NDMyNzY2 +OTQ3MRswGQYDVQQKExJGcmFuY2UgVGVsZXZpc2lvbnMxGzAZBgNVBAMTEkZyYW5j +ZSBUZWxldmlzaW9uczEpMCcGCSqGSIb3DQEJARYaSVNQLVJFREFDVElPTlNAZnJh +bmNldHYuZnIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCuoQSZTt6K +a4OV7AJa6dw8z5KnP8LU2/S1rXDjXQf1/Uxie2J/lUuReC+xivLbzaTpYWazbpvx +xLWLX5WdEF89FSO7lFlVrn0/bPpMcF38thxl8PTk9K9kJjSFg/f/sVsqg3cPlt9Z +wYhlsjfDgf9a3f2AplV5G8rMXFutw7zYbSEC26YtMSlUqaWVsCcj+kwrWX7Gv8Dg +jYi0cy12i/V9XyzZ0XrfaLPdDEhwQ7wlYOtOdx2Gr8hWioIc1Xs7A2vVckov9R5V +AQhLyZ114D0IBGc9uzvgjSfyTM/eLrN+8QIQ7RzzaaE7fgMzqSQWzoTNY0XndWkt +HW9TQRdhl/x5AgMBAAGjggHlMIIB4TAOBgNVHQ8BAf8EBAMCBaAwgZMGCCsGAQUF +BwEBBIGGMIGDMEYGCCsGAQUFBzAChjpodHRwOi8vc2VjdXJlLmdsb2JhbHNpZ24u +Y29tL2NhY2VydC9nc2djY3I2c21pbWVjYTIwMjMuY3J0MDkGCCsGAQUFBzABhi1o +dHRwOi8vb2NzcC5nbG9iYWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMwZQYD +VR0gBF4wXDAJBgdngQwBBQICMAsGCSsGAQQBoDIBKDBCBgorBgEEAaAyCgMBMDQw +MgYIKwYBBQUHAgEWJmh0dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRv +cnkvMAkGA1UdEwQCMAAwQQYDVR0fBDowODA2oDSgMoYwaHR0cDovL2NybC5nbG9i +YWxzaWduLmNvbS9nc2djY3I2c21pbWVjYTIwMjMuY3JsMCUGA1UdEQQeMByBGklT +UC1SRURBQ1RJT05TQGZyYW5jZXR2LmZyMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggr +BgEFBQcDBDAfBgNVHSMEGDAWgBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNVHQ4E +FgQUPgwE86oDI1lKyRHSjpJCG0Rob+UwDQYJKoZIhvcNAQELBQADggIBAG/7qkXl +Va+yMmm/hJbconjEI9sInyM6MGkaw6eAH3VBKZoSBXix4/HkxYk4V5sKBsGk2wxU +7QiRrlGMM6Lo1Te+N3i3JMp9uViXLm/u5ypKE8Ks3OvCic0ACIkTGeyxt4WTacbD +lMzzdXnW/fDwjOdAma7P/dHunUTVuLkOEPAgHPA1KQrXinPTVcJJjAhCt4WcdOPk +tSoGRVb52Zhl12UXsZuzlGo1cgpPWcDjOeiF3FHPQKk7Yu/dCOQXRP5u4yiGK5ow +dz/ZdMzEJPFF7/lSYp4Mv3LKU/ypg9hIwCkVGf3wkinOM1CmjPVcbH4DYlSguQA4 +yKiK98Gn70Wucc0jNSxDiX8sRgOWRmJ37n0Ju5TnBvliccj0cdmZzGSmRHsFiS0E +iRisDm89Yv2cJ+tB6oi8uRAjBCy/8KlY1ZFOd32x3BUlCsakJmqcDtxabaUOv7/f +Mc2w3oN1drjY7ph5zwtDBC9+5BTAK+ys1Wu1SBNVgsZXj7dr+LybqVbdD3JfJGVX +nT6w+J9y2wJ1C8W61BVjBmHsD/M+8WlfAsU9V45dZR30PzC82ZlRMgFDiXe0Mikk +/dcE3wATPsfuMk6iQqlUt4h8YrCLQorpzMN3bP0GCTxbhDVaIFYagULmUPKDYlmz +y63Z39Oco/9v2uCu5nRqp5MQv3z5uNWa0+G4 +-----END CERTIFICATE----- + +# O=Fastly\, Inc. +-----BEGIN CERTIFICATE----- +MIICzDCCAnKgAwIBAgIUZvL7KopAAUd3z60QruoAhawBxIYwCgYIKoZIzj0EAwIw +cDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDVNh +biBGcmFuY2lzY28xFTATBgNVBAoMDEZhc3RseSwgSW5jLjEdMBsGCSqGSIb3DQEJ +ARYOcGh1QGZhc3RseS5jb20wHhcNMjUwNTA5MTY1MjI1WhcNMzUwNTA3MTY1MjI1 +WjBwMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN +U2FuIEZyYW5jaXNjbzEVMBMGA1UECgwMRmFzdGx5LCBJbmMuMR0wGwYJKoZIhvcN +AQkBFg5waHVAZmFzdGx5LmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABB5V +byODizsgVK620BFY7q7cibTDBWy/vHXEzX7IVE3wqtxynou85otZ6OTXk5hWp7k2 +nOUAaLQew8d6mTsNSBajgekwgeYwCQYDVR0TBAIwADAdBgNVHQ4EFgQU/EbBoqHe +9Xzjyr221lAN3Q1wTdkwgZcGA1UdIwSBjzCBjKF0pHIwcDELMAkGA1UEBhMCVVMx +EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDVNhbiBGcmFuY2lzY28xFTAT +BgNVBAoMDEZhc3RseSwgSW5jLjEdMBsGCSqGSIb3DQEJARYOcGh1QGZhc3RseS5j +b22CFGby+yqKQAFHd8+tEK7qAIWsAcSGMAsGA1UdDwQEAwIHgDATBgNVHSUEDDAK +BggrBgEFBQcDBDAKBggqhkjOPQQDAgNIADBFAiEAy2tpPTqt/wACBqEgd9epfsre +bJlAtzOsgLTQISsI+F8CIHjJh4AXV+WuLrJTy0kCQJoNGavML8SsREh8OSpcXqF9 +-----END CERTIFICATE----- + +# O=CLOUDINARY LTD +-----BEGIN CERTIFICATE----- +MIIGezCCBGOgAwIBAgIMTFXe89Ll9D9X8ncjMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI1MDUxNDIwMTMwNFoX +DTI2MDcwODE0MTIxNlowgbgxCzAJBgNVBAYTAklMMRkwFwYDVQQIExBDZW50cmFs +IERpc3RyaWN0MRQwEgYDVQQHEwtQZXRhaCBUaWt2YTEYMBYGA1UEYRMPTlRSSUwt +NTE0ODIxOTMzMRcwFQYDVQQKEw5DTE9VRElOQVJZIExURDEXMBUGA1UEAxMOQ0xP +VURJTkFSWSBMVEQxLDAqBgkqhkiG9w0BCQEWHW9wcytnbG9iYWxzaWduQGNsb3Vk +aW5hcnkuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA040YqTtx +fJ4tZ6w4OSfu1JmfyZxSsP3HiPkUEW9xeD8dt0B6ydgNMfAUQHdrNvnaSlAs9KXK +QoMGojbFwdtyeXNBi/C4BJiW+5Q/F7C1yXbg7u47TGKz56ASO5u4er1NZ5Rr1Rim +a1HwFFFoXDWyJlAXSZlR3JWUCL38Ovk9oXFwluA2mS+AJwVmxP6sTkKEt1CHkUli +zrrRNlDYAkjpKMGsEWBWxm8q2rHUBI12GmCZ+gnAeSs1lOlQMa1K+RC7dndECkJm +2tLkYHO0Nx+oDErr/zfobzeFtSkcobe04pWxScG9kRj5u4W9bM02UkL1iFQxcbJy +EjD0zgxuKsb8MwIDAQABo4IB6DCCAeQwDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEF +BQcBAQSBhjCBgzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWdu +LmNvbS9jYWNlcnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYt +aHR0cDovL29jc3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUG +A1UdIAReMFwwCQYHZ4EMAQUCAjALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0 +MDIGCCsGAQUFBwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0 +b3J5LzAJBgNVHRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xv +YmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAoBgNVHREEITAfgR1v +cHMrZ2xvYmFsc2lnbkBjbG91ZGluYXJ5LmNvbTAdBgNVHSUEFjAUBggrBgEFBQcD +AgYIKwYBBQUHAwQwHwYDVR0jBBgwFoAUACk2nlx6ug+vLVAt26AjhRiwoJIwHQYD +VR0OBBYEFGEdMMGvQF5zoyTuLoUwc7xUH7w0MA0GCSqGSIb3DQEBCwUAA4ICAQCi +S4L2GpECDVatw6RCw4vtXwH+cOJc8VyiJm7j23W5jRyIzcOfcaVPkMIxNfcgD5MO +5g0iQqUbB8ULxaS/AMavOku2IsA/XQNgodsTLXYdrNw8xrv1ZZoar9Exvs/ffzQH +nixQ3a241fvugZ3y9+/JAvKc68EiNqFzvVa28z1PgRHRO/xI0gBK4kCDk6yEVph0 +9fB32uvQ8lyWqmGeo+IGhKDaFRox/IXxdG9N3Fi2vmL0F074M4Ff5IeKr5we6xNU +BsS6g1Afs5XknYYWzyOA2jcVgVyw1SXJ8naL8UH9Dih73vgermMZcKaYDjo563f3 +6OOFM3NekFy92seI7va2b8uKEu403tczhai370fn5vNLfhXwNY2oVVRtPJAhV22G +uFrCHQjsP788R6bz7IGzjU71CrKzUIHneoo6YTYafNySLBZowkumN/WtK73qf2Bz +pDrdkOHOnQxwnF86qxeUUbBvh2Nr83ebfvMwvxgb6fW/beiV7W7pMp7rVOH3i2Y5 +aCVvd6Y3D1FAYpULTbjVsnBQZOOJDo0RF5dxO5hhDx61fl84BX1eGDzsa1kC6s9G +VhYhN73rVRdjUHKRLp3XNvhL8EG42TwPXrMeO1XmZdUljXn0SyrjhDushZ3R8pjF +hN+TWWm1iRoU6rqplDzVeehD3EDSQm+8GAJIvA5nDw== +-----END CERTIFICATE----- + +# O=Westdeutscher Rundfunk +-----BEGIN CERTIFICATE----- +MIIGZDCCBEygAwIBAgIMeISrJCOSuhRT4oMFMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI1MDUwODE1MzAxN1oX +DTI2MDUwOTE1MzAxN1owgbMxCzAJBgNVBAYTAkRFMRwwGgYDVQQIExNOb3Jkcmhl +aW4tV2VzdGZhbGVuMQ4wDAYDVQQHDAVLw7ZsbjEYMBYGA1UEYRMPVkFUREUtMTIy +NzkwMTY5MR8wHQYDVQQKExZXZXN0ZGV1dHNjaGVyIFJ1bmRmdW5rMR8wHQYDVQQD +ExZXZXN0ZGV1dHNjaGVyIFJ1bmRmdW5rMRowGAYJKoZIhvcNAQkBFgtjY2F2QHdk +ci5kZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANlCdlE0s+aL2GWe +N76uAb921uUaSrFvxkQEy2QaTZxbm9pmwGc3e79EZrKoewiiRkmalZTt5LMHRz+j +0z8cbQ9lKewWKopTYtB5QFDbIeCaPAgtcdo8o7OfhazD7GlNhnFzXZen6jMeM2fz +z+38xXNsIAjMOHcW0tf9rnzbNIzi3CB8r0Up94m+4yhCLJsJMhfhK094/pItbVT0 +L/mHlPuV2SS5RQDZYu+P+Gmt7rRsXSDiH2nRjBm4Qiz8NX2UAAYabpbRjYA7o4bk +U/fg6T3gTV9jy/gjH9J2kX4W4RbcADroYOM3EhtR5h45h+kgbN68d69tMThYU65i +Q4DpQ2kCAwEAAaOCAdYwggHSMA4GA1UdDwEB/wQEAwIFoDCBkwYIKwYBBQUHAQEE +gYYwgYMwRgYIKwYBBQUHMAKGOmh0dHA6Ly9zZWN1cmUuZ2xvYmFsc2lnbi5jb20v +Y2FjZXJ0L2dzZ2NjcjZzbWltZWNhMjAyMy5jcnQwOQYIKwYBBQUHMAGGLWh0dHA6 +Ly9vY3NwLmdsb2JhbHNpZ24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMzBlBgNVHSAE +XjBcMAkGB2eBDAEFAgIwCwYJKwYBBAGgMgEoMEIGCisGAQQBoDIKAwEwNDAyBggr +BgEFBQcCARYmaHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8w +CQYDVR0TBAIwADBBBgNVHR8EOjA4MDagNKAyhjBodHRwOi8vY3JsLmdsb2JhbHNp +Z24uY29tL2dzZ2NjcjZzbWltZWNhMjAyMy5jcmwwFgYDVR0RBA8wDYELY2NhdkB3 +ZHIuZGUwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMEMB8GA1UdIwQYMBaA +FAApNp5ceroPry1QLdugI4UYsKCSMB0GA1UdDgQWBBQ3ZOARkThjv8LqMfEXmbe3 +TP1lfTANBgkqhkiG9w0BAQsFAAOCAgEAHqkyc+L9jRAArzRS6LP9qwXP0mXnHeXd +3dWLDpo3fXnwD1SFxc9g8SzB0Wg8202eH0vOUijVat0ZEEWsl8zJqk6mVdwH4pJg +iehrQZdi0IkXMqlV3RY8t+vUdFjo32SqBI+EN5hySb5+csiKnj/K0RtMVY8sqesf +vp+zXR1uBkarwA3vd4exu6iOujYhgMzsgebTM9RZppJwvzbX7A8tGEYaK/QD3vw7 +UjfnskntXTnC7GLYrz5sAfNfkFezpHSyKsxtdoGW+u9JxoL+TWsqr4gRrq9IZB+0 +7povFHQT39EHXHPkOX5ZpBtDMv7DdQRuHX69Ir2tPbdcjEyKbT+02mgwunLnxm6U +QvrJgfGCPZTZOxOkZxwpgWBq58OwaSbmmBmyoehJN+vIxWmR5z48K/VqSN4A0FOC +Igd2nUTsiqZ9DnaQMzgAzvX6nAETj6yQgAREN+Zr4/Z53rJJMwvLWg8uWiUEQiPX +PbBjVcfYh9M88QxKgdZcuZ/ZA+YSEyOJnx4KQGh5cyn5YgmQ8Gy0CGGk1spYiKFQ +RKmwlmgfx0q0lXPdhsS+06UzAFS6BQmjWy+Y8oMt1InO5BQvVUlsimx8e8yfEsyT +Oa+vNAh+0pg4YHLfTnOJh2TjaBXMBI8+3wN6qSfyxi7fllRhpZVgYf7c8LReBoKZ +nGZ8mKDP2bY= +-----END CERTIFICATE----- + +# O=Sony Corporation +-----BEGIN CERTIFICATE----- +MIIGazCCBFOgAwIBAgIMDBw+WqC9RwH73H2BMA0GCSqGSIb3DQEBCwUAMFIxCzAJ +BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMSgwJgYDVQQDEx9H +bG9iYWxTaWduIEdDQyBSNiBTTUlNRSBDQSAyMDIzMB4XDTI1MDUyMzAxMzcyOVoX +DTI2MDUyNDAxMzcyOVowga8xCzAJBgNVBAYTAkpQMQ4wDAYDVQQIEwVUb2t5bzEP +MA0GA1UEBxMGTWluYXRvMRwwGgYDVQRhExNWQVRKUC03MDEwNDAxMDQ1NjYwMRkw +FwYDVQQKExBTb255IENvcnBvcmF0aW9uMR8wHQYDVQQDDBZzZWMtYzJwYS1pbmZv +QHNvbnkuY29tMSUwIwYJKoZIhvcNAQkBFhZzZWMtYzJwYS1pbmZvQHNvbnkuY29t +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsRbq9Ano9cSPmWCqDo0h ++CH9uxPzJImE1TfvE638IjknCMOUK06nYgJ6xkQWMvhRcXW+WifzTWZ/wU3baPcQ +9B2p3rJUHqcrgYdPUws5WpVlYwdoe+25Ez5wj5XCk3En3cHj+hFRsyiIMZdFA666 +PsY1FcV0AV9/VKnAjmx431J0cnHRyWTKdQMkLyRQCIwz6OjJMRP3PleIY83Fjd3y +67NmSAeNFP42/y4QrY0ofB0TfJfxRgnvIiXXOJuus6zC7nX2dnnMVSiiVxli2xWB +39pXUoEPkc++KX5NEVo2gflBmjbELD1EwUp08Ip5wDyrKJsdgZam/HtrY/BjnErE +wQIDAQABo4IB4TCCAd0wDgYDVR0PAQH/BAQDAgWgMIGTBggrBgEFBQcBAQSBhjCB +gzBGBggrBgEFBQcwAoY6aHR0cDovL3NlY3VyZS5nbG9iYWxzaWduLmNvbS9jYWNl +cnQvZ3NnY2NyNnNtaW1lY2EyMDIzLmNydDA5BggrBgEFBQcwAYYtaHR0cDovL29j +c3AuZ2xvYmFsc2lnbi5jb20vZ3NnY2NyNnNtaW1lY2EyMDIzMGUGA1UdIAReMFww +CQYHZ4EMAQUCAjALBgkrBgEEAaAyASgwQgYKKwYBBAGgMgoDATA0MDIGCCsGAQUF +BwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzAJBgNV +HRMEAjAAMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jcmwuZ2xvYmFsc2lnbi5j +b20vZ3NnY2NyNnNtaW1lY2EyMDIzLmNybDAhBgNVHREEGjAYgRZzZWMtYzJwYS1p +bmZvQHNvbnkuY29tMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDBDAfBgNV +HSMEGDAWgBQAKTaeXHq6D68tUC3boCOFGLCgkjAdBgNVHQ4EFgQUOGnClU98nO3h +b7YreubyJQOO66AwDQYJKoZIhvcNAQELBQADggIBACCS9e/ALoGO381EZJQ7Xi3V +E6VnQDqxxlyFSk2PkJ52UJhGu8x7rV6CFeoiiDry8q4/XnzpqREzCFpaFpuZgzRF +uPxF0HE5CWV2NZrkeL+xx3WkH1S3kdEfVjpThirzXcARPwWu5dO48n5t6z/7rTaa +xi9NbQqS5U1bTgaVlDdzD3Gm87BuKCEibJ48W3cg3KHIQMNF+ydFr3V6bsBXS8rg +xjuwY9o9OgXaMDCPDibfFWmlwKcrtfiM2F5ASVqXL5c+SlM87OKjOlg4wweK0IbX +SNHVspFpfhCkeuTQC0HvnAMDJrae4cHA54FOY69LKA7oU3YfV0clE33Amr5lZ2U9 +df3apGIM+mhQNqbgDvch7AapokCRY9y6efs3EkBHTjLg0DaK14GZeogtEeKop6b6 +Nv7vOXdJlvYcG/kyQlycO9KkRHxxEmB+mbSzMlJqTdbbhIjjkj17JdaSlILvmjf+ +t5XojjTvAKM9OT2Uqb3PX0ahf2lBgIpDD/b3nWLHlBWa5OhhCdBGHKxPdYGgzVr+ +TJT8N+gx/KZPRqIn07L9VNaBlYUJe8SHlvPRr2HRmwIwGfCN03r224W6GBzVcVEI +iDE8JHcS5s3uYsrVCZFiFq/RZ5G2/NBPKdtgaeMFI0cdjuEsPylXWJXQMunif9nM +U02/bVLmepJxtaKVluLi +-----END CERTIFICATE----- \ No newline at end of file diff --git a/tests/tmp_cert/anchors.pem b/tests/tmp_cert/anchors.pem new file mode 100644 index 0000000..b0d9191 --- /dev/null +++ b/tests/tmp_cert/anchors.pem @@ -0,0 +1,328 @@ +## The C2PA intends to publish an official C2PA Public Trust List. Until that time, this temporary known certificate list for use by the verifier at https://contentcredentials.org/verify. The list is subject to change, and will be deprecated. +## + +Leica C2PA Root +-----BEGIN CERTIFICATE----- +MIIDCDCCAq2gAwIBAgIQfj2771gNZMLyE3lSWlq8UDAKBggqhkjOPQQDAjCBojEL +MAkGA1UEBhMCREUxGDAWBgNVBAoTD0xlaWNhIENhbWVyYSBBRzEbMBkGA1UEAxMS +TGVpY2EgQzJQQSBSb290IENBMRAwDgYDVQQHEwdXZXR6bGFyMQ4wDAYDVQQREwUz +NTU3ODEYMBYGA1UECRMPQW0gTGVpdHotUGFyayA1MQ8wDQYDVQQFEwYyMDIzLTEx +DzANBgNVBAgTBkhlc3NlbjAgFw0yMzA3MDQxMjM1MzNaGA8yMDczMDcwNDEyMzUz +M1owgaIxCzAJBgNVBAYTAkRFMRgwFgYDVQQKEw9MZWljYSBDYW1lcmEgQUcxGzAZ +BgNVBAMTEkxlaWNhIEMyUEEgUm9vdCBDQTEQMA4GA1UEBxMHV2V0emxhcjEOMAwG +A1UEERMFMzU1NzgxGDAWBgNVBAkTD0FtIExlaXR6LVBhcmsgNTEPMA0GA1UEBRMG +MjAyMy0xMQ8wDQYDVQQIEwZIZXNzZW4wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC +AATYWHZLNiNnug3OVuNy0DbdTFEDDuVfzZeqis2yX2AgqZ9fM2R7UqC01v5pMx/N +xRMSV/Q/DD6wR0dwtkXaxohko4HAMIG9MA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFK1aJ39jgaFAW/vnqbxTtDBFVI77MDUGCCsGAQUFBwEBBCkwJzAlBggrBgEF +BQcwAYYZaHR0cDovL29jc3AubGVpY2Euc3lzdGVtczAOBgNVHQ8BAf8EBAMCAQYw +RAYDVR0fBD0wOzA5oDegNYYzaHR0cDovL2NybC5sZWljYS5zeXN0ZW1zL2NybC9s +ZWljYV9jMnBhX3Jvb3RfY2EuY3JsMAoGCCqGSM49BAMCA0kAMEYCIQCMmLG+9WqL +EFo+xkgDMaihJTTpbWDfSCcNrMfb9KEl+wIhAORyQm7Wchx4fmMQKYubFjeYCZtP +u+FSiisFK83vwhTQ +-----END CERTIFICATE----- + +Microsoft Root +-----BEGIN CERTIFICATE----- +MIIFrzCCA5egAwIBAgIQaCjVTH5c2r1DOa4MwVoqNTANBgkqhkiG9w0BAQwFADBf +MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTAw +LgYDVQQDEydNaWNyb3NvZnQgU3VwcGx5IENoYWluIFJTQSBSb290IENBIDIwMjIw +HhcNMjIwMjE3MDAxMjM2WhcNNDcwMjE3MDAyMTA5WjBfMQswCQYDVQQGEwJVUzEe +MBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTAwLgYDVQQDEydNaWNyb3Nv +ZnQgU3VwcGx5IENoYWluIFJTQSBSb290IENBIDIwMjIwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCeJQFmGR9kNMGdOSNiHXGLVuol0psf7ycBgr932JQz +gxhIm1Cee5ZkwtDDX0X/MpzoFxe9eO11mF86BggrHDebRkqQCrCvRpI+M4kq+rjn +MmPzI8du0hT7Jlju/gaEVPrBHzeq29TsViq/Sb3M6wLtxk78rBm1EjVpFYkXTaNo +6mweKZoJ8856IcYJ0RnqjzBGaTtoBCt8ii3WY13qbdY5nr0GPlvuLxFbKGunUqRo +Xkyk6q7OI79MNnHagUVQjsqGzv9Tw7hDsyTuB3qitPrHCh17xlI1MewIH4SAklv4 +sdo51snn5YkEflF/9OZqZEdJ6vjspvagQ1P+2sMjJNgl2hMsKrc/lN53HEx4HGr5 +mo/rahV3d61JhM4QQMeZSA/Vlh6AnHOhOKEDb9NNINC1Q+T3LngPTve8v2XabZAL +W7/e6icnmWT4OXxzPdYh0u7W81MRLlXD3OrxKVfeUaF4c5ALL/XJdTbrjdJtjnld +uho4/98ZAajSyNHW8uuK9S7RzJMTm5yQeGVjeQTE8Z6fjDrzZAz+mB2T4o9WpWNT +I7hucxZFGrb3ew/NpDL/Wv6WjeGHeNtwg6gkhWkgwm0SDeV59ipZz9ar54HmoLGI +LQiMC7HP12w2r575A2fZQXOpq0W4cWBYGNQWLGW60QXeksVQEBGQzkfM+6+/I8Cf +BQIDAQABo2cwZTAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUC7NoO6/ar+5wpXbZIffMRBYH0PgwEAYJKwYBBAGCNxUBBAMCAQAwEQYD +VR0gBAowCDAGBgRVHSAAMA0GCSqGSIb3DQEBDAUAA4ICAQBIxzf//8FoV9eLQ2ZG +OiZrL+j63mihj0fxPTSVetpVMfSV0jhfLLqPpY1RMWqJVWhsK0JkaoUkoFEDx93R +cljtbB6M2JHF50kRnRl6N1ged0T7wgiYQsRN45uKDs9ARU8bgHBZjJOB6A/VyCaV +qfcfdwa4yu+c++hm2uU54NLSYsOn1LYYmiebJlBKcpfVs1sqpP1fL37mYqMnZgz6 +2RnMER0xqAFSCOZUDJljK+rYhNS0CBbvvkpbiFj0Bhag63pd4cdE1rsvVVYl8J4M +5A8S28B/r1ZdxokOcalWEuS5nKhkHrVHlZKu0HDIk318WljxBfFKuGxyGKmuH1eZ +JnRm9R0P313w5zdbX7rwtO/kYwd+HzIYaalwWpL5eZxY1H6/cl1TRituo5lg1oWM +ZncWdq/ixRhb4l0INtZmNxdl8C7PoeW85o0NZbRWU12fyK9OblHPiL6S6jD7LOd1 +P0JgxHHnl59zx5/K0bhsI+pQKB0OQ8z1qRtA66aY5eUPxZIvpZbH1/o8GO4dG2ED +/YbnJEEzvdjztmB88xyCA9Vgr9/0IKTkgQYiWsyFM31k+OS4v4AX1PshP2Ou54+3 +F0Tsci41yQvQgR3pcgMJQdnfCUjmzbeyHGAlGVLzPRJJ7Z2UIo5xKPjBB1Rz3TgI +tIWPFGyqAK9Aq7WHzrY5XHP5kA== +-----END CERTIFICATE----- + +Adobe Root +-----BEGIN CERTIFICATE----- +MIIFpDCCA4ygAwIBAgIQXfEvX1enw+GwAtiTJwzd4TANBgkqhkiG9w0BAQsFADBs +MQswCQYDVQQGEwJVUzEjMCEGA1UEChMaQWRvYmUgU3lzdGVtcyBJbmNvcnBvcmF0 +ZWQxHTAbBgNVBAsTFEFkb2JlIFRydXN0IFNlcnZpY2VzMRkwFwYDVQQDExBBZG9i +ZSBSb290IENBIEcyMB4XDTE2MTEyOTAwMDAwMFoXDTQ2MTEyODIzNTk1OVowbDEL +MAkGA1UEBhMCVVMxIzAhBgNVBAoTGkFkb2JlIFN5c3RlbXMgSW5jb3Jwb3JhdGVk +MR0wGwYDVQQLExRBZG9iZSBUcnVzdCBTZXJ2aWNlczEZMBcGA1UEAxMQQWRvYmUg +Um9vdCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALbacmKb +7oN7MqJG44ojMpdXrC1zdFHLBv97MuaXDKzI59kgZ0hK900lgU8iXW9p2iwYQs/F +bJ0+cTRxUlKhthpbnRTNu42R5LGI+XAPbQznxqfr82ScT11BwF/mF4hATOsDy5Xv +sqXmjji9HCN5V8MicQTJcQ6zK9W9U52m7lLt3vK1T/eQKFL9UBd+JN032AoSGxOL +oxQ55qlJp8bVTBbBX220ZwrnGpl2Q59F7Mwc9KQSUG/6kJ/maqi7l5E//eUgj+CP ++WO82cW5XQmMp5aSZ6hg1dW2dBLDddEZe7/zl43eWp+S8DRByzQofDt+yAKkp7MJ +K5Vdhh4RnMGdAkkg1s7e2osxG090hIfqwV4pE5m7QT4ikNJmxxorvZNETfO+FxCJ +o72i7yMymZWHmKXObvluPvByzqVpuFPldywKvZgHIte730TZ2JZtnArX638/APjD +KH3hJRJNnx8KH2/WWNTek2IY8vuyMMrFukKMzDiglqfL2QGzyWpObMTazhvP/Z2M +MjtWVtMoZeGceUTfSq64HNwzFkZoz3rOPYu1ZYw493PEjqaY5fxIMtBd/kv2m5WS +FUUwBA2eJWKkx0u/cZ91ZAfxSwuGbaplDvr9NzIJXRdtiZRAI4fptFOVzSNvCQ9C +zK7QQRrbbLdFjsMP3VxSfsIJcrcMATSDLm6BAgMBAAGjQjBAMA4GA1UdDwEB/wQE +AwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSmHOFtVCRMqI9Icr9uqYzV +5Owx1DANBgkqhkiG9w0BAQsFAAOCAgEAlfp1Y79qJhM2l0QgpaXieeEB7wgURNlA +QRPQOjw24NlmnM4Kquzx9LSVoP1EPlTx+3ku0dGcTYhZiBsLTeOTjMT4j36j5jKT +WfWuuGwQboawtSftbmW7Bsy5x8ZEU7g70toZR2HVlXbaR46ChinHlNu79IXBtWZs +bdG+/btjGrVg6cQAs3U/GAFsoL4G1MkqV6shDvHQNjlzEBbkS0Idcvt+J3sqn/Om +JU8tAqzNx7e2RLUI2ZH4DT1QjVadgik5UVM9AAeTS1gTsIp3nCCid2aF0MpeIZp1 +u25E8yQRxBYeVFoj1ZYtxwYfcz3X6A68gIb6ZBeRzPq+wt8bEpS8h47O6hJ5pyNB +bdqBDe6SVdwz7ZUtjGBEJM5oc68j+QNShnke23/duIeK0jopwpyCeEtFckyNjAoL +YsrGG3+MQQGVDqgYZ/W8Ow0AQz/Zt0RfcqQmfCdbxWbTusR8lpZf8reaPU2X5adp +YDpY8W+rVNULcsk/Sj+BZ8YpcrMk90BbXf2K7bbzQw2ODtzHphL6SQkt3Ja6oKLa +WRvQTsaK7K8w+WSilfCtt4u4AAxByxlwmt/KHeMfHZskty/rHLyk7kwgtRzXdvpA +7quYkGyLWtTtZoB5J1b7OYUraMDuqG1s39jMchHjda1GqOwsBWxDqC4HqtdY7TK2 +ofZLvqTHvT4= +-----END CERTIFICATE----- + +Truepic Root +-----BEGIN CERTIFICATE----- +MIIFbzCCA1egAwIBAgIUQfJJVcjenVsqV04ke2B6+nMusbowDQYJKoZIhvcNAQEM +BQAwPzEPMA0GA1UEAwwGUm9vdENBMQ0wCwYDVQQLDARMZW5zMRAwDgYDVQQKDAdU +cnVlcGljMQswCQYDVQQGEwJVUzAeFw0yMTEyMDkyMDA0MTdaFw0zNjEyMDUyMDA0 +MTZaMD8xDzANBgNVBAMMBlJvb3RDQTENMAsGA1UECwwETGVuczEQMA4GA1UECgwH +VHJ1ZXBpYzELMAkGA1UEBhMCVVMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQDpdmLCqEXVSqb2GVireQbWQHTh9fo3Sja9r9grNAgH4iqEKS7Wlv+zDFmB +lWEfED/e1teBFy8sXqQTZM/nqfEuOAYbepJl535Olp/vOUryAMx78M2svGGug8xG +IOTXGJPekK9sqUwgNe6lgAP7v648d2ygw58MHZ/y20B3XMgiWMwVeM24PHYfQ/bp +zYz3AkG9lrmHbFu8Aily4jFe2b6VI1JbQYgo6DM2uPl7l3VRK2a857+WZioco425 +a1xWnv/sJYxPjLEBNq3BDkAJ8vz4DbKnGbRg4mwFQLpLY7bGJVfU14xEbDfuoz/K +ZBO8D2ktLGQGtFdldtsbVGdGvyvuOz/gcwJ/Vq5om7+8OkByiCw50bjU1caReS4q +842VZt1Hw6P3MUsfjHycG+xwYwu0jC4DXl1xCdnuRtYlYZhP8TkUUCN5XeLdnyAm +HIlItkhxin9+2UcNUJUFckyuR2Y5rqAMWZslzb22vPV1QAuBB+wHFPjJrMPMWuw6 +3wOBqLAPhplMUp//Ixbo6RXuhs5duNn7Jq6FLx5Eu6sZOiF/MuFnGpvKWr0LrGkP +bnc7wPcFMafh/7Ha9IhAGsD4sELsgTNWcklyPYxLESy+DHptF9nLc+6SAzDPy4ci +qB0tSRS/jehD6hQ5XdTcyYUjjFUlG04uRqImKJhEQVN8/A/GGQIDAQABo2MwYTAP +BgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFFi68anyDedFBgqwKadalzDqJz0L +MB0GA1UdDgQWBBRYuvGp8g3nRQYKsCmnWpcw6ic9CzAOBgNVHQ8BAf8EBAMCAYYw +DQYJKoZIhvcNAQEMBQADggIBAIM3f+uTGlEhxinXEASr0MfbUZOK1i58KyDM35Ot +NOHrXv4+z468US40tSYYizto2tpALygkAh0ddywgayOGwLaKR00IkIVwbEH4UVho +pR1QK7PXmmqrF8MTe60TNUiRgC6NUzzKyCIZzIy5e4Q3Cx8uMnNYniaU0TPZeWF9 +pWRiIPc7QOZPl3pAUMtHMFv1z5Ww+vJ6iUHKSQFCSs6vy+/fdiWLfdgok6mvXbw1 +EE6J6DIypwZU275v5L4UM9b40uNqlSdk6ckraNcj2whsx7D8fpXwKjvkCbihWt8l +gd05fL/7tJBnO/YorriTtBqtUviLnnTc0iEjC5S6yo/HIEWJUL+VK8hH4Tvq4e7Q +W5KC2/hFQ40CyOIuq0QMfjml+Uwp/4zW6LGK+OA09VhQ1dilztXvOE+tZorPTwy5 +CPRDi5Mjou6ZQy8LbhSdzrjVJGmEbv/7bsDDxHB/zN4Xb8LrtS89hoGDowu/y/vh +p4/IGuK7iAYb7mLrho0Xl9FUnavgYSm/tMh9UvcZ4Hs5ZeOhdbr5cbxVKDrCGwTs +77U+mI4JBR4WdoORw/CMyjLF7mkO3QZmr0YhTLMdRzn6/yPkotg9OAbLEM1cVZSt +wiz6O4c5amE4Nx+V6hBaLctoD23No45vnrnBDCF3BcVmFcQPBGF450dzKAnuY25a +wpEZ +-----END CERTIFICATE----- + +Microsoft RNC Root +-----BEGIN CERTIFICATE----- +MIIFzDCCA7SgAwIBAgIQVJjS0dRbGZVIE3nIEcCHmTANBgkqhkiG9w0BAQwFADB3 +MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMUgw +RgYDVQQDEz9NaWNyb3NvZnQgSWRlbnRpdHkgVmVyaWZpY2F0aW9uIFJvb3QgQ2Vy +dGlmaWNhdGUgQXV0aG9yaXR5IDIwMjAwHhcNMjAwNDE2MTgzNjE2WhcNNDUwNDE2 +MTg0NDQwWjB3MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv +cmF0aW9uMUgwRgYDVQQDEz9NaWNyb3NvZnQgSWRlbnRpdHkgVmVyaWZpY2F0aW9u +IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMjAwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCzkSoHgwZn/Z6d4MfAt6TmQgR/D6bbX/vVWtdFoPt3 +C/CA86ZtWk15U9ighoRXRSDHolT7x6K/isduNfOiFcQvTuNKhZZJDf++mdgU9rwn +B+5Cmyv1C5IG5P1pE2WokXLymITrgz0O5NdxEkghyw3t9kdJt5v5yccXtoRP/7is +mtdzZ0mF44a9N0DQJYbU3rXCbWJq1al4vC1vSfnlbBQU/RTH02UWN97LbrxeKY39 +YpsVLNYF5rmJMjOjYsfX1lJnCMQu9FYrnguHzOyntKaq6wXNGVelOgsEJxyRZ54t +Yi0vHr7awCDLBBnKM/uJvpjicqByNb554ZyDb+RtF2+Q8z0AhnU4jtDgSZq729P4 +MMrVV4hoTXLTv21/cdj9vQ2ukmRIt1tveSa1zZuVIYTR7w8yPXtXjPNFB0x84F4Y +DjV2i22eyzZ0qwX44HNdMlaUZ5clCsY1PZSX58FEi4D9wfj0dBnlMPYG+yFXPgYc +i2sVhidJe4KTylnodUfoPzj0x1N5oLa04lxR771fOMET5ngMlVouxUBZKMwPJMDs +ugl3I5k4prYc2se6ILbXN9h/N68I4ztx225zG32ZcrDkhjNZdLUWAHtQbcaGE9r9 +xDmCPSQAmmDaupTABVEsNKxQmROHu7MFgLJNMAJcuCaDXbRjc++uI5VPYCi+N9Vb +pQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUyH7SaoUqG8oZmAQHJ89QEE9oqKIwEAYJKwYBBAGCNxUBBAMCAQAwDQYJ +KoZIhvcNAQEMBQADggIBAK9q3eYZ5y2UQxlOy+lQlWSlA5ECi+I2gDsVolLCFhm2 +alpddEMw9Jv/YHQJsSEekBZtxSSPXGaIY/RPzH3yEkxAEIsBn9qpyK7ylRvPnQXr +ST50oGhb5VYsZRyCflPaVtlGF3mSRcQQNghSKRfLL6byftRpJIoej7BzDcwcSquy +qu2nkWMBZCKoMrh+MiizZ3MtkbTcMQEL90cKpvHXSu1WYMQsCKN7QLC8dCdSh9a+ +iN03ioluZ4gd9cldoP62qzqA1xqXPBc2IkEerE3Vg+Y8OL1PMOlUqdO2BMMydmG7 +sBjFKxizwIDVt5WwXlFNIvzsWKro2JS0pS7tkt7nGHwhV91VY/e/bc0f0qZ3KHDH +4ls6WwjSW07IAJaz4YM2r4YKZVx09ursemp0oPBL7u+Uo6xQ8oft1zowg8n7fVe+ +5eP4QcrlZK6zo+xY7IWazO+56vNWGLlcc5qvxXcXg1nbNxoYclSlQdK2I3WjQ5rl +d3yWebdBjb/s3ICgn9F3dVhfNRPgJRpnC33OJfoHCuRhIdjUHOUHxjaZ9JbQxhX+ +Ts3Xroud2xb9BMaSvdSI5qmjqrv3ZDg7X8wM0DW+dBkDpsWqTKJhNoI+HfMrvJdd +20t4Oy31O+9gI+j17AsjNpWvmGa/U9N7uGlKKpZmacSUxvRfbqyYeIiABlyisu2i +-----END CERTIFICATE----- + +Click/Nodle Root +-----BEGIN CERTIFICATE----- +MIICHDCCAaGgAwIBAgITEkGhSPCEEtphvbOmfJRJGv/f3TAKBggqhkjOPQQDAzA9 +MR0wGwYDVQQKExRDb250ZW50U2lnbiBieSBOb2RsZTEcMBoGA1UEAxMTQ29udGVu +dFNpZ24gUm9vdCBDQTAeFw0yMzExMjAyMzIzMzJaFw0zMzExMTcyMzIzMzFaMD0x +HTAbBgNVBAoTFENvbnRlbnRTaWduIGJ5IE5vZGxlMRwwGgYDVQQDExNDb250ZW50 +U2lnbiBSb290IENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEKKjUvBHg3eBRpS38 +LIuBZ4kfP/pfQw2CzsgT95JqZBrPnlkYvTcEg7tIEriPgVHLC5pXHMSbbQFIYEJ8 +YLXHY335sBmhnomZFDM1yqN0P3PK/cfsMKIZ5aIkAhD93fqGo2MwYTAOBgNVHQ8B +Af8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUDK+bQAU+9IPexRNP +ElBJtbIbSRIwHwYDVR0jBBgwFoAUDK+bQAU+9IPexRNPElBJtbIbSRIwCgYIKoZI +zj0EAwMDaQAwZgIxAI6PtQ946M7E9Ex4fFb9djgYIbVqJ8Em4ywOFddNAR6DvD8D +u0ZmTtCWBQqWvFxG4gIxAM7eUjCRqT6YLjbsD7eB6k3VPdm46erzQd/Cad820I2E +ThMCsJUSjNKONkZH/JuQJA== +-----END CERTIFICATE----- + +Samsung Root +-----BEGIN CERTIFICATE----- +MIICjzCCAfCgAwIBAgIEXHYjDTAKBggqhkjOPQQDBDBZMQswCQYDVQQGEwJLUjET +MBEGA1UEBxMKU3V3b24gY2l0eTEXMBUGA1UECxMOU2Ftc3VuZyBNb2JpbGUxHDAa +BgNVBAMTE1NhbXN1bmcgY29ycG9yYXRpb24wHhcNMTkwMjI3MDU0MTMzWhcNMzkw +MjIyMDU0MTMzWjBZMQswCQYDVQQGEwJLUjETMBEGA1UEBxMKU3V3b24gY2l0eTEX +MBUGA1UECxMOU2Ftc3VuZyBNb2JpbGUxHDAaBgNVBAMTE1NhbXN1bmcgY29ycG9y +YXRpb24wgZswEAYHKoZIzj0CAQYFK4EEACMDgYYABAGFsa4uumqXkjZYmasTmQRV +k6j52ADjqYqtUl/+yDN/Oza7sz1zVj1mQISKJiSFMUT289tqyZR9fJvCBnYQzfQD +UAE93XbifclsQN+wH/CcwfUByCwnIkU9sRNmLLjYWHCL7YEIDltwd7tKt2REhhKx +0FFooGhmxqnEHSAA6zSNI9Ffk6NjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8B +Af8EBAMCAQYwHQYDVR0OBBYEFGbsTn+ECfTAKlYSkIP+hkA01S7/MB8GA1UdIwQY +MBaAFGbsTn+ECfTAKlYSkIP+hkA01S7/MAoGCCqGSM49BAMEA4GMADCBiAJCAeGM +gCL5SfTUycZWd+37+cQIFSn5E1AzLIDw1ps1heoWoTj0dM9SPmWBo/TlWZrbtD4G +yH2VI7vz3wkpB9W7oT9RAkIAluAfQFNEqCoYndVEyGhu5RjG412BQdNbh8Y5NzZy +mu4/Zg7pC0ctus6hdJ8J5DjekOEh6tTy8poqNYC+wvHgAJg= +-----END CERTIFICATE----- + +Metaphysic PRO +-----BEGIN CERTIFICATE----- +MIICEzCCAbmgAwIBAgIUVIrV56rbRKoLP81rfblb/2mrQPkwCgYIKoZIzj0EAwIw +WjELMAkGA1UEBhMCR0IxFzAVBgNVBAoMDk1ldGFwaHlzaWMgUFJPMRcwFQYDVQQL +DA5NZXRhcGh5c2ljIFBSTzEZMBcGA1UEAwwQTWV0YXBoeXNpY1Jvb3RDQTAeFw0y +NDA5MDMxMDM4NTBaFw0zNDA5MDExMDM4NTBaMFoxCzAJBgNVBAYTAkdCMRcwFQYD +VQQKDA5NZXRhcGh5c2ljIFBSTzEXMBUGA1UECwwOTWV0YXBoeXNpYyBQUk8xGTAX +BgNVBAMMEE1ldGFwaHlzaWNSb290Q0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC +AAQeOqzGfyAbOjAM4Mf7xeWppTYdolsa7w4BKbXVrBtY5lS4lWrDR3m5JzB31BlL +hR+3pq0AmtdVMz9heQgHD5rRo10wWzAdBgNVHQ4EFgQUC+M9/xDkKCtSA7GVwbFG +YFEH3aowHwYDVR0jBBgwFoAUC+M9/xDkKCtSA7GVwbFGYFEH3aowDAYDVR0TBAUw +AwEB/zALBgNVHQ8EBAMCAQYwCgYIKoZIzj0EAwIDSAAwRQIgPb9+Evw000uDjMQg +3TeRvzhl8+B+03OG5WoyyjZvb90CIQCTDCIltIkUr0/EYTJf6VLKM7mBAZlWX4s2 +Bz3E79YeEQ== +-----END CERTIFICATE----- + +Canon Inc. +-----BEGIN CERTIFICATE----- +MIICBzCCAaygAwIBAgIUapyBGpjTU7rmwk5Y6gO5m3d2hBYwCgYIKoZIzj0EAwIw +YDELMAkGA1UEBhMCSlAxDjAMBgNVBAgTBVRva3lvMQ8wDQYDVQQHEwZPdGEta3Ux +EzARBgNVBAoTCkNhbm9uIEluYy4xGzAZBgNVBAMTEkNhbm9uIEMyUEEgUm9vdCBD +QTAgFw0yNDEwMTcwNzI1MDZaGA8yMDY0MTAxNjA3MjIxM1owYDELMAkGA1UEBhMC +SlAxDjAMBgNVBAgTBVRva3lvMQ8wDQYDVQQHEwZPdGEta3UxEzARBgNVBAoTCkNh +bm9uIEluYy4xGzAZBgNVBAMTEkNhbm9uIEMyUEEgUm9vdCBDQTBZMBMGByqGSM49 +AgEGCCqGSM49AwEHA0IABFnVKwHeC+Cx3gDiLhatGQObilqx5huCx3iQ4dF98gsr +oT1fBIL3yUyWtXK4yt3yfYt/t1sUozjTWQboJiZKLvejQjBAMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFNuSgKOKZTMu1E0kQKoSAICI5R7TMA4GA1UdDwEB/wQE +AwIBhjAKBggqhkjOPQQDAgNJADBGAiEA2GLR9KHDjO+0Wf9PKsTckmKeSzvz6cGh +54p6z6Z7lAECIQDx7lT/5ByzxTbYB36Pd6x+9eqkvM69QddPh+pRpvYk/A== +-----END CERTIFICATE----- + +Fujifilm +-----BEGIN CERTIFICATE----- +MIIB4jCCAYegAwIBAgIRAI3b5qRoBIlWVln9WIRMnmMwCgYIKoZIzj0EAwIwTzEL +MAkGA1UEBhMCSlAxHTAbBgNVBAoMFEZVSklGSUxNIENvcnBvcmF0aW9uMSEwHwYD +VQQDDBhGVUpJRklMTSBDMlBBIFJvb3QgQ0EgRzEwIBcNMjQxMjA5MjI1ODQ3WhgP +MjA3NDEyMDkyMzU4MjBaME8xCzAJBgNVBAYTAkpQMR0wGwYDVQQKDBRGVUpJRklM +TSBDb3Jwb3JhdGlvbjEhMB8GA1UEAwwYRlVKSUZJTE0gQzJQQSBSb290IENBIEcx +MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6Xo4h6qtgkxn+LAWDsDU5GSCHYjj +Zm4tHIEmmdyJrZCDYEyXfPhvSS09XKyXIDIEwQcdZU9gAsZdjNjP8cVva6NCMEAw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUjBEQ4pKsJIoIJzI2jJqKQ+78Mfww +DgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA0kAMEYCIQDTnTnmnXrgRZpdDY9i +YlXwoF5tJpTaU30UFLUO9PdtpAIhAMoOjajOcuooANmO4ZSFobiaw6wGndE0BxyZ +ic3gTwMF +-----END CERTIFICATE----- + +Pinterest +-----BEGIN CERTIFICATE----- +MIIF7DCCA9SgAwIBAgIJAMm9DzS6qm7hMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD +VQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNU2FuIEZyYW5j +aXNjbzEXMBUGA1UEChMOUGludGVyZXN0IEluYy4xLTArBgNVBAMTJFBpbnRlcmVz +dCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eTAeFw0yNDA3MzEyMTMxMjRaFw0z +NDA4MDMyMTMxMjRaMIGCMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5p +YTEWMBQGA1UEBxMNU2FuIEZyYW5jaXNjbzEXMBUGA1UEChMOUGludGVyZXN0IElu +Yy4xLTArBgNVBAMTJFBpbnRlcmVzdCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0 +eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANlgMDVxsvPvDRA7m3oJ +vr7ZqRcJxHW/wOSQjcKEWLe4nAQS+vRfe19A+mT/jzPdmILS5HNp2hm6cXgsDlWK +nlHZzPYr5X4lBTATSjh+yjGfNOdeqmdSshi7fPo5FqhdpTfKFaDMrRx8+7YumQGI +fB1cxRMTYDQLD/rU5CZOkiPZzTgo5l6Obgo6WtfHsSBUZkXujLmA9w5B6pU2vj8/ +8kxknUung5JJ/XEyO3nGBjVpvXfqGhy/UHnVuVDlIpqf8Xu3LJ3mVnDYlfBVb9AO +R8Fl3Le48k/AkeGWIZXgwoSVCd8UelwEv9AcROSOEe5nVM+5nEsk1symdiXnpHdp +GRTfvlpbzi02J4t7tjbdSnnA4uigioNskiD0armJU88luFAJPncQH/gy8SFN5XdT +NLJjauNduwkNwpfOcWEEqDxxTH+ErbCyvwb5+FBweZSlf23U5k1fLKcm7yW79o9E +uPBt9H5yaP2WvDrvIxIhhrtrvmVLqyPVfiNFe7DYnt0Z+BOk/eax8nC1SyjvAzrh +BUWKgbOb45YB3dn0XBmnCoiaMoq9GjmtUk1k1v5IUBgp8P8cVEMor2kX6PrEQGFA +H0wQSkSxGFAuemeY1t/dEI9paUc57uNdKvvN/CjElmytNvluYRwREAZTSjpd4ngz +z/gHxiiy8TlA7IZBaTCXEah3AgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYD +VR0PAQH/BAQDAgGGMB0GA1UdDgQWBBQwHanMifxO2QnKWAP9FT8C+iGXozAfBgNV +HSMEGDAWgBQwHanMifxO2QnKWAP9FT8C+iGXozANBgkqhkiG9w0BAQsFAAOCAgEA +DxTjUe0RU6KoLvgYmXYMWJlhtJw3B0rEQYA7+ICHQPBPhElTyoHnSZQUBWIOqSWB +VjgYOvyX8E9EAVaHRBel4pQOn6b3chK50xm3psjGU7bZhf0DISMGlrHHLmxSU705 +5JsYE0SOYuNTYp7rb9Rbbj1UTMI0PtAKIMVxWeWiEOoYWX78urQO9XD02OVHFSTI +HlKtA91mNrCO9I99pJeM9Shh485b5B9cSvOfvtTX8bdWHL8nFFWXjgrB4XnPsrKy +chTb5+4CxnIVps8x4bu8BGNu/NDck/+XrB1wvpPP/StIPY52ZVXvXzGXDUMvW91d +j7uRx6Te3sro0csNlhLMvZJRnk+VTvUB5/XsTAKZ4YlX2QZ3YuG/VWjt6NPtE5gQ ++QqksZUdhyRKoIY8kGk540PD+3UAgwHnbrPznNc0EoMBphe4oI9zKb6BB1tpivGy +vL6ZFIKcKPJSmtaB95tipnFkTTmJmgxY0bWD2GXnjS6w+EpMhdiXYWg+ALdGZwb0 +B5JosgHQw2NGCZ9aVimITFynJUTOtFcXaO8MxsKdri0rNDp+dWsHlKtbQYaxolCC +M4YU9ykc8OCDySb4NwX7m59GDA0xELtiDyW4hGagAY+bzzUfigZY9jzuTCq2tkX5 +s6SDrqImp50u2dqUUAfvBDHTNutzbhkxow+sQ+lfr4k= +-----END CERTIFICATE----- + +ATOM +-----BEGIN CERTIFICATE----- +MIICmzCCAiCgAwIBAgIUAJqo+ansD9x4r/iaYV5AaQX5jQAwCgYIKoZIzj0EAwMw +fDELMAkGA1UEBhMCVVMxDjAMBgNVBAgTBVRleGFzMQ8wDQYDVQQHEwZBdXN0aW4x +GjAYBgNVBAoTEUFUT00gVGVjaG5vbG9naWVzMRYwFAYDVQQLEw1BVE9NIFNlY3Vy +aXR5MRgwFgYDVQQDEw9BVE9NIHJvb3QgQ0EgdjEwHhcNMjQwOTA5MTkwODM4WhcN +MzQwOTA3MTkwODM3WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECBMFVGV4YXMxDzAN +BgNVBAcTBkF1c3RpbjEaMBgGA1UEChMRQVRPTSBUZWNobm9sb2dpZXMxFjAUBgNV +BAsTDUFUT00gU2VjdXJpdHkxGDAWBgNVBAMTD0FUT00gcm9vdCBDQSB2MTB2MBAG +ByqGSM49AgEGBSuBBAAiA2IABH0eAjxr8/wDSO6EfnE574peDRuGVRr0dTvnwoMl +MilfqJDPe873y3GmzOEj0nTGB/AHPNW1HOKePYoEaK51/66peq6JOxcVIUShQOwI +U1ZdCSIDbRD0kezWXn7P/9El1aNjMGEwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFI3x7N/TGB5W9WHtVnpPqyS0jRNXMB8GA1UdIwQY +MBaAFI3x7N/TGB5W9WHtVnpPqyS0jRNXMAoGCCqGSM49BAMDA2kAMGYCMQCZvUp0 +2Zo8gDDMyC1gO+TMTNY6nfZ7XXH1SeV0BaVeBGJLhHnTWfpvkN23+/adwiMCMQD1 +p6P/cqH4SNa2P/G0nzPn21Z8SblSfGelbA+EkQf9LyNi/v8o08i4oUrB1vhWbIc= +-----END CERTIFICATE----- + +Trufo +-----BEGIN CERTIFICATE----- +MIIBmDCCAUqgAwIBAgIUYASaeSSTolrnAdi1g2Fbv7PDxJEwBQYDK2VwMEoxCzAJ +BgNVBAYTAlVTMREwDwYDVQQIDAhOZXcgWW9yazEVMBMGA1UECgwMVHJ1Zm8gKFJv +b3QpMREwDwYDVQQDDAh0cnVmby5haTAeFw0yNDA4MTIyMjE3MDdaFw0yNTA4MTIy +MjE3MDdaMEoxCzAJBgNVBAYTAlVTMREwDwYDVQQIDAhOZXcgWW9yazEVMBMGA1UE +CgwMVHJ1Zm8gKFJvb3QpMREwDwYDVQQDDAh0cnVmby5haTAqMAUGAytlcAMhABFI +CkU3vtCVG4D2VtxqAmQyKZROrBVEnFl8vpmg4CM+o0IwQDAPBgNVHRMBAf8EBTAD +AQH/MA4GA1UdDwEB/wQEAwICBDAdBgNVHQ4EFgQUXa+ujzojES7nhreHkIzbDqeL +OLkwBQYDK2VwA0EALT8wJCiGqgBqVzWf6xvus5PwAhnGx8/U3/+NIl3uFO3fUhUt +2z62xjVd+G2ivv6AZ4VnCjou757WbNqsY3B5Aw== +-----END CERTIFICATE----- + +vivo +-----BEGIN CERTIFICATE----- +MIICrjCCAhCgAwIBAgIJEJ5cSOlh/nYsMAoGCCqGSM49BAMEMHYxOTA3BgNVBAMM +MHZpdm8gQ29udGVudCBQcm92ZW5hbmNlIGFuZCBBdXRoZW50aWNpdHkgUm9vdCBD +QTELMAkGA1UEBhMCQ04xLDAqBgNVBAoMI3Zpdm8gTW9iaWxlIENvbW11bmljYXRp +b24gQ28uLCBMdGQuMCAXDTI1MDQxNjAyNTUzOFoYDzIwNTUwNDE2MDI1NTM4WjB2 +MTkwNwYDVQQDDDB2aXZvIENvbnRlbnQgUHJvdmVuYW5jZSBhbmQgQXV0aGVudGlj +aXR5IFJvb3QgQ0ExCzAJBgNVBAYTAkNOMSwwKgYDVQQKDCN2aXZvIE1vYmlsZSBD +b21tdW5pY2F0aW9uIENvLiwgTHRkLjCBmzAQBgcqhkjOPQIBBgUrgQQAIwOBhgAE +AadjySUWxUJN7q9UtkC1169XLrnhqEcOfB3AAE+uQkehChJjR8mBcTAKCGpQHxem +0qxe13rlWj8scCWExoUy4j/eAUCU1rhA9nsaNmqZuQetemoaFsxB+uzFTan7eC2K +GGUTWyEEJsVpZRnzhV1HLKHJ+gEaRCeYkEkGcxRm6Yic6HzAo0IwQDAPBgNVHRMB +Af8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUZMn3MXRQRGJUI+Jb +ij8quKQc5GEwCgYIKoZIzj0EAwQDgYsAMIGHAkE2v363BCPhkErUyhrBl5KzCrxy +dzCskvifOy2pj0DHPtE1R8iBMJL9L7SqLRiwWFtzKIDjHzrYva/XGZ3vstpcCgJC +ALYmHM4xMXsNqb1hiWIxi1gqm92ddR+PSbVIJygODlJPiDT0xPEro6kTP7GKaxpH +GQdAQ3jeFxZgws/1Fymnxrbq +-----END CERTIFICATE----- \ No newline at end of file diff --git a/tests/tmp_cert/store.cfg b/tests/tmp_cert/store.cfg new file mode 100644 index 0000000..a570a05 --- /dev/null +++ b/tests/tmp_cert/store.cfg @@ -0,0 +1,10 @@ +//id-kp-emailProtection +1.3.6.1.5.5.7.3.4 +//id-kp-documentSigning +1.3.6.1.5.5.7.3.36 +//id-kp-timeStamping +1.3.6.1.5.5.7.3.8 +//id-kp-OCSPSigning +1.3.6.1.5.5.7.3.9 +// MS C2PA Signing +1.3.6.1.4.1.311.76.59.1.9 \ No newline at end of file