afterpresets 0.2.0 → 0.4.0

package/native-runtime/src/zip.cpp

@@ -0,0 +1,243 @@
+#include "zip.hpp"
+
+#include <cctype>
+#include <cstring>
+#include <set>
+
+#include "fsutil.hpp"
+
+extern "C" {
+#include "tinf.h"
+}
+
+namespace apn {
+
+namespace {
+
+constexpr uint32_t SIG_EOCD = 0x06054b50;
+constexpr uint32_t SIG_CENTRAL = 0x02014b50;
+constexpr uint32_t SIG_LOCAL = 0x04034b50;
+
+uint16_t u16(const std::string &b, size_t p) { return (uint16_t)((uint8_t)b[p] | (uint8_t)b[p + 1] << 8); }
+uint32_t u32(const std::string &b, size_t p) {
+    return (uint32_t)(uint8_t)b[p] | (uint32_t)(uint8_t)b[p + 1] << 8 | (uint32_t)(uint8_t)b[p + 2] << 16 |
+           (uint32_t)(uint8_t)b[p + 3] << 24;
+}
+
+bool fail(ZipError &err, const std::string &message) {
+    err.message = "Invalid update archive: " + message;
+    return false;
+}
+
+std::string quoted(const std::string &s) { return "\"" + s + "\""; }
+
+// The local header must agree with the central directory (name, method, sizes,
+// CRC, no data descriptor), so no data is hidden from one extractor and visible
+// to another. The server checks the same.
+bool local_header_ok(const std::string &buf, const ZipEntry &e) {
+    size_t o = e.local_offset;
+    if ((uint64_t)o + 30 > buf.size() || u32(buf, o) != SIG_LOCAL) return false;
+    uint16_t name_len = u16(buf, o + 26);
+    if ((uint64_t)o + 30 + name_len + u16(buf, o + 28) + e.comp_size > buf.size()) return false;
+    return u16(buf, o + 8) == e.method && !(u16(buf, o + 6) & 0x0008) && u32(buf, o + 14) == e.crc &&
+           u32(buf, o + 18) == e.comp_size && u32(buf, o + 22) == e.size && buf.compare(o + 30, name_len, e.name) == 0;
+}
+
+bool ends_with(const std::string &s, const std::string &suffix) {
+    return s.size() >= suffix.size() && s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+
+}  // namespace
+
+bool zip_list(const std::string &buf, std::vector<ZipEntry> &out, ZipError &err) {
+    out.clear();
+    if (buf.size() < 22) return fail(err, "file is too small.");
+    size_t min = buf.size() > 22 + 65535 ? buf.size() - 22 - 65535 : 0;
+    size_t eocd = std::string::npos;
+    for (size_t i = buf.size() - 22 + 1; i-- > min;) {
+        if (u32(buf, i) == SIG_EOCD) { eocd = i; break; }
+    }
+    if (eocd == std::string::npos) return fail(err, "end of central directory not found.");
+    uint16_t count = u16(buf, eocd + 10);
+    uint32_t cd_size = u32(buf, eocd + 12);
+    uint32_t cd_offset = u32(buf, eocd + 16);
+    if (count == 0xFFFF || cd_size == 0xFFFFFFFF || cd_offset == 0xFFFFFFFF) return fail(err, "ZIP64 is not supported.");
+    if ((uint64_t)cd_offset + cd_size > eocd) return fail(err, "central directory out of range.");
+    if (count > ZipLimits::MAX_ENTRIES) return fail(err, "more than " + std::to_string(ZipLimits::MAX_ENTRIES) + " entries.");
+    uint64_t total = 0;
+    size_t p = cd_offset;
+    for (uint16_t i = 0; i < count; i++) {
+        if (p + 46 > buf.size() || u32(buf, p) != SIG_CENTRAL) return fail(err, "bad central directory entry.");
+        uint16_t made_by = u16(buf, p + 4);
+        uint16_t flags = u16(buf, p + 8);
+        ZipEntry e;
+        e.method = u16(buf, p + 10);
+        e.crc = u32(buf, p + 16);
+        e.comp_size = u32(buf, p + 20);
+        e.size = u32(buf, p + 24);
+        uint16_t name_len = u16(buf, p + 28);
+        uint16_t extra_len = u16(buf, p + 30);
+        uint16_t comment_len = u16(buf, p + 32);
+        uint32_t ext_attr = u32(buf, p + 38);
+        e.local_offset = u32(buf, p + 42);
+        if (p + 46 + name_len > buf.size()) return fail(err, "entry name out of range.");
+        e.name = buf.substr(p + 46, name_len);
+        p += 46 + (size_t)name_len + extra_len + comment_len;
+        if (flags & (0x0001 | 0x0040)) return fail(err, "encrypted entries are not supported (" + e.name + ").");
+        if (flags & 0x0008) return fail(err, "data descriptors are not supported (" + e.name + ").");
+        if (e.comp_size == 0xFFFFFFFF || e.size == 0xFFFFFFFF || e.local_offset == 0xFFFFFFFF) {
+            return fail(err, "ZIP64 is not supported.");
+        }
+        uint32_t unix_mode = (ext_attr >> 16) & 0xF000;
+        bool unix_host = (made_by >> 8) == 3;
+        if (unix_host && unix_mode == 0xA000) return fail(err, "symbolic links are not allowed (" + e.name + ").");
+        // Only regular files and folders (a mode of 0 means "not recorded").
+        if (unix_host && unix_mode != 0 && unix_mode != 0x8000 && unix_mode != 0x4000) {
+            return fail(err, "special files are not allowed (" + e.name + ").");
+        }
+        if (e.method != 0 && e.method != 8) {
+            return fail(err, "unsupported compression method " + std::to_string(e.method) + " (" + e.name + ").");
+        }
+        e.is_directory = !e.name.empty() && e.name.back() == '/';
+        e.executable = unix_host && ((ext_attr >> 16) & 0111) != 0;
+        if (e.method == 0 && e.comp_size != e.size) return fail(err, "stored size does not match (" + e.name + ").");
+        if (e.size > ZipLimits::MAX_ENTRY_BYTES) return fail(err, e.name + " is too large.");
+        if (e.is_directory && e.size != 0) return fail(err, "folder entry with data (" + e.name + ").");
+        total += e.size;
+        if (total > ZipLimits::MAX_TOTAL_BYTES) return fail(err, "the archive unpacks to more than 400 MB.");
+        if (!local_header_ok(buf, e)) return fail(err, "local header does not match the central directory (" + e.name + ").");
+        out.push_back(std::move(e));
+    }
+    return true;
+}
+
+bool zip_read(const std::string &buf, const ZipEntry &e, std::string &out, ZipError &err) {
+    size_t o = e.local_offset;
+    if ((uint64_t)o + 30 > buf.size() || u32(buf, o) != SIG_LOCAL) return fail(err, "bad local header (" + e.name + ").");
+    if (!local_header_ok(buf, e)) return fail(err, "local header does not match the central directory (" + e.name + ").");
+    uint16_t local_name_len = u16(buf, o + 26);
+    uint64_t start = (uint64_t)o + 30 + local_name_len + u16(buf, o + 28);
+    uint64_t end = start + e.comp_size;
+    if (end > buf.size()) return fail(err, "entry data out of range (" + e.name + ").");
+    if (e.method == 0) {
+        out.assign(buf, (size_t)start, e.comp_size);
+    } else {
+        out.assign(e.size, '\0');
+        unsigned int dest_len = e.size;
+        // tinf never writes past dest_len; a stream that wants more is a data error.
+        int res = tinf_uncompress(e.size ? &out[0] : nullptr, &dest_len, buf.data() + start, e.comp_size);
+        if (res != TINF_OK) return fail(err, "corrupt data (" + e.name + ").");
+        out.resize(dest_len);
+    }
+    if (out.size() != e.size) return fail(err, "size mismatch (" + e.name + ").");
+    if (tinf_crc32(out.data(), (unsigned int)out.size()) != e.crc && !(out.empty() && e.crc == 0)) {
+        return fail(err, "CRC mismatch (" + e.name + ").");
+    }
+    return true;
+}
+
+std::optional<std::vector<std::string>> zip_entry_parts(const std::string &name, ZipError &err) {
+    if (name.empty() || name.size() > ZipLimits::MAX_NAME_BYTES) { fail(err, "empty or overlong entry name."); return std::nullopt; }
+    for (unsigned char c : name) {
+        if (c < 0x20 || c > 0x7e) { fail(err, "non-ASCII or control characters in an entry name."); return std::nullopt; }
+    }
+    if (name.find('\\') != std::string::npos || name.find('\0') != std::string::npos) {
+        fail(err, "illegal characters in " + quoted(name) + ".");
+        return std::nullopt;
+    }
+    if (name[0] == '/' || (name.size() >= 2 && std::isalpha((unsigned char)name[0]) && name[1] == ':')) {
+        fail(err, "absolute path " + quoted(name) + ".");
+        return std::nullopt;
+    }
+    std::string trimmed = name.back() == '/' ? name.substr(0, name.size() - 1) : name;
+    std::vector<std::string> parts;
+    size_t start = 0;
+    for (;;) {
+        size_t slash = trimmed.find('/', start);
+        parts.push_back(trimmed.substr(start, slash == std::string::npos ? std::string::npos : slash - start));
+        if (slash == std::string::npos) break;
+        start = slash + 1;
+    }
+    for (const auto &part : parts) {
+        if (part.empty() || part == "." || part == ".." || part.find_first_of("<>:\"|?*") != std::string::npos ||
+            part.back() == '.' || part.back() == ' ') {
+            fail(err, "unsafe path " + quoted(name) + ".");
+            return std::nullopt;
+        }
+    }
+    return parts;
+}
+
+bool zip_extract_plugin(const std::string &archive, const std::string &os, const std::string &dest_dir,
+                        std::string &plugin_name, ZipError &err, uint64_t max_total) {
+    std::vector<ZipEntry> entries;
+    if (!zip_list(archive, entries, err)) return false;
+    bool mac = os == "macos";
+    std::set<std::string> candidates;  // root plugin names for this OS
+    std::vector<std::vector<std::string>> parts(entries.size());
+    for (size_t i = 0; i < entries.size(); i++) {
+        auto p = zip_entry_parts(entries[i].name, err);
+        if (!p) return false;  // one unsafe name refuses the whole archive
+        parts[i] = *p;
+        const std::string &top = parts[i][0];
+        std::string lower_top = top;
+        for (auto &c : lower_top) c = (char)std::tolower((unsigned char)c);
+        if (mac && ends_with(lower_top, ".plugin") && top.size() > 7 && parts[i].size() >= 4 &&
+            parts[i][1] == "Contents" && parts[i][2] == "MacOS" && !entries[i].is_directory) {
+            candidates.insert(top);
+        }
+        if (!mac && parts[i].size() == 1 && !entries[i].is_directory && ends_with(lower_top, ".aex") && top.size() > 4) {
+            candidates.insert(top);
+        }
+    }
+    if (candidates.size() != 1) {
+        std::string what = mac ? "<Name>.plugin/Contents/MacOS/<binary>" : "<Name>.aex";
+        return fail(err, candidates.empty() ? "no " + what + " at the top level."
+                                            : "more than one " + what + " at the top level.");
+    }
+    plugin_name = *candidates.begin();
+    struct Item {
+        size_t index;
+        std::string rel;  // path below dest_dir, '/'-separated
+    };
+    std::vector<Item> plan;
+    std::set<std::string> seen;
+    uint64_t total = 0;
+    for (size_t i = 0; i < entries.size(); i++) {
+        if (parts[i][0] != plugin_name) continue;  // installers, readme, the other OS's plugin
+        std::string rel;
+        for (size_t k = 0; k < parts[i].size(); k++) rel += (k ? "/" : "") + parts[i][k];
+        std::string folded = rel;
+        for (auto &c : folded) c = (char)std::tolower((unsigned char)c);
+        // Case-insensitive duplicates would overwrite each other on APFS/NTFS.
+        if (!entries[i].is_directory && !seen.insert(folded).second) return fail(err, "duplicate entry " + quoted(entries[i].name) + ".");
+        total += entries[i].size;
+        if (total > max_total) return fail(err, "too large.");
+        plan.push_back({i, rel});
+    }
+    // Decompress and verify everything before writing anything.
+    std::vector<std::string> data(plan.size());
+    for (size_t k = 0; k < plan.size(); k++) {
+        if (entries[plan[k].index].is_directory) continue;
+        if (!zip_read(archive, entries[plan[k].index], data[k], err)) return false;
+    }
+    if (!fsu::mkdirs(dest_dir)) return fail(err, "cannot create the staging folder.");
+    for (size_t k = 0; k < plan.size(); k++) {
+        std::string target = dest_dir;
+        for (const auto &part : parts[plan[k].index]) target = fsu::join(target, part);
+        const ZipEntry &e = entries[plan[k].index];
+        if (e.is_directory) {
+            if (!fsu::mkdirs(target)) return fail(err, "cannot create " + plan[k].rel + ".");
+            continue;
+        }
+        // The plugin's own executable keeps its x bit; on macOS everything in
+        // Contents/MacOS is executable even if the archiver dropped the mode.
+        const auto &p = parts[plan[k].index];
+        bool exec = e.executable || (mac && p.size() >= 4 && p[1] == "Contents" && p[2] == "MacOS");
+        if (!fsu::write_file(target, data[k], exec)) return fail(err, "cannot write " + plan[k].rel + ".");
+    }
+    return true;
+}
+
+}  // namespace apn

package/native-runtime/src/zip.hpp

@@ -0,0 +1,58 @@
+// Minimal ZIP reader for signed update archives (port of packages/runtime/src/zip.js).
+// Stored and deflate entries; refuses ZIP64, encryption, symlinks, CRC/size
+// mismatches and unsafe paths.
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace apn {
+
+struct ZipEntry {
+    std::string name;
+    bool is_directory = false;
+    bool executable = false;  // POSIX x bit in the external attributes
+    uint16_t method = 0;
+    uint32_t crc = 0;
+    uint32_t comp_size = 0;
+    uint32_t size = 0;
+    uint32_t local_offset = 0;
+};
+
+// Limits and rules mirror the server's release check
+// (apps/api/src/lib/developer-platform/native-release.ts), as defence in depth.
+struct ZipLimits {
+    static constexpr size_t MAX_ENTRIES = 1000;
+    static constexpr uint64_t MAX_ENTRY_BYTES = 128ULL * 1024 * 1024;
+    static constexpr uint64_t MAX_TOTAL_BYTES = 400ULL * 1024 * 1024;
+    static constexpr size_t MAX_NAME_BYTES = 255;
+};
+
+struct ZipError {
+    std::string message;
+};
+
+// Parses the central directory. On failure returns false and fills err.
+bool zip_list(const std::string &archive, std::vector<ZipEntry> &out, ZipError &err);
+// Decompresses one entry and checks its size and CRC.
+bool zip_read(const std::string &archive, const ZipEntry &entry, std::string &out, ZipError &err);
+
+// Splits and validates an entry name like the server: printable ASCII only,
+// at most 255 bytes, no absolute paths, "..", ".", empty parts, backslashes,
+// and no segment Windows cannot store (<>:"|?* or a trailing dot/space).
+std::optional<std::vector<std::string>> zip_entry_parts(const std::string &name, ZipError &err);
+
+// The release ZIP contract (docs/native-runtime-design.md, "Release ZIP"): at
+// its root <Name>.plugin/ (macOS), <Name>.aex (Windows), mac-install.command,
+// windows-install.bat, readme.txt. Extracts ONLY this OS's plugin into
+// dest_dir (dest_dir/<Name>.plugin or dest_dir/<Name>.aex) after validating
+// every entry of the archive and decompressing the chosen entries in memory
+// first, so a corrupt or unsafe archive writes nothing. Exactly one plugin for
+// the OS must be present. os: "macos" | "windows". plugin_name receives
+// "<Name>.plugin" / "<Name>.aex".
+bool zip_extract_plugin(const std::string &archive, const std::string &os, const std::string &dest_dir,
+                        std::string &plugin_name, ZipError &err, uint64_t max_total = ZipLimits::MAX_TOTAL_BYTES);
+
+}  // namespace apn

package/native-runtime/third_party/monocypher/LICENCE.md

@@ -0,0 +1,167 @@
+Monocypher as a whole is dual-licensed.  Choose whichever licence you
+want from the two licences listed below.
+
+The first licence is a regular 2-clause BSD licence.  The second licence
+is the CC-0 from Creative Commons. It is intended to release Monocypher
+to the public domain.  The BSD licence serves as a fallback option.
+
+See the individual files for specific information about who contributed
+to what file during which years.  See below for special notes.
+
+Licence 1 (2-clause BSD)
+------------------------
+
+Copyright (c) 2017-2023, Loup Vaillant
+Copyright (c) 2017-2019, Michael Savage
+Copyright (c) 2017-2023, Fabio Scotoni
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the
+   distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Licence 2 (CC-0)
+----------------
+
+> CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+> LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+> ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+> INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+> REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+> PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+> THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+> HEREUNDER.
+
+### Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work
+of authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without
+fear of later claims of infringement build upon, modify, incorporate in
+other works, reuse and redistribute as freely as possible in any form
+whatsoever and for any purposes, including without limitation commercial
+purposes. These owners may contribute to the Commons to promote the
+ideal of a free culture and the further production of creative, cultural
+and scientific works, or to gain reputation or greater distribution for
+their Work in part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or
+she is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under
+its terms, with knowledge of his or her Copyright and Related Rights in
+the Work and the meaning and intended legal effect of CC0 on those
+rights.
+
+1. **Copyright and Related Rights.** A Work made available under CC0 may
+   be protected by copyright and related or neighboring rights
+   ("Copyright and Related Rights"). Copyright and Related Rights
+   include, but are not limited to, the following:
+
+   - the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+   - moral rights retained by the original author(s) and/or
+     performer(s); publicity and privacy rights pertaining to a person's
+     image or likeness depicted in a Work;
+   - rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+   - rights protecting the extraction, dissemination, use and reuse of
+     data in a Work;
+   - database rights (such as those arising under Directive 96/9/EC of
+     the European Parliament and of the Council of 11 March 1996 on the
+     legal protection of databases, and under any national
+     implementation thereof, including any amended or successor version
+     of such directive); and
+   - other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. **Waiver.** To the greatest extent permitted by, but not in
+   contravention of, applicable law, Affirmer hereby overtly, fully,
+   permanently, irrevocably and unconditionally waives, abandons, and
+   surrenders all of Affirmer's Copyright and Related Rights and
+   associated claims and causes of action, whether now known or unknown
+   (including existing as well as future claims and causes of action),
+   in the Work (i) in all territories worldwide, (ii) for the maximum
+   duration provided by applicable law or treaty (including future time
+   extensions), (iii) in any current or future medium and for any number
+   of copies, and (iv) for any purpose whatsoever, including without
+   limitation commercial, advertising or promotional purposes (the
+   "Waiver"). Affirmer makes the Waiver for the benefit of each member
+   of the public at large and to the detriment of Affirmer's heirs and
+   successors, fully intending that such Waiver shall not be subject to
+   revocation, rescission, cancellation, termination, or any other legal
+   or equitable action to disrupt the quiet enjoyment of the Work by the
+   public as contemplated by Affirmer's express Statement of Purpose.
+
+3. **Public License Fallback.** Should any part of the Waiver for any
+   reason be judged legally invalid or ineffective under applicable law,
+   then the Waiver shall be preserved to the maximum extent permitted
+   taking into account Affirmer's express Statement of Purpose. In
+   addition, to the extent the Waiver is so judged Affirmer hereby
+   grants to each affected person a royalty-free, non transferable, non
+   sublicensable, non exclusive, irrevocable and unconditional license
+   to exercise Affirmer's Copyright and Related Rights in the Work (i)
+   in all territories worldwide, (ii) for the maximum duration provided
+   by applicable law or treaty (including future time extensions), (iii)
+   in any current or future medium and for any number of copies, and
+   (iv) for any purpose whatsoever, including without limitation
+   commercial, advertising or promotional purposes (the "License"). The
+   License shall be deemed effective as of the date CC0 was applied by
+   Affirmer to the Work. Should any part of the License for any reason
+   be judged legally invalid or ineffective under applicable law, such
+   partial invalidity or ineffectiveness shall not invalidate the
+   remainder of the License, and in such case Affirmer hereby affirms
+   that he or she will not (i) exercise any of his or her remaining
+   Copyright and Related Rights in the Work or (ii) assert any
+   associated claims and causes of action with respect to the Work, in
+   either case contrary to Affirmer's express Statement of Purpose.
+
+4. **Limitations and Disclaimers.**
+
+   - No trademark or patent rights held by Affirmer are waived,
+     abandoned, surrendered, licensed or otherwise affected by this
+     document.
+   - Affirmer offers the Work as-is and makes no representations or
+     warranties of any kind concerning the Work, express, implied,
+     statutory or otherwise, including without limitation warranties of
+     title, merchantability, fitness for a particular purpose, non
+     infringement, or the absence of latent or other defects, accuracy,
+     or the present or absence of errors, whether or not discoverable,
+     all to the greatest extent permissible under applicable law.
+   - Affirmer disclaims responsibility for clearing rights of other
+     persons that may apply to the Work or any use thereof, including
+     without limitation any person's Copyright and Related Rights in the
+     Work. Further, Affirmer disclaims responsibility for obtaining any
+     necessary consents, permissions or other rights required for any
+     use of the Work.
+   - Affirmer understands and acknowledges that Creative Commons is not
+     a party to this document and has no duty or obligation with respect
+     to this CC0 or use of the Work.