Pier Angelo Vendrame pushed to branch tor-browser-128.2.0esr-14.0-1 at The Tor Project / Applications / Tor Browser

Commits:

3 changed files:

Changes:

  • toolkit/components/lox/Lox.sys.mjs
    ... ... @@ -9,6 +9,7 @@ const lazy = {};
    9 9
    10 10 
     ChromeUtils.defineLazyGetter(lazy, "logger", () => {
    11 11 
       return console.createInstance({
    12 
    +    maxLogLevel: "Warn",
    12 13 
         maxLogLevelPref: "lox.log_level",
    13 14 
         prefix: "Lox",
    14 15 
       });
    ... ... @@ -50,6 +51,8 @@ XPCOMUtils.defineLazyModuleGetters(lazy, {
    50 51 
       handle_check_blockage: "resource://gre/modules/lox_wasm.jsm",
    51 52 
       blockage_migration: "resource://gre/modules/lox_wasm.jsm",
    52 53 
       handle_blockage_migration: "resource://gre/modules/lox_wasm.jsm",
    54 
    +  check_lox_pubkeys_update: "resource://gre/modules/lox_wasm.jsm",
    55 
    +  handle_update_cred: "resource://gre/modules/lox_wasm.jsm",
    53 56 
     });
    54 57
    55 58 
     export const LoxTopics = Object.freeze({
    ... ... @@ -61,7 +64,7 @@ export const LoxTopics = Object.freeze({
    61 64 
       // Whenever we gain a new upgrade or blockage event, or clear events.
    62 65 
       UpdateEvents: "lox:update-events",
    63 66 
       // Whenever the next unlock *might* have changed.
    64 
    -  // getNextUnlock uses #credentials and #constants, sow ill fire when either
    67 
    +  // getNextUnlock uses #credentials and #constants, so will fire when either
    65 68 
       // value changes.
    66 69 
       UpdateNextUnlock: "lox:update-next-unlock",
    67 70 
       // Whenever the remaining invites *might* have changed.
    ... ... @@ -194,7 +197,7 @@ class LoxImpl {
    194 197
    195 198 
       observe(subject, topic) {
    196 199 
         switch (topic) {
    197 
    -      case lazy.TorSettingsTopics.SettingsChanged:
    200 
    +      case lazy.TorSettingsTopics.SettingsChanged: {
    198 201 
             const { changes } = subject.wrappedJSObject;
    199 202 
             if (
    200 203 
               changes.includes("bridges.enabled") ||
    ... ... @@ -218,6 +221,7 @@ class LoxImpl {
    218 221 
               }
    219 222 
             }
    220 223 
             break;
    224 
    +      }
    221 225 
           case lazy.TorSettingsTopics.Ready:
    222 226 
             // Set the initial #activeLoxId.
    223 227 
             this.#updateActiveLoxId();
    ... ... @@ -403,24 +407,98 @@ class LoxImpl {
    403 407 
         );
    404 408 
       }
    405 409
    410 
    +  /**
    411 
    +   * Update Lox credential after Lox key rotation
    412 
    +   * Do not call directly, use #getPubKeys() instead to start the update only
    413 
    +   * once
    414 
    +   *
    415 
    +   * @param {string} prevkeys The public keys we are replacing
    416 
    +   */
    417 
    +  async #updatePubkeys(prevkeys) {
    418 
    +    let pubKeys;
    419 
    +    try {
    420 
    +      pubKeys = await this.#makeRequest("pubkeys", []);
    421 
    +    } catch (error) {
    422 
    +      lazy.logger.debug("Failed to get pubkeys", error);
    423 
    +      // Make the next call try again.
    424 
    +      this.#pubKeyPromise = null;
    425 
    +      if (!this.#pubKeys) {
    426 
    +        throw error;
    427 
    +      }
    428 
    +      return;
    429 
    +    }
    430 
    +    const prevKeys = this.#pubKeys;
    431 
    +    if (prevKeys !== null) {
    432 
    +      // check if the lox pubkeys have changed and update the lox
    433 
    +      // credentials if so
    434 
    +      let lox_cred_req;
    435 
    +      try {
    436 
    +        lox_cred_req = JSON.parse(
    437 
    +          lazy.check_lox_pubkeys_update(
    438 
    +            JSON.stringify(pubKeys),
    439 
    +            prevkeys,
    440 
    +            this.#getCredentials(this.#activeLoxId)
    441 
    +          )
    442 
    +        );
    443 
    +      } catch (error) {
    444 
    +        lazy.logger.debug("Check lox pubkey update failed", error);
    445 
    +        // Make the next call try again.
    446 
    +        this.#pubKeyPromise = null;
    447 
    +        return;
    448 
    +      }
    449 
    +      if (lox_cred_req.updated) {
    450 
    +        lazy.logger.debug(
    451 
    +          `Lox pubkey updated, update Lox credential "${this.#activeLoxId}"`
    452 
    +        );
    453 
    +        let response;
    454 
    +        try {
    455 
    +          // TODO: If this call doesn't succeed due to a networking error, the Lox
    456 
    +          // credential may be in an unusable state (spent but not updated)
    457 
    +          // until this request can be completed successfully (and until Lox
    458 
    +          // is refactored to send repeat responses:
    459 
    +          // https://gitlab.torproject.org/tpo/anti-censorship/lox/-/issues/74)
    460 
    +          response = await this.#makeRequest("updatecred", lox_cred_req.req);
    461 
    +        } catch (error) {
    462 
    +          lazy.logger.debug("Lox cred update failed.", error);
    463 
    +          // Make the next call try again.
    464 
    +          this.#pubKeyPromise = null;
    465 
    +          return;
    466 
    +        }
    467 
    +        if (response.hasOwnProperty("error")) {
    468 
    +          lazy.logger.error(response.error);
    469 
    +          this.#pubKeyPromise = null;
    470 
    +          lazy.logger.debug(
    471 
    +            `Error response to Lox pubkey update request: "${response.error}", reverting to old pubkeys`
    472 
    +          );
    473 
    +          return;
    474 
    +        }
    475 
    +        let cred;
    476 
    +        try {
    477 
    +          cred = lazy.handle_update_cred(
    478 
    +            lox_cred_req.req,
    479 
    +            JSON.stringify(response),
    480 
    +            pubKeys
    481 
    +          );
    482 
    +        } catch (error) {
    483 
    +          lazy.logger.debug("Unable to handle updated Lox cred", error);
    484 
    +          // Make the next call try again.
    485 
    +          this.#pubKeyPromise = null;
    486 
    +          return;
    487 
    +        }
    488 
    +        this.#changeCredentials(this.#activeLoxId, cred);
    489 
    +      }
    490 
    +    }
    491 
    +    // If we arrive here we haven't had other errors before, we can actually
    492 
    +    // store the new public key.
    493 
    +    this.#pubKeys = JSON.stringify(pubKeys);
    494 
    +    this.#store();
    495 
    +  }
    496 
    +
    406 497 
       async #getPubKeys() {
    407 498 
         // FIXME: We are always refetching #pubKeys, #encTable and #constants once
    408 499 
         // per session, but they may change more frequently. tor-browser#42502
    409 500 
         if (this.#pubKeyPromise === null) {
    410 
    -      this.#pubKeyPromise = this.#makeRequest("pubkeys", [])
    411 
    -        .then(pubKeys => {
    412 
    -          this.#pubKeys = JSON.stringify(pubKeys);
    413 
    -          this.#store();
    414 
    -        })
    415 
    -        .catch(error => {
    416 
    -          lazy.logger.debug("Failed to get pubkeys", error);
    417 
    -          // Make the next call try again.
    418 
    -          this.#pubKeyPromise = null;
    419 
    -          // We always try to update, but if that doesn't work fall back to stored data
    420 
    -          if (!this.#pubKeys) {
    421 
    -            throw error;
    422 
    -          }
    423 
    -        });
    501 
    +      this.#pubKeyPromise = this.#updatePubkeys();
    424 502 
         }
    425 503 
         await this.#pubKeyPromise;
    426 504 
       }
    ... ... @@ -508,6 +586,11 @@ class LoxImpl {
    508 586 
           lazy.logger.warn("No loxId for the background task");
    509 587 
           return;
    510 588 
         }
    589 
    +
    590 
    +    // Attempt to update pubkeys each time background tasks are run
    591 
    +    // this should catch key rotations (ideally some days) prior to the next
    592 
    +    // credential update
    593 
    +    await this.#getPubKeys();
    511 594 
         try {
    512 595 
           const levelup = await this.#attemptUpgrade(loxId);
    513 596 
           if (levelup) {
    ... ... @@ -631,13 +714,16 @@ class LoxImpl {
    631 714 
       }
    632 715
    633 716 
       /**
    634 
    -   * Redeems a Lox invitation to obtain a credential and bridges.
    717 
    +   * Redeems a Lox open invitation to obtain an untrusted Lox credential
    718 
    +   * and 1 bridge.
    635 719 
        *
    636 
    -   * @param {string} invite A Lox invitation.
    720 
    +   * @param {string} invite A Lox open invitation.
    637 721 
        * @returns {string} The loxId of the associated credential on success.
    638 722 
        */
    639 723 
       async redeemInvite(invite) {
    640 724 
         this.#assertInitialized();
    725 
    +    // It's fine to get pubkey here without a delay since the user will not have a Lox
    726 
    +    // credential yet
    641 727 
         await this.#getPubKeys();
    642 728 
         let request = await lazy.open_invite(JSON.parse(invite).invite);
    643 729 
         let response = await this.#makeRequest(
    ... ... @@ -691,7 +777,18 @@ class LoxImpl {
    691 777 
        */
    692 778 
       async generateInvite(loxId) {
    693 779 
         this.#assertInitialized();
    694 
    -    await this.#getPubKeys();
    780 
    +    // Check for pubkey update prior to invitation generation
    781 
    +    // to avoid invite being generated with outdated keys
    782 
    +    // TODO: it's still possible the keys could be rotated before the invitation is redeemed
    783 
    +    // so updating the invite after issuing should also be possible somehow
    784 
    +    if (this.#pubKeys == null) {
    785 
    +      // TODO: Set pref to call this function after some time #43086
    786 
    +      // See also: https://gitlab.torproject.org/tpo/applications/tor-browser/-/merge_requests/1090#note_3066911
    787 
    +      await this.#getPubKeys();
    788 
    +      throw new LoxError(
    789 
    +        `Pubkeys just updated, retry later to avoid deanonymization`
    790 
    +      );
    791 
    +    }
    695 792 
         await this.#getEncTable();
    696 793 
         let level = this.#getLevel(loxId);
    697 794 
         if (level < 1) {
    ... ... @@ -740,7 +837,6 @@ class LoxImpl {
    740 837 
       }
    741 838
    742 839 
       async #blockageMigration(loxId) {
    743 
    -    await this.#getPubKeys();
    744 840 
         let request;
    745 841 
         try {
    746 842 
           request = lazy.check_blockage(this.#getCredentials(loxId), this.#pubKeys);
    ... ... @@ -783,11 +879,10 @@ class LoxImpl {
    783 879 
       /** Attempts to upgrade the currently saved Lox credential.
    784 880 
        *  If an upgrade is available, save an event in the event list.
    785 881 
        *
    786 
    -   * @param {string} loxId Lox ID
    787 
    -   * @returns {boolean} Whether a levelup event occurred.
    882 
    +   *  @param {string} loxId Lox ID
    883 
    +   *  @returns {boolean} Whether a levelup event occurred.
    788 884 
        */
    789 885 
       async #attemptUpgrade(loxId) {
    790 
    -    await this.#getPubKeys();
    791 886 
         await this.#getEncTable();
    792 887 
         await this.#getConstants();
    793 888 
         let level = this.#getLevel(loxId);
    ... ... @@ -821,60 +916,84 @@ class LoxImpl {
    821 916 
        * @returns {boolean} Whether the credential was successfully migrated.
    822 917 
        */
    823 918 
       async #trustMigration(loxId) {
    824 
    -    await this.#getPubKeys();
    825 
    -    return new Promise(resolve => {
    826 
    -      let request = "";
    827 
    -      try {
    828 
    -        request = lazy.trust_promotion(
    829 
    -          this.#getCredentials(loxId),
    830 
    -          this.#pubKeys
    831 
    -        );
    832 
    -      } catch (err) {
    833 
    -        lazy.logger.debug("Not ready to upgrade");
    834 
    -        resolve(false);
    835 
    -      }
    836 
    -      this.#makeRequest("trustpromo", JSON.parse(request).request)
    837 
    -        .then(response => {
    838 
    -          if (response.hasOwnProperty("error")) {
    839 
    -            lazy.logger.error("Error response from trustpromo", response.error);
    840 
    -            resolve(false);
    841 
    -          }
    842 
    -          lazy.logger.debug("Got promotion cred", response, request);
    843 
    -          let promoCred = lazy.handle_trust_promotion(
    844 
    -            request,
    845 
    -            JSON.stringify(response)
    846 
    -          );
    847 
    -          lazy.logger.debug("Formatted promotion cred");
    848 
    -          request = lazy.trust_migration(
    849 
    -            this.#getCredentials(loxId),
    850 
    -            promoCred,
    851 
    -            this.#pubKeys
    852 
    -          );
    853 
    -          lazy.logger.debug("Formatted migration request");
    854 
    -          this.#makeRequest("trustmig", JSON.parse(request).request)
    855 
    -            .then(response => {
    856 
    -              if (response.hasOwnProperty("error")) {
    857 
    -                lazy.logger.error(
    858 
    -                  "Error response from trustmig",
    859 
    -                  response.error
    860 
    -                );
    861 
    -                resolve(false);
    862 
    -              }
    863 
    -              lazy.logger.debug("Got new credential");
    864 
    -              let cred = lazy.handle_trust_migration(request, response);
    865 
    -              this.#changeCredentials(loxId, cred);
    866 
    -              resolve(true);
    867 
    -            })
    868 
    -            .catch(err => {
    869 
    -              lazy.logger.error("Failed trust migration", err);
    870 
    -              resolve(false);
    871 
    -            });
    872 
    -        })
    873 
    -        .catch(err => {
    874 
    -          lazy.logger.error("Failed trust promotion", err);
    875 
    -          resolve(false);
    876 
    -        });
    877 
    -    });
    919 
    +    if (this.#pubKeys == null) {
    920 
    +      // TODO: Set pref to call this function after some time #43086
    921 
    +      // See also: https://gitlab.torproject.org/tpo/applications/tor-browser/-/merge_requests/1090#note_3066911
    922 
    +      this.#getPubKeys();
    923 
    +      return false;
    924 
    +    }
    925 
    +    let request, response;
    926 
    +    try {
    927 
    +      request = lazy.trust_promotion(
    928 
    +        this.#getCredentials(loxId),
    929 
    +        this.#pubKeys
    930 
    +      );
    931 
    +    } catch (err) {
    932 
    +      lazy.logger.debug("Not ready to upgrade", err);
    933 
    +      return false;
    934 
    +    }
    935 
    +    try {
    936 
    +      response = await this.#makeRequest(
    937 
    +        "trustpromo",
    938 
    +        JSON.parse(request).request
    939 
    +      );
    940 
    +    } catch (err) {
    941 
    +      lazy.logger.error("Failed trust promotion", err);
    942 
    +      return false;
    943 
    +    }
    944 
    +    if (response.hasOwnProperty("error")) {
    945 
    +      lazy.logger.error("Error response from trustpromo", response.error);
    946 
    +      return false;
    947 
    +    }
    948 
    +    lazy.logger.debug("Got promotion cred", response, request);
    949 
    +    let promoCred;
    950 
    +    try {
    951 
    +      promoCred = lazy.handle_trust_promotion(
    952 
    +        request,
    953 
    +        JSON.stringify(response)
    954 
    +      );
    955 
    +      lazy.logger.debug("Formatted promotion cred");
    956 
    +    } catch (err) {
    957 
    +      lazy.logger.error(
    958 
    +        "Unable to handle trustpromo response properly",
    959 
    +        response.error
    960 
    +      );
    961 
    +      return false;
    962 
    +    }
    963 
    +    try {
    964 
    +      request = lazy.trust_migration(
    965 
    +        this.#getCredentials(loxId),
    966 
    +        promoCred,
    967 
    +        this.#pubKeys
    968 
    +      );
    969 
    +      lazy.logger.debug("Formatted migration request");
    970 
    +    } catch (err) {
    971 
    +      lazy.logger.error("Failed to generate trust migration request", err);
    972 
    +      return false;
    973 
    +    }
    974 
    +    try {
    975 
    +      response = await this.#makeRequest(
    976 
    +        "trustmig",
    977 
    +        JSON.parse(request).request
    978 
    +      );
    979 
    +    } catch (err) {
    980 
    +      lazy.logger.error("Failed trust migration", err);
    981 
    +      return false;
    982 
    +    }
    983 
    +    if (response.hasOwnProperty("error")) {
    984 
    +      lazy.logger.error("Error response from trustmig", response.error);
    985 
    +      return false;
    986 
    +    }
    987 
    +    lazy.logger.debug("Got new credential");
    988 
    +    let cred;
    989 
    +    try {
    990 
    +      cred = lazy.handle_trust_migration(request, response);
    991 
    +    } catch (err) {
    992 
    +      lazy.logger.error("Failed to handle response from trustmig", err);
    993 
    +      return false;
    994 
    +    }
    995 
    +    this.#changeCredentials(loxId, cred);
    996 
    +    return true;
    878 997 
       }
    879 998
    880 999 
       /**

  • toolkit/components/lox/content/lox_wasm_bg.wasm
    No preview for this file type
  • toolkit/components/lox/lox_wasm.jsm
    1 
    -var EXPORTED_SYMBOLS = ["set_panic_hook", "open_invite", "handle_new_lox_credential", "trust_promotion", "handle_trust_promotion", "trust_migration", "handle_trust_migration", "level_up", "handle_level_up", "issue_invite", "handle_issue_invite", "prepare_invite", "redeem_invite", "handle_redeem_invite", "check_blockage", "handle_check_blockage", "blockage_migration", "handle_blockage_migration", "get_last_upgrade_time", "get_trust_level", "get_invites_remaining", "get_issued_invite_expiry", "get_received_invite_expiry", "get_bridgelines_from_bucket", "invitation_is_trusted", "get_next_unlock", "init", "initSync"];
    1 
    +var EXPORTED_SYMBOLS = ["set_panic_hook", "open_invite", "handle_new_lox_credential", "trust_promotion", "handle_trust_promotion", "trust_migration", "handle_trust_migration", "level_up", "handle_level_up", "issue_invite", "handle_issue_invite", "prepare_invite", "redeem_invite", "handle_redeem_invite", "check_blockage", "handle_check_blockage", "blockage_migration", "handle_blockage_migration", "update_cred", "handle_update_cred", "update_invite", "handle_update_invite", "get_last_upgrade_time", "get_trust_level", "get_invites_remaining", "get_issued_invite_expiry", "get_received_invite_expiry", "get_bridgelines_from_bucket", "invitation_is_trusted", "get_next_unlock", "check_lox_pubkeys_update", "check_invitation_pubkeys_update", "init", "initSync"];
    2 2
    3 3 
     let wasm;
    4 4 
     let module;
    ... ... @@ -57,52 +57,6 @@ function set_panic_hook() {
    57 57
    58 58 
     let WASM_VECTOR_LEN = 0;
    59 59
    60 
    -function passArray8ToWasm0(arg, malloc) {
    61 
    -    const ptr = malloc(arg.length * 1, 1) >>> 0;
    62 
    -    getUint8Memory0().set(arg, ptr / 1);
    63 
    -    WASM_VECTOR_LEN = arg.length;
    64 
    -    return ptr;
    65 
    -}
    66 
    -
    67 
    -let cachedInt32Memory0 = null;
    68 
    -
    69 
    -function getInt32Memory0() {
    70 
    -    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
    71 
    -        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
    72 
    -    }
    73 
    -    return cachedInt32Memory0;
    74 
    -}
    75 
    -/**
    76 
    -* @param {Uint8Array} invite
    77 
    -* @returns {string}
    78 
    -*/
    79 
    -function open_invite(invite) {
    80 
    -    let deferred3_0;
    81 
    -    let deferred3_1;
    82 
    -    try {
    83 
    -        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    84 
    -        const ptr0 = passArray8ToWasm0(invite, wasm.__wbindgen_malloc);
    85 
    -        const len0 = WASM_VECTOR_LEN;
    86 
    -        wasm.open_invite(retptr, ptr0, len0);
    87 
    -        var r0 = getInt32Memory0()[retptr / 4 + 0];
    88 
    -        var r1 = getInt32Memory0()[retptr / 4 + 1];
    89 
    -        var r2 = getInt32Memory0()[retptr / 4 + 2];
    90 
    -        var r3 = getInt32Memory0()[retptr / 4 + 3];
    91 
    -        var ptr2 = r0;
    92 
    -        var len2 = r1;
    93 
    -        if (r3) {
    94 
    -            ptr2 = 0; len2 = 0;
    95 
    -            throw takeObject(r2);
    96 
    -        }
    97 
    -        deferred3_0 = ptr2;
    98 
    -        deferred3_1 = len2;
    99 
    -        return getStringFromWasm0(ptr2, len2);
    100 
    -    } finally {
    101 
    -        wasm.__wbindgen_add_to_stack_pointer(16);
    102 
    -        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
    103 
    -    }
    104 
    -}
    105 
    -
    106 60 
     const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
    107 61
    108 62 
     const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
    ... ... @@ -150,11 +104,52 @@ function passStringToWasm0(arg, malloc, realloc) {
    150 104 
             const ret = encodeString(arg, view);
    151 105
    152 106 
             offset += ret.written;
    107 
    +        ptr = realloc(ptr, len, offset, 1) >>> 0;
    153 108 
         }
    154 109
    155 110 
         WASM_VECTOR_LEN = offset;
    156 111 
         return ptr;
    157 112 
     }
    113 
    +
    114 
    +let cachedInt32Memory0 = null;
    115 
    +
    116 
    +function getInt32Memory0() {
    117 
    +    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
    118 
    +        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
    119 
    +    }
    120 
    +    return cachedInt32Memory0;
    121 
    +}
    122 
    +/**
    123 
    +* @param {string} base64_invite
    124 
    +* @returns {string}
    125 
    +*/
    126 
    +function open_invite(base64_invite) {
    127 
    +    let deferred3_0;
    128 
    +    let deferred3_1;
    129 
    +    try {
    130 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    131 
    +        const ptr0 = passStringToWasm0(base64_invite, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    132 
    +        const len0 = WASM_VECTOR_LEN;
    133 
    +        wasm.open_invite(retptr, ptr0, len0);
    134 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    135 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    136 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    137 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    138 
    +        var ptr2 = r0;
    139 
    +        var len2 = r1;
    140 
    +        if (r3) {
    141 
    +            ptr2 = 0; len2 = 0;
    142 
    +            throw takeObject(r2);
    143 
    +        }
    144 
    +        deferred3_0 = ptr2;
    145 
    +        deferred3_1 = len2;
    146 
    +        return getStringFromWasm0(ptr2, len2);
    147 
    +    } finally {
    148 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    149 
    +        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
    150 
    +    }
    151 
    +}
    152 
    +
    158 153 
     /**
    159 154 
     * @param {string} open_lox_result
    160 155 
     * @param {string} open_lox_response
    ... ... @@ -726,6 +721,148 @@ function handle_blockage_migration(blockage_migration_request, blockage_migratio
    726 721 
         }
    727 722 
     }
    728 723
    724 
    +/**
    725 
    +* @param {string} lox_cred
    726 
    +* @param {string} lox_pub
    727 
    +* @returns {string}
    728 
    +*/
    729 
    +function update_cred(lox_cred, lox_pub) {
    730 
    +    let deferred4_0;
    731 
    +    let deferred4_1;
    732 
    +    try {
    733 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    734 
    +        const ptr0 = passStringToWasm0(lox_cred, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    735 
    +        const len0 = WASM_VECTOR_LEN;
    736 
    +        const ptr1 = passStringToWasm0(lox_pub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    737 
    +        const len1 = WASM_VECTOR_LEN;
    738 
    +        wasm.update_cred(retptr, ptr0, len0, ptr1, len1);
    739 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    740 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    741 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    742 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    743 
    +        var ptr3 = r0;
    744 
    +        var len3 = r1;
    745 
    +        if (r3) {
    746 
    +            ptr3 = 0; len3 = 0;
    747 
    +            throw takeObject(r2);
    748 
    +        }
    749 
    +        deferred4_0 = ptr3;
    750 
    +        deferred4_1 = len3;
    751 
    +        return getStringFromWasm0(ptr3, len3);
    752 
    +    } finally {
    753 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    754 
    +        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
    755 
    +    }
    756 
    +}
    757 
    +
    758 
    +/**
    759 
    +* @param {string} update_cred_request
    760 
    +* @param {string} update_cred_response
    761 
    +* @param {string} updated_lox_pub
    762 
    +* @returns {string}
    763 
    +*/
    764 
    +function handle_update_cred(update_cred_request, update_cred_response, updated_lox_pub) {
    765 
    +    let deferred5_0;
    766 
    +    let deferred5_1;
    767 
    +    try {
    768 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    769 
    +        const ptr0 = passStringToWasm0(update_cred_request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    770 
    +        const len0 = WASM_VECTOR_LEN;
    771 
    +        const ptr1 = passStringToWasm0(update_cred_response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    772 
    +        const len1 = WASM_VECTOR_LEN;
    773 
    +        const ptr2 = passStringToWasm0(updated_lox_pub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    774 
    +        const len2 = WASM_VECTOR_LEN;
    775 
    +        wasm.handle_update_cred(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
    776 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    777 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    778 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    779 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    780 
    +        var ptr4 = r0;
    781 
    +        var len4 = r1;
    782 
    +        if (r3) {
    783 
    +            ptr4 = 0; len4 = 0;
    784 
    +            throw takeObject(r2);
    785 
    +        }
    786 
    +        deferred5_0 = ptr4;
    787 
    +        deferred5_1 = len4;
    788 
    +        return getStringFromWasm0(ptr4, len4);
    789 
    +    } finally {
    790 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    791 
    +        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
    792 
    +    }
    793 
    +}
    794 
    +
    795 
    +/**
    796 
    +* @param {string} invite_cred
    797 
    +* @param {string} lox_pub
    798 
    +* @returns {string}
    799 
    +*/
    800 
    +function update_invite(invite_cred, lox_pub) {
    801 
    +    let deferred4_0;
    802 
    +    let deferred4_1;
    803 
    +    try {
    804 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    805 
    +        const ptr0 = passStringToWasm0(invite_cred, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    806 
    +        const len0 = WASM_VECTOR_LEN;
    807 
    +        const ptr1 = passStringToWasm0(lox_pub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    808 
    +        const len1 = WASM_VECTOR_LEN;
    809 
    +        wasm.update_invite(retptr, ptr0, len0, ptr1, len1);
    810 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    811 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    812 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    813 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    814 
    +        var ptr3 = r0;
    815 
    +        var len3 = r1;
    816 
    +        if (r3) {
    817 
    +            ptr3 = 0; len3 = 0;
    818 
    +            throw takeObject(r2);
    819 
    +        }
    820 
    +        deferred4_0 = ptr3;
    821 
    +        deferred4_1 = len3;
    822 
    +        return getStringFromWasm0(ptr3, len3);
    823 
    +    } finally {
    824 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    825 
    +        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
    826 
    +    }
    827 
    +}
    828 
    +
    829 
    +/**
    830 
    +* @param {string} update_invite_request
    831 
    +* @param {string} update_invite_response
    832 
    +* @param {string} updated_lox_pub
    833 
    +* @returns {string}
    834 
    +*/
    835 
    +function handle_update_invite(update_invite_request, update_invite_response, updated_lox_pub) {
    836 
    +    let deferred5_0;
    837 
    +    let deferred5_1;
    838 
    +    try {
    839 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    840 
    +        const ptr0 = passStringToWasm0(update_invite_request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    841 
    +        const len0 = WASM_VECTOR_LEN;
    842 
    +        const ptr1 = passStringToWasm0(update_invite_response, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    843 
    +        const len1 = WASM_VECTOR_LEN;
    844 
    +        const ptr2 = passStringToWasm0(updated_lox_pub, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    845 
    +        const len2 = WASM_VECTOR_LEN;
    846 
    +        wasm.handle_update_invite(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
    847 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    848 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    849 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    850 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    851 
    +        var ptr4 = r0;
    852 
    +        var len4 = r1;
    853 
    +        if (r3) {
    854 
    +            ptr4 = 0; len4 = 0;
    855 
    +            throw takeObject(r2);
    856 
    +        }
    857 
    +        deferred5_0 = ptr4;
    858 
    +        deferred5_1 = len4;
    859 
    +        return getStringFromWasm0(ptr4, len4);
    860 
    +    } finally {
    861 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    862 
    +        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
    863 
    +    }
    864 
    +}
    865 
    +
    729 866 
     /**
    730 867 
     * @param {string} lox_cred_str
    731 868 
     * @returns {string}
    ... ... @@ -971,6 +1108,80 @@ function get_next_unlock(constants_str, lox_cred_str) {
    971 1108 
         }
    972 1109 
     }
    973 1110
    1111 
    +/**
    1112 
    +* @param {string} new_pubkeys_str
    1113 
    +* @param {string} old_pubkeys_str
    1114 
    +* @param {string} old_lox_cred
    1115 
    +* @returns {string}
    1116 
    +*/
    1117 
    +function check_lox_pubkeys_update(new_pubkeys_str, old_pubkeys_str, old_lox_cred) {
    1118 
    +    let deferred5_0;
    1119 
    +    let deferred5_1;
    1120 
    +    try {
    1121 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    1122 
    +        const ptr0 = passStringToWasm0(new_pubkeys_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1123 
    +        const len0 = WASM_VECTOR_LEN;
    1124 
    +        const ptr1 = passStringToWasm0(old_pubkeys_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1125 
    +        const len1 = WASM_VECTOR_LEN;
    1126 
    +        const ptr2 = passStringToWasm0(old_lox_cred, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1127 
    +        const len2 = WASM_VECTOR_LEN;
    1128 
    +        wasm.check_lox_pubkeys_update(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
    1129 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    1130 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    1131 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    1132 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    1133 
    +        var ptr4 = r0;
    1134 
    +        var len4 = r1;
    1135 
    +        if (r3) {
    1136 
    +            ptr4 = 0; len4 = 0;
    1137 
    +            throw takeObject(r2);
    1138 
    +        }
    1139 
    +        deferred5_0 = ptr4;
    1140 
    +        deferred5_1 = len4;
    1141 
    +        return getStringFromWasm0(ptr4, len4);
    1142 
    +    } finally {
    1143 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    1144 
    +        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
    1145 
    +    }
    1146 
    +}
    1147 
    +
    1148 
    +/**
    1149 
    +* @param {string} new_pubkeys_str
    1150 
    +* @param {string} old_pubkeys_str
    1151 
    +* @param {string} old_invite_cred
    1152 
    +* @returns {string}
    1153 
    +*/
    1154 
    +function check_invitation_pubkeys_update(new_pubkeys_str, old_pubkeys_str, old_invite_cred) {
    1155 
    +    let deferred5_0;
    1156 
    +    let deferred5_1;
    1157 
    +    try {
    1158 
    +        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
    1159 
    +        const ptr0 = passStringToWasm0(new_pubkeys_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1160 
    +        const len0 = WASM_VECTOR_LEN;
    1161 
    +        const ptr1 = passStringToWasm0(old_pubkeys_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1162 
    +        const len1 = WASM_VECTOR_LEN;
    1163 
    +        const ptr2 = passStringToWasm0(old_invite_cred, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
    1164 
    +        const len2 = WASM_VECTOR_LEN;
    1165 
    +        wasm.check_invitation_pubkeys_update(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
    1166 
    +        var r0 = getInt32Memory0()[retptr / 4 + 0];
    1167 
    +        var r1 = getInt32Memory0()[retptr / 4 + 1];
    1168 
    +        var r2 = getInt32Memory0()[retptr / 4 + 2];
    1169 
    +        var r3 = getInt32Memory0()[retptr / 4 + 3];
    1170 
    +        var ptr4 = r0;
    1171 
    +        var len4 = r1;
    1172 
    +        if (r3) {
    1173 
    +            ptr4 = 0; len4 = 0;
    1174 
    +            throw takeObject(r2);
    1175 
    +        }
    1176 
    +        deferred5_0 = ptr4;
    1177 
    +        deferred5_1 = len4;
    1178 
    +        return getStringFromWasm0(ptr4, len4);
    1179 
    +    } finally {
    1180 
    +        wasm.__wbindgen_add_to_stack_pointer(16);
    1181 
    +        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
    1182 
    +    }
    1183 
    +}
    1184 
    +
    974 1185 
     function handleError(f, args) {
    975 1186 
         try {
    976 1187 
             return f.apply(this, args);
    ... ... @@ -1013,11 +1224,11 @@ async function __wbg_load(module, imports) {
    1013 1224 
     function __wbg_get_imports(window) {
    1014 1225 
         const imports = {};
    1015 1226 
         imports.wbg = {};
    1016 
    -    imports.wbg.__wbg_new0_622c21a64f3d83ea = function() {
    1227 
    +    imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
    1017 1228 
             const ret = new Date();
    1018 1229 
             return addHeapObject(ret);
    1019 1230 
         };
    1020 
    -    imports.wbg.__wbg_getTime_9272be78826033e1 = function(arg0) {
    1231 
    +    imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
    1021 1232 
             const ret = getObject(arg0).getTime();
    1022 1233 
             return ret;
    1023 1234 
         };
    ... ... @@ -1057,7 +1268,7 @@ function __wbg_get_imports(window) {
    1057 1268 
             const ret = getObject(arg0);
    1058 1269 
             return addHeapObject(ret);
    1059 1270 
         };
    1060 
    -    imports.wbg.__wbg_crypto_c48a774b022d20ac = function(arg0) {
    1271 
    +    imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
    1061 1272 
             const ret = getObject(arg0).crypto;
    1062 1273 
             return addHeapObject(ret);
    1063 1274 
         };
    ... ... @@ -1066,15 +1277,15 @@ function __wbg_get_imports(window) {
    1066 1277 
             const ret = typeof(val) === 'object' && val !== null;
    1067 1278 
             return ret;
    1068 1279 
         };
    1069 
    -    imports.wbg.__wbg_process_298734cf255a885d = function(arg0) {
    1280 
    +    imports.wbg.__wbg_process_4a72847cc503995b = function(arg0) {
    1070 1281 
             const ret = getObject(arg0).process;
    1071 1282 
             return addHeapObject(ret);
    1072 1283 
         };
    1073 
    -    imports.wbg.__wbg_versions_e2e78e134e3e5d01 = function(arg0) {
    1284 
    +    imports.wbg.__wbg_versions_f686565e586dd935 = function(arg0) {
    1074 1285 
             const ret = getObject(arg0).versions;
    1075 1286 
             return addHeapObject(ret);
    1076 1287 
         };
    1077 
    -    imports.wbg.__wbg_node_1cd7a5d853dbea79 = function(arg0) {
    1288 
    +    imports.wbg.__wbg_node_104a2ff8d6ea03a2 = function(arg0) {
    1078 1289 
             const ret = getObject(arg0).node;
    1079 1290 
             return addHeapObject(ret);
    1080 1291 
         };
    ... ... @@ -1082,7 +1293,7 @@ function __wbg_get_imports(window) {
    1082 1293 
             const ret = typeof(getObject(arg0)) === 'string';
    1083 1294 
             return ret;
    1084 1295 
         };
    1085 
    -    imports.wbg.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () {
    1296 
    +    imports.wbg.__wbg_require_cca90b1a94a0255b = function() { return handleError(function () {
    1086 1297 
             const ret = module.require;
    1087 1298 
             return addHeapObject(ret);
    1088 1299 
         }, arguments) };
    ... ... @@ -1090,31 +1301,31 @@ function __wbg_get_imports(window) {
    1090 1301 
             const ret = typeof(getObject(arg0)) === 'function';
    1091 1302 
             return ret;
    1092 1303 
         };
    1093 
    -    imports.wbg.__wbg_call_5da1969d7cd31ccd = function() { return handleError(function (arg0, arg1, arg2) {
    1304 
    +    imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
    1094 1305 
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
    1095 1306 
             return addHeapObject(ret);
    1096 1307 
         }, arguments) };
    1097 
    -    imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) {
    1308 
    +    imports.wbg.__wbg_msCrypto_eb05e62b530a1508 = function(arg0) {
    1098 1309 
             const ret = getObject(arg0).msCrypto;
    1099 1310 
             return addHeapObject(ret);
    1100 1311 
         };
    1101 
    -    imports.wbg.__wbg_newwithlength_6c2df9e2f3028c43 = function(arg0) {
    1312 
    +    imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
    1102 1313 
             const ret = new Uint8Array(arg0 >>> 0);
    1103 1314 
             return addHeapObject(ret);
    1104 1315 
         };
    1105 
    -    imports.wbg.__wbg_self_f0e34d89f33b99fd = function() { return handleError(function () {
    1316 
    +    imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
    1106 1317 
             const ret = window;
    1107 1318 
             return addHeapObject(ret);
    1108 1319 
         }, arguments) };
    1109 
    -    imports.wbg.__wbg_window_d3b084224f4774d7 = function() { return handleError(function () {
    1320 
    +    imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
    1110 1321 
             const ret = window.window;
    1111 1322 
             return addHeapObject(ret);
    1112 1323 
         }, arguments) };
    1113 
    -    imports.wbg.__wbg_globalThis_9caa27ff917c6860 = function() { return handleError(function () {
    1324 
    +    imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
    1114 1325 
             const ret = globalThis.globalThis;
    1115 1326 
             return addHeapObject(ret);
    1116 1327 
         }, arguments) };
    1117 
    -    imports.wbg.__wbg_global_35dfdd59a4da3e74 = function() { return handleError(function () {
    1328 
    +    imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
    1118 1329 
             const ret = global.global;
    1119 1330 
             return addHeapObject(ret);
    1120 1331 
         }, arguments) };
    ... ... @@ -1122,11 +1333,11 @@ function __wbg_get_imports(window) {
    1122 1333 
             const ret = getObject(arg0) === undefined;
    1123 1334 
             return ret;
    1124 1335 
         };
    1125 
    -    imports.wbg.__wbg_newnoargs_c62ea9419c21fbac = function(arg0, arg1) {
    1336 
    +    imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
    1126 1337 
             const ret = new Function(getStringFromWasm0(arg0, arg1));
    1127 1338 
             return addHeapObject(ret);
    1128 1339 
         };
    1129 
    -    imports.wbg.__wbg_call_90c26b09837aba1c = function() { return handleError(function (arg0, arg1) {
    1340 
    +    imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
    1130 1341 
             const ret = getObject(arg0).call(getObject(arg1));
    1131 1342 
             return addHeapObject(ret);
    1132 1343 
         }, arguments) };
    ... ... @@ -1134,29 +1345,29 @@ function __wbg_get_imports(window) {
    1134 1345 
             const ret = wasm.memory;
    1135 1346 
             return addHeapObject(ret);
    1136 1347 
         };
    1137 
    -    imports.wbg.__wbg_buffer_a448f833075b71ba = function(arg0) {
    1348 
    +    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
    1138 1349 
             const ret = getObject(arg0).buffer;
    1139 1350 
             return addHeapObject(ret);
    1140 1351 
         };
    1141 
    -    imports.wbg.__wbg_newwithbyteoffsetandlength_d0482f893617af71 = function(arg0, arg1, arg2) {
    1352 
    +    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
    1142 1353 
             const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
    1143 1354 
             return addHeapObject(ret);
    1144 1355 
         };
    1145 
    -    imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) {
    1356 
    +    imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
    1146 1357 
             getObject(arg0).randomFillSync(takeObject(arg1));
    1147 1358 
         }, arguments) };
    1148 
    -    imports.wbg.__wbg_subarray_2e940e41c0f5a1d9 = function(arg0, arg1, arg2) {
    1359 
    +    imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
    1149 1360 
             const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
    1150 1361 
             return addHeapObject(ret);
    1151 1362 
         };
    1152 
    -    imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) {
    1363 
    +    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
    1153 1364 
             getObject(arg0).getRandomValues(getObject(arg1));
    1154 1365 
         }, arguments) };
    1155 
    -    imports.wbg.__wbg_new_8f67e318f15d7254 = function(arg0) {
    1366 
    +    imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
    1156 1367 
             const ret = new Uint8Array(getObject(arg0));
    1157 1368 
             return addHeapObject(ret);
    1158 1369 
         };
    1159 
    -    imports.wbg.__wbg_set_2357bf09366ee480 = function(arg0, arg1, arg2) {
    1370 
    +    imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
    1160 1371 
             getObject(arg0).set(getObject(arg1), arg2 >>> 0);
    1161 1372 
         };
    1162 1373 
         imports.wbg.__wbindgen_throw = function(arg0, arg1) {

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.torproject.org. Manage all notifications · Help