matrix-react-sdk/lib/async-components/views/dialogs/security/CreateSecretStorageDialog.js

SDK for matrix.org using React

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _react = _interopRequireWildcard(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var sdk = _interopRequireWildcard(require("../../../../index"));

var _MatrixClientPeg = require("../../../../MatrixClientPeg");

var _fileSaver = _interopRequireDefault(require("file-saver"));

var _languageHandler = require("../../../../languageHandler");

var _Modal = _interopRequireDefault(require("../../../../Modal"));

var _SecurityManager = require("../../../../SecurityManager");

var _strings = require("../../../../utils/strings");

var _InteractiveAuthEntryComponents = require("../../../../components/views/auth/InteractiveAuthEntryComponents");

var _PassphraseField = _interopRequireDefault(require("../../../../components/views/auth/PassphraseField"));

var _StyledRadioButton = _interopRequireDefault(require("../../../../components/views/elements/StyledRadioButton"));

var _AccessibleButton = _interopRequireDefault(require("../../../../components/views/elements/AccessibleButton"));

var _DialogButtons = _interopRequireDefault(require("../../../../components/views/elements/DialogButtons"));

var _InlineSpinner = _interopRequireDefault(require("../../../../components/views/elements/InlineSpinner"));

var _RestoreKeyBackupDialog = _interopRequireDefault(require("../../../../components/views/dialogs/security/RestoreKeyBackupDialog"));

var _WellKnownUtils = require("../../../../utils/WellKnownUtils");

var _Security = _interopRequireDefault(require("../../../../customisations/Security"));

/*
Copyright 2018, 2019 New Vector Ltd
Copyright 2019, 2020 The Matrix.org Foundation C.I.C.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
const PHASE_LOADING = 0;
const PHASE_LOADERROR = 1;
const PHASE_CHOOSE_KEY_PASSPHRASE = 2;
const PHASE_MIGRATE = 3;
const PHASE_PASSPHRASE = 4;
const PHASE_PASSPHRASE_CONFIRM = 5;
const PHASE_SHOWKEY = 6;
const PHASE_STORING = 8;
const PHASE_CONFIRM_SKIP = 10;
const PASSWORD_MIN_SCORE = 4; // So secure, many characters, much complex, wow, etc, etc.
// these end up as strings from being values in the radio buttons, so just use strings

const CREATE_STORAGE_OPTION_KEY = 'key';
const CREATE_STORAGE_OPTION_PASSPHRASE = 'passphrase';
/*
 * Walks the user through the process of creating a passphrase to guard Secure
 * Secret Storage in account data.
 */

class CreateSecretStorageDialog extends _react.default.PureComponent {
  constructor(props) {
    super(props);
    (0, _defineProperty2.default)(this, "_onKeyBackupStatusChange", () => {
      if (this.state.phase === PHASE_MIGRATE) this._fetchBackupInfo();
    });
    (0, _defineProperty2.default)(this, "_onKeyPassphraseChange", e => {
      this.setState({
        passPhraseKeySelected: e.target.value
      });
    });
    (0, _defineProperty2.default)(this, "_collectRecoveryKeyNode", n => {
      this._recoveryKeyNode = n;
    });
    (0, _defineProperty2.default)(this, "_onChooseKeyPassphraseFormSubmit", async () => {
      if (this.state.passPhraseKeySelected === CREATE_STORAGE_OPTION_KEY) {
        this._recoveryKey = await _MatrixClientPeg.MatrixClientPeg.get().createRecoveryKeyFromPassphrase();
        this.setState({
          copied: false,
          downloaded: false,
          setPassphrase: false,
          phase: PHASE_SHOWKEY
        });
      } else {
        this.setState({
          copied: false,
          downloaded: false,
          phase: PHASE_PASSPHRASE
        });
      }
    });
    (0, _defineProperty2.default)(this, "_onMigrateFormSubmit", e => {
      e.preventDefault();

      if (this.state.backupSigStatus.usable) {
        this._bootstrapSecretStorage();
      } else {
        this._restoreBackup();
      }
    });
    (0, _defineProperty2.default)(this, "_onCopyClick", () => {
      const successful = (0, _strings.copyNode)(this._recoveryKeyNode);

      if (successful) {
        this.setState({
          copied: true
        });
      }
    });
    (0, _defineProperty2.default)(this, "_onDownloadClick", () => {
      const blob = new Blob([this._recoveryKey.encodedPrivateKey], {
        type: 'text/plain;charset=us-ascii'
      });

      _fileSaver.default.saveAs(blob, 'security-key.txt');

      this.setState({
        downloaded: true
      });
    });
    (0, _defineProperty2.default)(this, "_doBootstrapUIAuth", async makeRequest => {
      if (this.state.canUploadKeysWithPasswordOnly && this.state.accountPassword) {
        await makeRequest({
          type: 'm.login.password',
          identifier: {
            type: 'm.id.user',
            user: _MatrixClientPeg.MatrixClientPeg.get().getUserId()
          },
          // TODO: Remove `user` once servers support proper UIA
          // See https://github.com/matrix-org/synapse/issues/5665
          user: _MatrixClientPeg.MatrixClientPeg.get().getUserId(),
          password: this.state.accountPassword
        });
      } else {
        const InteractiveAuthDialog = sdk.getComponent("dialogs.InteractiveAuthDialog");
        const dialogAesthetics = {
          [_InteractiveAuthEntryComponents.SSOAuthEntry.PHASE_PREAUTH]: {
            title: (0, _languageHandler._t)("Use Single Sign On to continue"),
            body: (0, _languageHandler._t)("To continue, use Single Sign On to prove your identity."),
            continueText: (0, _languageHandler._t)("Single Sign On"),
            continueKind: "primary"
          },
          [_InteractiveAuthEntryComponents.SSOAuthEntry.PHASE_POSTAUTH]: {
            title: (0, _languageHandler._t)("Confirm encryption setup"),
            body: (0, _languageHandler._t)("Click the button below to confirm setting up encryption."),
            continueText: (0, _languageHandler._t)("Confirm"),
            continueKind: "primary"
          }
        };

        const {
          finished
        } = _Modal.default.createTrackedDialog('Cross-signing keys dialog', '', InteractiveAuthDialog, {
          title: (0, _languageHandler._t)("Setting up keys"),
          matrixClient: _MatrixClientPeg.MatrixClientPeg.get(),
          makeRequest,
          aestheticsForStagePhases: {
            [_InteractiveAuthEntryComponents.SSOAuthEntry.LOGIN_TYPE]: dialogAesthetics,
            [_InteractiveAuthEntryComponents.SSOAuthEntry.UNSTABLE_LOGIN_TYPE]: dialogAesthetics
          }
        });

        const [confirmed] = await finished;

        if (!confirmed) {
          throw new Error("Cross-signing key upload auth canceled");
        }
      }
    });
    (0, _defineProperty2.default)(this, "_bootstrapSecretStorage", async () => {
      this.setState({
        phase: PHASE_STORING,
        error: null
      });

      const cli = _MatrixClientPeg.MatrixClientPeg.get();

      const {
        forceReset
      } = this.props;

      try {
        if (forceReset) {
          console.log("Forcing secret storage reset");
          await cli.bootstrapSecretStorage({
            createSecretStorageKey: async () => this._recoveryKey,
            setupNewKeyBackup: true,
            setupNewSecretStorage: true
          });
        } else {
          // For password authentication users after 2020-09, this cross-signing
          // step will be a no-op since it is now setup during registration or login
          // when needed. We should keep this here to cover other cases such as:
          //   * Users with existing sessions prior to 2020-09 changes
          //   * SSO authentication users which require interactive auth to upload
          //     keys (and also happen to skip all post-authentication flows at the
          //     moment via token login)
          await cli.bootstrapCrossSigning({
            authUploadDeviceSigningKeys: this._doBootstrapUIAuth
          });
          await cli.bootstrapSecretStorage({
            createSecretStorageKey: async () => this._recoveryKey,
            keyBackupInfo: this.state.backupInfo,
            setupNewKeyBackup: !this.state.backupInfo,
            getKeyBackupPassphrase: () => {
              // We may already have the backup key if we earlier went
              // through the restore backup path, so pass it along
              // rather than prompting again.
              if (this._backupKey) {
                return this._backupKey;
              }

              return (0, _SecurityManager.promptForBackupPassphrase)();
            }
          });
        }

        this.props.onFinished(true);
      } catch (e) {
        if (this.state.canUploadKeysWithPasswordOnly && e.httpStatus === 401 && e.data.flows) {
          this.setState({
            accountPassword: '',
            accountPasswordCorrect: false,
            phase: PHASE_MIGRATE
          });
        } else {
          this.setState({
            error: e
          });
        }

        console.error("Error bootstrapping secret storage", e);
      }
    });
    (0, _defineProperty2.default)(this, "_onCancel", () => {
      this.props.onFinished(false);
    });
    (0, _defineProperty2.default)(this, "_onDone", () => {
      this.props.onFinished(true);
    });
    (0, _defineProperty2.default)(this, "_restoreBackup", async () => {
      // It's possible we'll need the backup key later on for bootstrapping,
      // so let's stash it here, rather than prompting for it twice.
      const keyCallback = k => this._backupKey = k;

      const {
        finished
      } = _Modal.default.createTrackedDialog('Restore Backup', '', _RestoreKeyBackupDialog.default, {
        showSummary: false,
        keyCallback
      }, null,
      /* priority = */
      false,
      /* static = */
      false);

      await finished;
      const {
        backupSigStatus
      } = await this._fetchBackupInfo();

      if (backupSigStatus.usable && this.state.canUploadKeysWithPasswordOnly && this.state.accountPassword) {
        this._bootstrapSecretStorage();
      }
    });
    (0, _defineProperty2.default)(this, "_onLoadRetryClick", () => {
      this.setState({
        phase: PHASE_LOADING
      });

      this._fetchBackupInfo();
    });
    (0, _defineProperty2.default)(this, "_onShowKeyContinueClick", () => {
      this._bootstrapSecretStorage();
    });
    (0, _defineProperty2.default)(this, "_onCancelClick", () => {
      this.setState({
        phase: PHASE_CONFIRM_SKIP
      });
    });
    (0, _defineProperty2.default)(this, "_onGoBackClick", () => {
      this.setState({
        phase: PHASE_CHOOSE_KEY_PASSPHRASE
      });
    });
    (0, _defineProperty2.default)(this, "_onPassPhraseNextClick", async e => {
      e.preventDefault();
      if (!this._passphraseField.current) return; // unmounting

      await this._passphraseField.current.validate({
        allowEmpty: false
      });

      if (!this._passphraseField.current.state.valid) {
        this._passphraseField.current.focus();

        this._passphraseField.current.validate({
          allowEmpty: false,
          focused: true
        });

        return;
      }

      this.setState({
        phase: PHASE_PASSPHRASE_CONFIRM
      });
    });
    (0, _defineProperty2.default)(this, "_onPassPhraseConfirmNextClick", async e => {
      e.preventDefault();
      if (this.state.passPhrase !== this.state.passPhraseConfirm) return;
      this._recoveryKey = await _MatrixClientPeg.MatrixClientPeg.get().createRecoveryKeyFromPassphrase(this.state.passPhrase);
      this.setState({
        copied: false,
        downloaded: false,
        setPassphrase: true,
        phase: PHASE_SHOWKEY
      });
    });
    (0, _defineProperty2.default)(this, "_onSetAgainClick", () => {
      this.setState({
        passPhrase: '',
        passPhraseValid: false,
        passPhraseConfirm: '',
        phase: PHASE_PASSPHRASE
      });
    });
    (0, _defineProperty2.default)(this, "_onPassPhraseValidate", result => {
      this.setState({
        passPhraseValid: result.valid
      });
    });
    (0, _defineProperty2.default)(this, "_onPassPhraseChange", e => {
      this.setState({
        passPhrase: e.target.value
      });
    });
    (0, _defineProperty2.default)(this, "_onPassPhraseConfirmChange", e => {
      this.setState({
        passPhraseConfirm: e.target.value
      });
    });
    (0, _defineProperty2.default)(this, "_onAccountPasswordChange", e => {
      this.setState({
        accountPassword: e.target.value
      });
    });
    this._recoveryKey = null;
    this._recoveryKeyNode = null;
    this._backupKey = null;
    this.state = {
      phase: PHASE_LOADING,
      passPhrase: '',
      passPhraseValid: false,
      passPhraseConfirm: '',
      copied: false,
      downloaded: false,
      setPassphrase: false,
      backupInfo: null,
      backupSigStatus: null,
      // does the server offer a UI auth flow with just m.login.password
      // for /keys/device_signing/upload?
      canUploadKeysWithPasswordOnly: null,
      accountPassword: props.accountPassword || "",
      accountPasswordCorrect: null,
      canSkip: !(0, _WellKnownUtils.isSecureBackupRequired)()
    };
    const setupMethods = (0, _WellKnownUtils.getSecureBackupSetupMethods)();

    if (setupMethods.includes("key")) {
      this.state.passPhraseKeySelected = CREATE_STORAGE_OPTION_KEY;
    } else {
      this.state.passPhraseKeySelected = CREATE_STORAGE_OPTION_PASSPHRASE;
    }

    this._passphraseField = /*#__PURE__*/(0, _react.createRef)();

    _MatrixClientPeg.MatrixClientPeg.get().on('crypto.keyBackupStatus', this._onKeyBackupStatusChange);

    if (this.state.accountPassword) {
      // If we have an account password in memory, let's simplify and
      // assume it means password auth is also supported for device
      // signing key upload as well. This avoids hitting the server to
      // test auth flows, which may be slow under high load.
      this.state.canUploadKeysWithPasswordOnly = true;
    } else {
      this._queryKeyUploadAuth();
    }

    this._getInitialPhase();
  }

  componentWillUnmount() {
    _MatrixClientPeg.MatrixClientPeg.get().removeListener('crypto.keyBackupStatus', this._onKeyBackupStatusChange);
  }

  _getInitialPhase() {
    const keyFromCustomisations = _Security.default.createSecretStorageKey?.();

    if (keyFromCustomisations) {
      console.log("Created key via customisations, jumping to bootstrap step");
      this._recoveryKey = {
        privateKey: keyFromCustomisations
      };

      this._bootstrapSecretStorage();

      return;
    }

    this._fetchBackupInfo();
  }

  async _fetchBackupInfo() {
    try {
      const backupInfo = await _MatrixClientPeg.MatrixClientPeg.get().getKeyBackupVersion();
      const backupSigStatus = // we may not have started crypto yet, in which case we definitely don't trust the backup
      _MatrixClientPeg.MatrixClientPeg.get().isCryptoEnabled() && (await _MatrixClientPeg.MatrixClientPeg.get().isKeyBackupTrusted(backupInfo));
      const {
        forceReset
      } = this.props;
      const phase = backupInfo && !forceReset ? PHASE_MIGRATE : PHASE_CHOOSE_KEY_PASSPHRASE;
      this.setState({
        phase,
        backupInfo,
        backupSigStatus
      });
      return {
        backupInfo,
        backupSigStatus
      };
    } catch (e) {
      this.setState({
        phase: PHASE_LOADERROR
      });
    }
  }

  async _queryKeyUploadAuth() {
    try {
      await _MatrixClientPeg.MatrixClientPeg.get().uploadDeviceSigningKeys(null, {}); // We should never get here: the server should always require
      // UI auth to upload device signing keys. If we do, we upload
      // no keys which would be a no-op.

      console.log("uploadDeviceSigningKeys unexpectedly succeeded without UI auth!");
    } catch (error) {
      if (!error.data || !error.data.flows) {
        console.log("uploadDeviceSigningKeys advertised no flows!");
        return;
      }

      const canUploadKeysWithPasswordOnly = error.data.flows.some(f => {
        return f.stages.length === 1 && f.stages[0] === 'm.login.password';
      });
      this.setState({
        canUploadKeysWithPasswordOnly
      });
    }
  }

  _renderOptionKey() {
    return /*#__PURE__*/_react.default.createElement(_StyledRadioButton.default, {
      key: CREATE_STORAGE_OPTION_KEY,
      value: CREATE_STORAGE_OPTION_KEY,
      name: "keyPassphrase",
      checked: this.state.passPhraseKeySelected === CREATE_STORAGE_OPTION_KEY,
      onChange: this._onKeyPassphraseChange,
      outlined: true
    }, /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_optionTitle"
    }, /*#__PURE__*/_react.default.createElement("span", {
      className: "mx_CreateSecretStorageDialog_optionIcon mx_CreateSecretStorageDialog_optionIcon_secureBackup"
    }), (0, _languageHandler._t)("Generate a Security Key")), /*#__PURE__*/_react.default.createElement("div", null, (0, _languageHandler._t)("We’ll generate a Security Key for you to store somewhere safe, like a password manager or a safe.")));
  }

  _renderOptionPassphrase() {
    return /*#__PURE__*/_react.default.createElement(_StyledRadioButton.default, {
      key: CREATE_STORAGE_OPTION_PASSPHRASE,
      value: CREATE_STORAGE_OPTION_PASSPHRASE,
      name: "keyPassphrase",
      checked: this.state.passPhraseKeySelected === CREATE_STORAGE_OPTION_PASSPHRASE,
      onChange: this._onKeyPassphraseChange,
      outlined: true
    }, /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_optionTitle"
    }, /*#__PURE__*/_react.default.createElement("span", {
      className: "mx_CreateSecretStorageDialog_optionIcon mx_CreateSecretStorageDialog_optionIcon_securePhrase"
    }), (0, _languageHandler._t)("Enter a Security Phrase")), /*#__PURE__*/_react.default.createElement("div", null, (0, _languageHandler._t)("Use a secret phrase only you know, and optionally save a Security Key to use for backup.")));
  }

  _renderPhaseChooseKeyPassphrase() {
    const setupMethods = (0, _WellKnownUtils.getSecureBackupSetupMethods)();
    const optionKey = setupMethods.includes("key") ? this._renderOptionKey() : null;
    const optionPassphrase = setupMethods.includes("passphrase") ? this._renderOptionPassphrase() : null;
    return /*#__PURE__*/_react.default.createElement("form", {
      onSubmit: this._onChooseKeyPassphraseFormSubmit
    }, /*#__PURE__*/_react.default.createElement("p", {
      className: "mx_CreateSecretStorageDialog_centeredBody"
    }, (0, _languageHandler._t)("Safeguard against losing access to encrypted messages & data by " + "backing up encryption keys on your server.")), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_primaryContainer",
      role: "radiogroup"
    }, optionKey, optionPassphrase), /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: (0, _languageHandler._t)("Continue"),
      onPrimaryButtonClick: this._onChooseKeyPassphraseFormSubmit,
      onCancel: this._onCancelClick,
      hasCancel: this.state.canSkip
    }));
  }

  _renderPhaseMigrate() {
    // TODO: This is a temporary screen so people who have the labs flag turned on and
    // click the button are aware they're making a change to their account.
    // Once we're confident enough in this (and it's supported enough) we can do
    // it automatically.
    // https://github.com/vector-im/element-web/issues/11696
    const Field = sdk.getComponent('views.elements.Field');
    let authPrompt;
    let nextCaption = (0, _languageHandler._t)("Next");

    if (this.state.canUploadKeysWithPasswordOnly) {
      authPrompt = /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("div", null, (0, _languageHandler._t)("Enter your account password to confirm the upgrade:")), /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(Field, {
        type: "password",
        label: (0, _languageHandler._t)("Password"),
        value: this.state.accountPassword,
        onChange: this._onAccountPasswordChange,
        forceValidity: this.state.accountPasswordCorrect === false ? false : null,
        autoFocus: true
      })));
    } else if (!this.state.backupSigStatus.usable) {
      authPrompt = /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("div", null, (0, _languageHandler._t)("Restore your key backup to upgrade your encryption")));
      nextCaption = (0, _languageHandler._t)("Restore");
    } else {
      authPrompt = /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("You'll need to authenticate with the server to confirm the upgrade."));
    }

    return /*#__PURE__*/_react.default.createElement("form", {
      onSubmit: this._onMigrateFormSubmit
    }, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Upgrade this session to allow it to verify other sessions, " + "granting them access to encrypted messages and marking them " + "as trusted for other users.")), /*#__PURE__*/_react.default.createElement("div", null, authPrompt), /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: nextCaption,
      onPrimaryButtonClick: this._onMigrateFormSubmit,
      hasCancel: false,
      primaryDisabled: this.state.canUploadKeysWithPasswordOnly && !this.state.accountPassword
    }, /*#__PURE__*/_react.default.createElement("button", {
      type: "button",
      className: "danger",
      onClick: this._onCancelClick
    }, (0, _languageHandler._t)('Skip'))));
  }

  _renderPhasePassPhrase() {
    return /*#__PURE__*/_react.default.createElement("form", {
      onSubmit: this._onPassPhraseNextClick
    }, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Enter a security phrase only you know, as it’s used to safeguard your data. " + "To be secure, you shouldn’t re-use your account password.")), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_passPhraseContainer"
    }, /*#__PURE__*/_react.default.createElement(_PassphraseField.default, {
      className: "mx_CreateSecretStorageDialog_passPhraseField",
      onChange: this._onPassPhraseChange,
      minScore: PASSWORD_MIN_SCORE,
      value: this.state.passPhrase,
      onValidate: this._onPassPhraseValidate,
      fieldRef: this._passphraseField,
      autoFocus: true,
      label: (0, _languageHandler._td)("Enter a Security Phrase"),
      labelEnterPassword: (0, _languageHandler._td)("Enter a Security Phrase"),
      labelStrongPassword: (0, _languageHandler._td)("Great! This Security Phrase looks strong enough."),
      labelAllowedButUnsafe: (0, _languageHandler._td)("Great! This Security Phrase looks strong enough.")
    })), /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: (0, _languageHandler._t)('Continue'),
      onPrimaryButtonClick: this._onPassPhraseNextClick,
      hasCancel: false,
      disabled: !this.state.passPhraseValid
    }, /*#__PURE__*/_react.default.createElement("button", {
      type: "button",
      onClick: this._onCancelClick,
      className: "danger"
    }, (0, _languageHandler._t)("Cancel"))));
  }

  _renderPhasePassPhraseConfirm() {
    const Field = sdk.getComponent('views.elements.Field');
    let matchText;
    let changeText;

    if (this.state.passPhraseConfirm === this.state.passPhrase) {
      matchText = (0, _languageHandler._t)("That matches!");
      changeText = (0, _languageHandler._t)("Use a different passphrase?");
    } else if (!this.state.passPhrase.startsWith(this.state.passPhraseConfirm)) {
      // only tell them they're wrong if they've actually gone wrong.
      // Security concious readers will note that if you left element-web unattended
      // on this screen, this would make it easy for a malicious person to guess
      // your passphrase one letter at a time, but they could get this faster by
      // just opening the browser's developer tools and reading it.
      // Note that not having typed anything at all will not hit this clause and
      // fall through so empty box === no hint.
      matchText = (0, _languageHandler._t)("That doesn't match.");
      changeText = (0, _languageHandler._t)("Go back to set it again.");
    }

    let passPhraseMatch = null;

    if (matchText) {
      passPhraseMatch = /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("div", null, matchText), /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(_AccessibleButton.default, {
        element: "span",
        className: "mx_linkButton",
        onClick: this._onSetAgainClick
      }, changeText)));
    }

    return /*#__PURE__*/_react.default.createElement("form", {
      onSubmit: this._onPassPhraseConfirmNextClick
    }, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Enter your Security Phrase a second time to confirm it.")), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_passPhraseContainer"
    }, /*#__PURE__*/_react.default.createElement(Field, {
      type: "password",
      onChange: this._onPassPhraseConfirmChange,
      value: this.state.passPhraseConfirm,
      className: "mx_CreateSecretStorageDialog_passPhraseField",
      label: (0, _languageHandler._t)("Confirm your Security Phrase"),
      autoFocus: true,
      autoComplete: "new-password"
    }), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_passPhraseMatch"
    }, passPhraseMatch)), /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: (0, _languageHandler._t)('Continue'),
      onPrimaryButtonClick: this._onPassPhraseConfirmNextClick,
      hasCancel: false,
      disabled: this.state.passPhrase !== this.state.passPhraseConfirm
    }, /*#__PURE__*/_react.default.createElement("button", {
      type: "button",
      onClick: this._onCancelClick,
      className: "danger"
    }, (0, _languageHandler._t)("Skip"))));
  }

  _renderPhaseShowKey() {
    let continueButton;

    if (this.state.phase === PHASE_SHOWKEY) {
      continueButton = /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
        primaryButton: (0, _languageHandler._t)("Continue"),
        disabled: !this.state.downloaded && !this.state.copied && !this.state.setPassphrase,
        onPrimaryButtonClick: this._onShowKeyContinueClick,
        hasCancel: false
      });
    } else {
      continueButton = /*#__PURE__*/_react.default.createElement("div", {
        className: "mx_CreateSecretStorageDialog_continueSpinner"
      }, /*#__PURE__*/_react.default.createElement(_InlineSpinner.default, null));
    }

    return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Store your Security Key somewhere safe, like a password manager or a safe, " + "as it’s used to safeguard your encrypted data.")), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_primaryContainer"
    }, /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_recoveryKeyContainer"
    }, /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_recoveryKey"
    }, /*#__PURE__*/_react.default.createElement("code", {
      ref: this._collectRecoveryKeyNode
    }, this._recoveryKey.encodedPrivateKey)), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_CreateSecretStorageDialog_recoveryKeyButtons"
    }, /*#__PURE__*/_react.default.createElement(_AccessibleButton.default, {
      kind: "primary",
      className: "mx_Dialog_primary",
      onClick: this._onDownloadClick,
      disabled: this.state.phase === PHASE_STORING
    }, (0, _languageHandler._t)("Download")), /*#__PURE__*/_react.default.createElement("span", null, (0, _languageHandler._t)("or")), /*#__PURE__*/_react.default.createElement(_AccessibleButton.default, {
      kind: "primary",
      className: "mx_Dialog_primary mx_CreateSecretStorageDialog_recoveryKeyButtons_copyBtn",
      onClick: this._onCopyClick,
      disabled: this.state.phase === PHASE_STORING
    }, this.state.copied ? (0, _languageHandler._t)("Copied!") : (0, _languageHandler._t)("Copy"))))), continueButton);
  }

  _renderBusyPhase() {
    const Spinner = sdk.getComponent('views.elements.Spinner');
    return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement(Spinner, null));
  }

  _renderPhaseLoadError() {
    return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Unable to query secret storage status")), /*#__PURE__*/_react.default.createElement("div", {
      className: "mx_Dialog_buttons"
    }, /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: (0, _languageHandler._t)('Retry'),
      onPrimaryButtonClick: this._onLoadRetryClick,
      hasCancel: this.state.canSkip,
      onCancel: this._onCancel
    })));
  }

  _renderPhaseSkipConfirm() {
    return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("If you cancel now, you may lose encrypted messages & data if you lose access to your logins.")), /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("You can also set up Secure Backup & manage your keys in Settings.")), /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
      primaryButton: (0, _languageHandler._t)('Go back'),
      onPrimaryButtonClick: this._onGoBackClick,
      hasCancel: false
    }, /*#__PURE__*/_react.default.createElement("button", {
      type: "button",
      className: "danger",
      onClick: this._onCancel
    }, (0, _languageHandler._t)('Cancel'))));
  }

  _titleForPhase(phase) {
    switch (phase) {
      case PHASE_CHOOSE_KEY_PASSPHRASE:
        return (0, _languageHandler._t)('Set up Secure Backup');

      case PHASE_MIGRATE:
        return (0, _languageHandler._t)('Upgrade your encryption');

      case PHASE_PASSPHRASE:
        return (0, _languageHandler._t)('Set a Security Phrase');

      case PHASE_PASSPHRASE_CONFIRM:
        return (0, _languageHandler._t)('Confirm Security Phrase');

      case PHASE_CONFIRM_SKIP:
        return (0, _languageHandler._t)('Are you sure?');

      case PHASE_SHOWKEY:
        return (0, _languageHandler._t)('Save your Security Key');

      case PHASE_STORING:
        return (0, _languageHandler._t)('Setting up keys');

      default:
        return '';
    }
  }

  render() {
    const BaseDialog = sdk.getComponent('views.dialogs.BaseDialog');
    let content;

    if (this.state.error) {
      content = /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", null, (0, _languageHandler._t)("Unable to set up secret storage")), /*#__PURE__*/_react.default.createElement("div", {
        className: "mx_Dialog_buttons"
      }, /*#__PURE__*/_react.default.createElement(_DialogButtons.default, {
        primaryButton: (0, _languageHandler._t)('Retry'),
        onPrimaryButtonClick: this._bootstrapSecretStorage,
        hasCancel: this.state.canSkip,
        onCancel: this._onCancel
      })));
    } else {
      switch (this.state.phase) {
        case PHASE_LOADING:
          content = this._renderBusyPhase();
          break;

        case PHASE_LOADERROR:
          content = this._renderPhaseLoadError();
          break;

        case PHASE_CHOOSE_KEY_PASSPHRASE:
          content = this._renderPhaseChooseKeyPassphrase();
          break;

        case PHASE_MIGRATE:
          content = this._renderPhaseMigrate();
          break;

        case PHASE_PASSPHRASE:
          content = this._renderPhasePassPhrase();
          break;

        case PHASE_PASSPHRASE_CONFIRM:
          content = this._renderPhasePassPhraseConfirm();
          break;

        case PHASE_SHOWKEY:
          content = this._renderPhaseShowKey();
          break;

        case PHASE_STORING:
          content = this._renderBusyPhase();
          break;

        case PHASE_CONFIRM_SKIP:
          content = this._renderPhaseSkipConfirm();
          break;
      }
    }

    let titleClass = null;

    switch (this.state.phase) {
      case PHASE_PASSPHRASE:
      case PHASE_PASSPHRASE_CONFIRM:
        titleClass = ['mx_CreateSecretStorageDialog_titleWithIcon', 'mx_CreateSecretStorageDialog_securePhraseTitle'];
        break;

      case PHASE_SHOWKEY:
        titleClass = ['mx_CreateSecretStorageDialog_titleWithIcon', 'mx_CreateSecretStorageDialog_secureBackupTitle'];
        break;

      case PHASE_CHOOSE_KEY_PASSPHRASE:
        titleClass = 'mx_CreateSecretStorageDialog_centeredTitle';
        break;
    }

    return /*#__PURE__*/_react.default.createElement(BaseDialog, {
      className: "mx_CreateSecretStorageDialog",
      onFinished: this.props.onFinished,
      title: this._titleForPhase(this.state.phase),
      titleClass: titleClass,
      hasCancel: this.props.hasCancel && [PHASE_PASSPHRASE].includes(this.state.phase),
      fixedWidth: false
    }, /*#__PURE__*/_react.default.createElement("div", null, content));
  }

}

exports.default = CreateSecretStorageDialog;
(0, _defineProperty2.default)(CreateSecretStorageDialog, "propTypes", {
  hasCancel: _propTypes.default.bool,
  accountPassword: _propTypes.default.string,
  forceReset: _propTypes.default.bool
});
(0, _defineProperty2.default)(CreateSecretStorageDialog, "defaultProps", {
  hasCancel: true,
  forceReset: false
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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