privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-EUEPIW4S.mjs

@@ -0,0 +1,574 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  HashAlgorithms,
+  Uint8ArrayToBase64,
+  Uint8ArrayToHex,
+  Uint8ArrayToString,
+  base64ToUint8Array,
+  canonicalize,
+  hexToUint8Array,
+  importKey,
+  stringToUint8Array,
+  verifySignature
+} from "./c-U4ITOXAN.mjs";
+import "./c-4WVR32AP.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@freedomofpress/tuf-browser/dist/crypto.js
+function getRoleKeys(keys, keyids) {
+  const roleKeys = new Map(keys);
+  for (const key of keys.keys()) {
+    if (!keyids.includes(key)) {
+      roleKeys.delete(key);
+    }
+  }
+  return roleKeys;
+}
+__name(getRoleKeys, "getRoleKeys");
+async function loadKeys(keys) {
+  const importedKeys = /* @__PURE__ */ new Map();
+  for (const keyId in keys) {
+    const key = keys[keyId];
+    const canonicalBytes = stringToUint8Array(canonicalize(key));
+    const verified_keyId = Uint8ArrayToHex(new Uint8Array(await crypto.subtle.digest(HashAlgorithms.SHA256, canonicalBytes)));
+    if (importedKeys.has(verified_keyId)) {
+      throw new Error("Duplicate keyId found!");
+    }
+    if (verified_keyId !== keyId) {
+      console.warn(`KeyId ${keyId} does not match the expected ${verified_keyId}, importing anyway the provided one for proper referencing.`);
+    }
+    importedKeys.set(keyId, await importKey(key.keytype, key.scheme, key.keyval.public));
+  }
+  return importedKeys;
+}
+__name(loadKeys, "loadKeys");
+async function checkSignatures(keys, roleKeys, signed, signatures, threshold) {
+  if (threshold < 1) {
+    throw new Error("Threshold must be at least 1");
+  }
+  if (threshold > keys.size) {
+    throw new Error("Threshold is bigger than the number of keys provided, something is wrong.");
+  }
+  const keyIds = new Set(roleKeys);
+  const signed_canon = canonicalize(signed);
+  let valid_signatures = 0;
+  for (const signature of signatures) {
+    if (!keyIds.has(signature.keyid)) {
+      continue;
+    }
+    keyIds.delete(signature.keyid);
+    const key = keys.get(signature.keyid);
+    const sig = hexToUint8Array(signature.sig);
+    if (!key) {
+      throw new Error("Keyid was empty.");
+    }
+    if (await verifySignature(key, stringToUint8Array(signed_canon), sig) === true) {
+      valid_signatures++;
+    }
+  }
+  if (valid_signatures >= threshold) {
+    return true;
+  } else {
+    return false;
+  }
+}
+__name(checkSignatures, "checkSignatures");
+
+// node_modules/@freedomofpress/tuf-browser/dist/storage/encoding.js
+function isRawBytesWrapper(value) {
+  return value != null && typeof value === "object" && "__raw_bytes__" in value && // eslint-disable-next-line
+  typeof value.__raw_bytes__ === "string";
+}
+__name(isRawBytesWrapper, "isRawBytesWrapper");
+function decodeRawBytesWrapper(wrapper) {
+  const bytes = base64ToUint8Array(wrapper.__raw_bytes__);
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+__name(decodeRawBytesWrapper, "decodeRawBytesWrapper");
+function createRawBytesWrapper(value) {
+  return { __raw_bytes__: Uint8ArrayToBase64(value) };
+}
+__name(createRawBytesWrapper, "createRawBytesWrapper");
+
+// node_modules/@freedomofpress/tuf-browser/dist/storage/browser.js
+var ExtensionStorageBackend = class {
+  static {
+    __name(this, "ExtensionStorageBackend");
+  }
+  async read(key) {
+    const result = await browser.storage.local.get(key);
+    const value = result[key];
+    if (isRawBytesWrapper(value)) {
+      return decodeRawBytesWrapper(value);
+    }
+    return value;
+  }
+  async write(key, value) {
+    await browser.storage.local.set({ [key]: value });
+  }
+  async writeRaw(key, value) {
+    await browser.storage.local.set({ [key]: createRawBytesWrapper(value) });
+  }
+  async delete(key) {
+    await browser.storage.local.remove(key);
+  }
+};
+
+// node_modules/@freedomofpress/tuf-browser/dist/storage/localstorage.js
+var LocalStorageBackend = class {
+  static {
+    __name(this, "LocalStorageBackend");
+  }
+  async read(key) {
+    const value = localStorage.getItem(key);
+    if (value) {
+      const parsed = JSON.parse(value);
+      if (isRawBytesWrapper(parsed)) {
+        return decodeRawBytesWrapper(parsed);
+      }
+      return parsed;
+    }
+  }
+  async write(key, value) {
+    localStorage.setItem(key, JSON.stringify(value));
+  }
+  async writeRaw(key, value) {
+    localStorage.setItem(key, JSON.stringify(createRawBytesWrapper(value)));
+  }
+  async delete(key) {
+    localStorage.removeItem(key);
+  }
+};
+
+// node_modules/@freedomofpress/tuf-browser/dist/storage/memory.js
+var MemoryBackend = class {
+  static {
+    __name(this, "MemoryBackend");
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  async read(key) {
+    const value = this.cache.get(key);
+    if (!value)
+      return void 0;
+    if (isRawBytesWrapper(value)) {
+      return decodeRawBytesWrapper(value);
+    }
+    return value;
+  }
+  async write(key, value) {
+    this.cache.set(key, value);
+  }
+  async writeRaw(key, value) {
+    this.cache.set(key, createRawBytesWrapper(value));
+  }
+  async delete(key) {
+    this.cache.delete(key);
+  }
+};
+
+// node_modules/@freedomofpress/tuf-browser/dist/types.js
+var Roles;
+(function(Roles2) {
+  Roles2["Root"] = "root";
+  Roles2["Timestamp"] = "timestamp";
+  Roles2["Snapshot"] = "snapshot";
+  Roles2["Targets"] = "targets";
+})(Roles || (Roles = {}));
+var TOP_LEVEL_ROLE_NAMES = [
+  Roles.Root,
+  Roles.Targets,
+  Roles.Snapshot,
+  Roles.Timestamp
+];
+
+// node_modules/@freedomofpress/tuf-browser/dist/tuf.js
+var TUFClient = class {
+  static {
+    __name(this, "TUFClient");
+  }
+  constructor(repositoryUrl, startingRoot, namespace, targetBaseUrl, options) {
+    this.repositoryUrl = repositoryUrl;
+    this.targetBaseUrl = targetBaseUrl || repositoryUrl;
+    this.startingRoot = startingRoot;
+    this.namespace = namespace;
+    if (options?.backend) {
+      this.backend = options.backend;
+    } else if (options?.disableCache) {
+      this.backend = new MemoryBackend();
+    } else if (typeof browser !== "undefined" && browser.storage?.local) {
+      this.backend = new ExtensionStorageBackend();
+    } else if (typeof localStorage !== "undefined") {
+      this.backend = new LocalStorageBackend();
+    } else {
+      this.backend = new MemoryBackend();
+    }
+  }
+  getCacheKey(key) {
+    if (key.startsWith("/") || key.startsWith("./") || key.includes("..") || key.includes("\\")) {
+      throw new Error(`key contains an invalid pattern (${key})`);
+    }
+    return `${this.namespace}/${key}.json`;
+  }
+  async getFromCache(key) {
+    const namespacedKey = this.getCacheKey(key);
+    return await this.backend.read(namespacedKey);
+  }
+  async setInCache(key, value) {
+    const namespacedKey = this.getCacheKey(key);
+    await this.backend.write(namespacedKey, value);
+  }
+  async fetchMetafileBase(role, version, target = false) {
+    let url;
+    role = encodeURIComponent(role);
+    if (!target) {
+      url = version !== -1 ? `${this.repositoryUrl}${version}.${role}.json` : `${this.repositoryUrl}${role}.json`;
+    } else {
+      url = `${this.repositoryUrl}${version}.${role}`;
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch file: ${response.status} ${response.statusText}`);
+    }
+    return response;
+  }
+  validateMetadata(metadata) {
+    const seenKeyIds = /* @__PURE__ */ new Set();
+    for (const sig of metadata.signatures) {
+      if (seenKeyIds.has(sig.keyid)) {
+        throw new Error(`Duplicate signature found for keyid: ${sig.keyid}`);
+      }
+      seenKeyIds.add(sig.keyid);
+    }
+    const specVersion = metadata.signed.spec_version;
+    if (!specVersion) {
+      throw new Error("spec_version is required");
+    }
+    const parts = specVersion.split(".");
+    if (parts.length < 2 || parts.length > 3) {
+      throw new Error(`Invalid spec_version format: ${specVersion}`);
+    }
+    if (!parts.every((p) => /^\d+$/.test(p))) {
+      throw new Error(`spec_version parts must be numeric: ${specVersion}`);
+    }
+    if (parts[0] !== "1") {
+      throw new Error(`Unsupported spec_version major version: ${parts[0]} (expected 1)`);
+    }
+  }
+  async fetchMetafileJson(role, version = -1) {
+    const response = await this.fetchMetafileBase(role, version);
+    const metadata = await response.json();
+    this.validateMetadata(metadata);
+    return metadata;
+  }
+  async fetchMetafileBinary(role, version = -1, target = false) {
+    const response = await this.fetchMetafileBase(role, version, target);
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  bootstrapRoot(file) {
+    try {
+      const metadata = JSON.parse(file);
+      this.validateMetadata(metadata);
+      return metadata;
+    } catch (error) {
+      throw new Error(`Failed to load the JSON file:  ${error}`);
+    }
+  }
+  async verifyHashes(data, hashes, context) {
+    if (!hashes)
+      return;
+    const hashAlgoMap = {
+      sha256: HashAlgorithms.SHA256,
+      sha384: HashAlgorithms.SHA384,
+      sha512: HashAlgorithms.SHA512
+    };
+    for (const [algo, expectedHash] of Object.entries(hashes)) {
+      const cryptoAlgo = hashAlgoMap[algo];
+      if (!cryptoAlgo) {
+        throw new Error(`${context}: unsupported hash algorithm '${algo}'`);
+      }
+      const computedHash = Uint8ArrayToHex(new Uint8Array(await crypto.subtle.digest(cryptoAlgo, data)));
+      if (expectedHash !== computedHash) {
+        throw new Error(`${context}: ${algo} hash mismatch`);
+      }
+    }
+  }
+  // This function supports ECDSA (256, 385, 521), Ed25519 in Hex or PEM format
+  // it is possible to support certain cases of RSA, but it is not really useful for now
+  // Returns a mapping keyid (hexstring) -> CryptoKey object
+  async loadRoot(json, oldroot) {
+    if (json.signed._type !== Roles.Root) {
+      throw new Error("Loading the wrong metafile as root.");
+    }
+    let keys;
+    let threshold;
+    let roleKeys;
+    if (oldroot == void 0) {
+      keys = await loadKeys(json.signed.keys);
+      roleKeys = json.signed.roles.root.keyids;
+      threshold = json.signed.roles.root.threshold;
+    } else {
+      keys = oldroot.keys;
+      roleKeys = oldroot.roles["root"].keyids;
+      threshold = oldroot.threshold;
+    }
+    if (await checkSignatures(keys, roleKeys, json.signed, json.signatures, threshold) !== true) {
+      throw new Error("Failed to verify metafile.");
+    }
+    keys = await loadKeys(json.signed.keys);
+    if (!Number.isSafeInteger(json.signed.version) || json.signed.version < 1) {
+      throw new Error("There is something wrong with the root version number.");
+    }
+    for (const role of TOP_LEVEL_ROLE_NAMES) {
+      if (!json.signed.roles[role]) {
+        throw new Error(`Missing required top-level role: ${role}`);
+      }
+    }
+    for (const [roleName, role] of Object.entries(json.signed.roles)) {
+      const keyidSet = new Set(role.keyids);
+      if (keyidSet.size !== role.keyids.length) {
+        throw new Error(`Duplicate key IDs found in role: ${roleName}`);
+      }
+    }
+    return {
+      keys,
+      version: json.signed.version,
+      expires: new Date(json.signed.expires),
+      threshold: json.signed.roles.root.threshold,
+      consistent_snapshot: json.signed.consistent_snapshot,
+      roles: json.signed.roles
+    };
+  }
+  async updateRoot(frozenTimestamp) {
+    let rootJson = await this.getFromCache(Roles.Root);
+    if (!rootJson) {
+      rootJson = await this.bootstrapRoot(this.startingRoot);
+    }
+    let root = await this.loadRoot(rootJson);
+    const oldRoot = root;
+    let newroot;
+    let newrootJson;
+    for (let new_version = root.version + 1; new_version < Number.MAX_SAFE_INTEGER; new_version++) {
+      try {
+        newrootJson = await this.fetchMetafileJson(Roles.Root, new_version);
+      } catch (e) {
+        if (e instanceof Error && e.message.includes("Failed to fetch")) {
+          break;
+        }
+        throw e;
+      }
+      if (newrootJson.signed.version !== new_version) {
+        throw new Error(`Version mismatch: URL version ${new_version} but file contains version ${newrootJson.signed.version}`);
+      }
+      if (newrootJson.signed?._type !== Roles.Root) {
+        throw new Error("Incorrect metadata type for root.");
+      }
+      newroot = await this.loadRoot(newrootJson, root);
+      if (newroot.version !== root.version + 1) {
+        throw new Error(`Root version must be exactly ${root.version + 1}, got ${newroot.version}. Probable rollback attack.`);
+      }
+      newroot = await this.loadRoot(newrootJson);
+      root = newroot;
+      await this.setInCache(Roles.Root, newrootJson);
+    }
+    if (root.expires <= frozenTimestamp) {
+      throw new Error("Freeze attack on the root metafile.");
+    }
+    if (root.version > oldRoot.version) {
+      const timestampKeysChanged = JSON.stringify(root.roles.timestamp.keyids.sort()) !== JSON.stringify(oldRoot.roles.timestamp.keyids.sort());
+      const snapshotKeysChanged = JSON.stringify(root.roles.snapshot.keyids.sort()) !== JSON.stringify(oldRoot.roles.snapshot.keyids.sort());
+      const targetsKeysChanged = JSON.stringify(root.roles.targets.keyids.sort()) !== JSON.stringify(oldRoot.roles.targets.keyids.sort());
+      if (timestampKeysChanged) {
+        await this.backend.delete(this.getCacheKey(Roles.Timestamp));
+        await this.backend.delete(this.getCacheKey(Roles.Snapshot));
+        await this.backend.delete(this.getCacheKey(Roles.Targets));
+      }
+      if (snapshotKeysChanged) {
+        await this.backend.delete(this.getCacheKey(Roles.Snapshot));
+        await this.backend.delete(this.getCacheKey(Roles.Targets));
+      }
+      if (targetsKeysChanged) {
+        await this.backend.delete(this.getCacheKey(Roles.Targets));
+      }
+    }
+    return root;
+  }
+  async updateTimestamp(root, frozenTimestamp) {
+    const keys = getRoleKeys(root.keys, root.roles.timestamp.keyids);
+    if (keys.size < 1) {
+      throw new Error("No valid keys found for the timestamp role.");
+    }
+    const cachedTimestamp = await this.getFromCache(Roles.Timestamp);
+    const newTimestampRaw = await this.fetchMetafileBinary(Roles.Timestamp, -1);
+    const newTimestamp = JSON.parse(Uint8ArrayToString(newTimestampRaw));
+    this.validateMetadata(newTimestamp);
+    if (newTimestamp.signed._type !== Roles.Timestamp) {
+      throw new Error(`Invalid metadata type: expected ${Roles.Timestamp}, got ${newTimestamp.signed._type}`);
+    }
+    if (!newTimestamp.signed.meta || !newTimestamp.signed.meta["snapshot.json"]) {
+      throw new Error("Timestamp metadata missing required meta['snapshot.json']");
+    }
+    if (await checkSignatures(keys, root.roles["timestamp"].keyids, newTimestamp.signed, newTimestamp.signatures, root.roles.timestamp.threshold) !== true) {
+      throw new Error("Failed verifying timestamp role signature(s).");
+    }
+    if (cachedTimestamp !== void 0) {
+      if (newTimestamp.signed.version < cachedTimestamp.signed.version) {
+        throw new Error("New timestamp file has a lower version that the currently cached one.");
+      }
+      if (newTimestamp.signed.version == cachedTimestamp.signed.version) {
+        return null;
+      }
+      if (newTimestamp.signed.meta["snapshot.json"].version < cachedTimestamp.signed.meta["snapshot.json"].version) {
+        throw new Error("Timestamp has been updated, but snapshot version has been rolled back.");
+      }
+    }
+    if (new Date(newTimestamp.signed.expires) <= frozenTimestamp) {
+      throw new Error("Freeze attack on the timestamp metafile.");
+    }
+    await this.backend.writeRaw(this.getCacheKey(Roles.Timestamp), newTimestampRaw);
+    return newTimestamp;
+  }
+  async updateSnapshot(root, frozenTimestamp, timestampMeta) {
+    const version = timestampMeta.signed.meta["snapshot.json"].version;
+    const keys = getRoleKeys(root.keys, root.roles.snapshot.keyids);
+    const cachedSnapshot = await this.getFromCache(Roles.Snapshot);
+    let newSnapshotRaw;
+    if (root.consistent_snapshot) {
+      newSnapshotRaw = await this.fetchMetafileBinary(Roles.Snapshot, version);
+    } else {
+      newSnapshotRaw = await this.fetchMetafileBinary(Roles.Snapshot, -1);
+    }
+    const snapshotMeta = timestampMeta.signed.meta["snapshot.json"];
+    if (snapshotMeta.length !== void 0) {
+      if (newSnapshotRaw.length !== snapshotMeta.length) {
+        throw new Error(`Snapshot length mismatch: expected ${snapshotMeta.length}, got ${newSnapshotRaw.length}`);
+      }
+    }
+    await this.verifyHashes(newSnapshotRaw, snapshotMeta.hashes, "Snapshot");
+    const newSnapshot = JSON.parse(Uint8ArrayToString(newSnapshotRaw));
+    this.validateMetadata(newSnapshot);
+    if (newSnapshot.signed._type !== Roles.Snapshot) {
+      throw new Error(`Invalid metadata type: expected ${Roles.Snapshot}, got ${newSnapshot.signed._type}`);
+    }
+    if (!newSnapshot.signed.meta || !newSnapshot.signed.meta["targets.json"]) {
+      throw new Error("Snapshot metadata missing required meta['targets.json']");
+    }
+    if (await checkSignatures(keys, root.roles["snapshot"].keyids, newSnapshot.signed, newSnapshot.signatures, root.roles.snapshot.threshold) !== true) {
+      throw new Error("Failed verifying snapshot role signature(s).");
+    }
+    if (newSnapshot.signed.version !== version) {
+      throw new Error(`Snapshot version mismatch: URL version ${version} but file contains version ${newSnapshot.signed.version}`);
+    }
+    if (cachedSnapshot !== void 0) {
+      for (const [target] of Object.entries(cachedSnapshot.signed.meta)) {
+        if (target in newSnapshot.signed.meta !== true) {
+          throw new Error("Target that was listed in an older snapshot was dropped in a newer one.");
+        }
+        if (newSnapshot.signed.meta[target].version < cachedSnapshot.signed.meta[target].version) {
+          throw new Error("Target version in newer snapshot is lower than the cached one. Probable rollback attack.");
+        }
+      }
+    }
+    if (new Date(newSnapshot.signed.expires) <= frozenTimestamp) {
+      throw new Error("Freeze attack on the snapshot metafile.");
+    }
+    await this.backend.writeRaw(this.getCacheKey(Roles.Snapshot), newSnapshotRaw);
+    return newSnapshot.signed.meta;
+  }
+  async updateTargets(root, frozenTimestamp, snapshot) {
+    const keys = getRoleKeys(root.keys, root.roles.targets.keyids);
+    const cachedTargets = await this.getFromCache(Roles.Targets);
+    let newTargetsRaw;
+    if (root.consistent_snapshot) {
+      newTargetsRaw = await this.fetchMetafileBinary(Roles.Targets, snapshot[`${Roles.Targets}.json`].version);
+    } else {
+      newTargetsRaw = await this.fetchMetafileBinary(Roles.Targets, -1);
+    }
+    const targetsMeta = snapshot[`${Roles.Targets}.json`];
+    if (targetsMeta.length !== void 0) {
+      if (newTargetsRaw.length !== targetsMeta.length) {
+        throw new Error(`Targets length mismatch: expected ${targetsMeta.length}, got ${newTargetsRaw.length}`);
+      }
+    }
+    await this.verifyHashes(newTargetsRaw, targetsMeta.hashes, "Targets");
+    const newTargets = JSON.parse(Uint8ArrayToString(newTargetsRaw));
+    this.validateMetadata(newTargets);
+    if (newTargets.signed._type !== Roles.Targets) {
+      throw new Error(`Invalid metadata type: expected ${Roles.Targets}, got ${newTargets.signed._type}`);
+    }
+    if (await checkSignatures(keys, root.roles["targets"].keyids, newTargets.signed, newTargets.signatures, root.roles.targets.threshold) !== true) {
+      throw new Error(`Failed verifying targets role.`);
+    }
+    const expectedVersion = snapshot[`${Roles.Targets}.json`].version;
+    if (newTargets.signed.version !== expectedVersion) {
+      throw new Error(`Targets version mismatch: URL version ${expectedVersion} but file contains version ${newTargets.signed.version}`);
+    }
+    if (cachedTargets !== void 0 && newTargets.signed.version < cachedTargets.signed.version) {
+      throw new Error("Targets version is lower than the cached one. Probable rollback attack.");
+    }
+    if (new Date(newTargets.signed.expires) <= frozenTimestamp) {
+      throw new Error("Freeze attack on the targets metafile.");
+    }
+    await this.backend.writeRaw(this.getCacheKey(Roles.Targets), newTargetsRaw);
+  }
+  async listSignedTargets() {
+    const cachedTargets = await this.getFromCache(Roles.Targets);
+    const filenames = [];
+    if (cachedTargets) {
+      for (const filename of Object.keys(cachedTargets.signed.targets)) {
+        filenames.push(filename);
+      }
+    }
+    return filenames;
+  }
+  async fetchTarget(name) {
+    const cachedTargets = await this.getFromCache(Roles.Targets);
+    if (cachedTargets === void 0) {
+      throw new Error("Failed to find the targets metafile when it should have existed.");
+    }
+    if (!(name in cachedTargets.signed.targets)) {
+      throw new Error(`${name} not present in the targets role.`);
+    }
+    const targetInfo = cachedTargets.signed.targets[name];
+    const targetHashes = targetInfo.hashes;
+    let hashForUrl;
+    if (targetHashes.sha256) {
+      hashForUrl = targetHashes.sha256;
+    } else if (targetHashes.sha512) {
+      hashForUrl = targetHashes.sha512;
+    } else {
+      throw new Error(`No supported hash algorithm found for ${name}. Available: ${Object.keys(targetHashes).join(", ")}`);
+    }
+    const lastSlash = name.lastIndexOf("/");
+    const targetUrl = lastSlash === -1 ? `${this.targetBaseUrl}${hashForUrl}.${name}` : `${this.targetBaseUrl}${name.substring(0, lastSlash + 1)}${hashForUrl}.${name.substring(lastSlash + 1)}`;
+    const response = await fetch(targetUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch target: ${response.status} ${response.statusText}`);
+    }
+    const raw_file = new Uint8Array(await response.arrayBuffer());
+    if (raw_file.byteLength !== targetInfo.length) {
+      throw new Error(`${name} length mismatch: expected ${targetInfo.length}, got ${raw_file.byteLength}`);
+    }
+    await this.verifyHashes(raw_file, targetHashes, `Target '${name}'`);
+    return raw_file.buffer;
+  }
+  async updateTUF() {
+    const frozenTimestamp = /* @__PURE__ */ new Date();
+    const root = await this.updateRoot(frozenTimestamp);
+    const timestampMeta = await this.updateTimestamp(root, frozenTimestamp);
+    if (timestampMeta === null) {
+      return;
+    }
+    const snapshot = await this.updateSnapshot(root, frozenTimestamp, timestampMeta);
+    await this.updateTargets(root, frozenTimestamp, snapshot);
+  }
+  async getTarget(name) {
+    return await this.fetchTarget(name);
+  }
+};
+export {
+  TUFClient
+};