Skip to content

A platform for community discussion. Free, open, simple.

22.4 KB
Raw Blame
# frozen_string_literal: true

describe OAuth2BasicAuthenticator do
  describe "configuration" do
    let(:authenticator) { described_class.new }

    before do
      SiteSetting.oauth2_client_id = "client"
      SiteSetting.oauth2_client_secret = ""
      SiteSetting.oauth2_authorize_url = "https://id.example.com/authorize"
      SiteSetting.oauth2_token_url = "https://id.example.com/token"
    end

    it "allows the provider to be enabled with an empty client secret" do
      SiteSetting.oauth2_enabled = true

      expect(authenticator.required_settings).to eq(
        %i[oauth2_client_id oauth2_authorize_url oauth2_token_url],
      )
      expect(authenticator).to be_configured
      expect(authenticator).to be_enabled
    end

    it "still requires the client ID and endpoint URLs" do
      SiteSetting.oauth2_enabled = true

      authenticator.required_settings.each do |setting|
        value = SiteSetting.public_send(setting)
        SiteSetting.public_send("#{setting}=", "")

        expect(authenticator).not_to be_configured
        expect(authenticator).not_to be_enabled

        SiteSetting.public_send("#{setting}=", value)
      end
    end
  end

  describe "after_authenticate" do
    before { SiteSetting.oauth2_user_json_url = "https://provider.com/user" }

    let(:user) { Fabricate(:user) }
    let(:authenticator) { OAuth2BasicAuthenticator.new }

    let(:auth) do
      OmniAuth::AuthHash.new(
        "provider" => "oauth2_basic",
        "credentials" => {
          token: "token",
        },
        "uid" => "123456789",
        "info" => {
          id: "id",
        },
        "extra" => {
        },
      )
    end

    before(:each) { SiteSetting.oauth2_email_verified = true }

    it "finds user by email" do
      authenticator.expects(:fetch_user_details).returns(email: user.email)
      result = authenticator.after_authenticate(auth)
      expect(result.user).to eq(user)
    end

    it "validates user email if provider has verified" do
      SiteSetting.oauth2_email_verified = false
      authenticator.stubs(:fetch_user_details).returns(email: user.email, email_verified: true)
      result = authenticator.after_authenticate(auth)
      expect(result.email_valid).to eq(true)
    end

    it "doesn't validate user email if provider hasn't verified" do
      SiteSetting.oauth2_email_verified = false
      authenticator.stubs(:fetch_user_details).returns(email: user.email, email_verified: nil)
      result = authenticator.after_authenticate(auth)
      expect(result.email_valid).to eq(false)
    end

    it "doesn't affect the site setting" do
      SiteSetting.oauth2_email_verified = true
      authenticator.stubs(:fetch_user_details).returns(email: user.email, email_verified: false)
      result = authenticator.after_authenticate(auth)
      expect(result.email_valid).to eq(true)
    end

    it "handles true/false strings from identity provider" do
      SiteSetting.oauth2_email_verified = false
      authenticator.stubs(:fetch_user_details).returns(email: user.email, email_verified: "true")
      result = authenticator.after_authenticate(auth)
      expect(result.email_valid).to eq(true)

      authenticator.stubs(:fetch_user_details).returns(email: user.email, email_verified: "false")
      result = authenticator.after_authenticate(auth)
      expect(result.email_valid).to eq(false)
    end

    it "only accepts explicit verified email values" do
      SiteSetting.oauth2_email_verified = false

      [true, "true", "True", "TRUE"].each do |email_verified|
        expect(
          authenticator.primary_email_verified?(auth.deep_merge(info: { email_verified: })),
        ).to eq(true)
      end

      [false, nil, "false", "pending", 0, [], {}].each do |email_verified|
        expect(
          authenticator.primary_email_verified?(auth.deep_merge(info: { email_verified: })),
        ).to eq(false)
      end
    end

    describe "fetch_user_details" do
      before(:each) do
        SiteSetting.oauth2_fetch_user_details = true
        SiteSetting.oauth2_user_json_url = "https://provider.com/user"
        SiteSetting.oauth2_user_json_url_method = "GET"
        SiteSetting.oauth2_json_email_path = "account.email"
      end

      let(:success_response) do
        { status: 200, body: '{"account":{"email":"[email protected]"}}' }
      end

      let(:fail_response) { { status: 403 } }

      it "supports GET and POST requests" do
        stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(success_response)
        result = authenticator.after_authenticate(auth)
        expect(result.email).to eq("[email protected]")

        SiteSetting.oauth2_user_json_url_method = "POST"
        stub_request(:post, SiteSetting.oauth2_user_json_url).to_return(success_response)
        result = authenticator.after_authenticate(auth)
        expect(result.email).to eq("[email protected]")
      end

      it "returns an standardised result if the http request fails" do
        stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(fail_response)
        result = authenticator.after_authenticate(auth)
        expect(result.failed).to eq(true)

        SiteSetting.oauth2_user_json_url_method = "POST"
        stub_request(:post, SiteSetting.oauth2_user_json_url).to_return(fail_response)
        result = authenticator.after_authenticate(auth)
        expect(result.failed).to eq(true)
      end

      it "returns a standardised result if the request times out" do
        stub_request(:get, SiteSetting.oauth2_user_json_url).to_timeout
        result = authenticator.after_authenticate(auth)
        expect(result.failed).to eq(true)
      end

      describe "fetch custom attributes" do
        after { DiscoursePluginRegistry.reset_register!(:oauth2_basic_additional_json_paths) }

        let(:response) do
          {
            status: 200,
            body: '{"account":{"email":"[email protected]","custom_attr":"received"}}',
          }
        end

        it "stores custom attributes in the user associated account" do
          custom_path = "account.custom_attr"
          DiscoursePluginRegistry.register_oauth2_basic_additional_json_path(
            custom_path,
            Plugin::Instance.new,
          )
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(response)

          result = authenticator.after_authenticate(auth)
          associated_account = UserAssociatedAccount.last

          expect(associated_account.extra[custom_path]).to eq("received")
        end
      end

      describe "group syncing" do
        before { SiteSetting.oauth2_json_groups_path = "account.groups" }

        it "sets associated_groups from the configured path" do
          body = { account: { email: "[email protected]", groups: %w[admins editors] } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.associated_groups).to eq(
            [{ id: "admins", name: "admins" }, { id: "editors", name: "editors" }],
          )
        end

        it "clears associated_groups when the path resolves to an empty array" do
          body = { account: { email: "[email protected]", groups: [] } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.associated_groups).to eq([])
        end

        it "clears associated_groups when the path doesn't resolve" do
          body = { account: { email: "[email protected]" } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.associated_groups).to eq([])
        end

        it "clears associated_groups and logs when the path resolves to a non-array" do
          body = { account: { email: "[email protected]", groups: "admins" } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.associated_groups).to eq([])
        end

        it "leaves associated_groups nil when no path is configured" do
          SiteSetting.oauth2_json_groups_path = ""
          body = { account: { email: "[email protected]", groups: %w[admins editors] } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.associated_groups).to be_nil
        end
      end

      describe "user field mappings" do
        fab!(:user_field)

        before do
          SiteSetting.oauth2_user_field_mappings = [
            { "path" => "account.department", "user_field_id" => user_field.id },
          ].to_json
        end

        it "populates user_field_values from the user JSON" do
          body = { account: { email: "[email protected]", department: "Engineering" } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.user_field_values).to eq(user_field.id.to_s => "Engineering")
        end

        it "clears the field when the path resolves to an empty string" do
          body = { account: { email: "[email protected]", department: "" } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.user_field_values).to eq(user_field.id.to_s => "")
        end

        it "skips the mapping when the path doesn't resolve" do
          body = { account: { email: "[email protected]" } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.user_field_values).to eq({})
        end

        it "joins array values with commas" do
          body = { account: { email: "[email protected]", department: %w[Eng Ops] } }.to_json
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(status: 200, body: body)

          result = authenticator.after_authenticate(auth)
          expect(result.user_field_values).to eq(user_field.id.to_s => "Eng,Ops")
        end
      end

      describe "required attributes" do
        after { DiscoursePluginRegistry.reset_register!(:oauth2_basic_required_json_paths) }

        it "'authenticates' successfully if required json path is fulfilled" do
          DiscoursePluginRegistry.register_oauth2_basic_additional_json_path(
            "account.is_legit",
            Plugin::Instance.new,
          )
          DiscoursePluginRegistry.register_oauth2_basic_required_json_path(
            { path: "extra:account.is_legit", required_value: true },
            Plugin::Instance.new,
          )

          response = {
            status: 200,
            body: '{"account":{"email":"[email protected]","is_legit":true}}',
          }
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(response)

          result = authenticator.after_authenticate(auth)
          expect(result.failed).to eq(false)
        end

        it "fails 'authentication' if required json path is unfulfilled" do
          DiscoursePluginRegistry.register_oauth2_basic_additional_json_path(
            "account.is_legit",
            Plugin::Instance.new,
          )
          DiscoursePluginRegistry.register_oauth2_basic_required_json_path(
            {
              path: "extra:account.is_legit",
              required_value: true,
              error_message: "You're not legit",
            },
            Plugin::Instance.new,
          )
          response = {
            status: 200,
            body: '{"account":{"email":"[email protected]","is_legit":false}}',
          }
          stub_request(:get, SiteSetting.oauth2_user_json_url).to_return(response)

          result = authenticator.after_authenticate(auth)
          expect(result.failed).to eq(true)
          expect(result.failed_reason).to eq("You're not legit")
        end
      end
    end

    describe "avatar downloading" do
      before do
        Jobs.run_later!
        SiteSetting.oauth2_fetch_user_details = true
        SiteSetting.oauth2_email_verified = true
      end

      let(:job_klass) { Jobs::DownloadAvatarFromUrl }

      it "enqueues a download_avatar_from_url job for existing user" do
        authenticator.expects(:fetch_user_details).returns(
          email: user.email,
          avatar: "http://avatar.example.com/avatar.png",
        )
        expect { authenticator.after_authenticate(auth) }.to change { job_klass.jobs.count }.by(1)

        job_args = job_klass.jobs.last["args"].first

        expect(job_args["url"]).to eq("http://avatar.example.com/avatar.png")
        expect(job_args["user_id"]).to eq(user.id)
        expect(job_args["associated_account_id"]).to eq(user.user_associated_accounts.first.id)
      end

      it "enqueues a download_avatar_from_url job for new user" do
        authenticator.expects(:fetch_user_details).returns(
          email: "[email protected]",
          avatar: "http://avatar.example.com/avatar.png",
        )

        auth_result = nil
        expect { auth_result = authenticator.after_authenticate(auth) }.not_to change {
          job_klass.jobs.count
        }

        expect { authenticator.after_create_account(user, auth_result) }.to change {
          job_klass.jobs.count
        }.by(1)

        job_args = job_klass.jobs.last["args"].first

        expect(job_args["url"]).to eq("http://avatar.example.com/avatar.png")
        expect(job_args["user_id"]).to eq(user.id)
        expect(job_args["associated_account_id"]).to eq(user.user_associated_accounts.first.id)
      end
    end
  end

  it "can walk json" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"user":{"id":1234,"email":{"address":"[email protected]"}}}'
    SiteSetting.oauth2_json_email_path = "user.email.address"
    result = authenticator.json_walk({}, JSON.parse(json_string), :email)

    expect(result).to eq "[email protected]"
  end

  it "allows keys containing dots, if wrapped in quotes" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"www.example.com/uid": "myuid"}'
    SiteSetting.oauth2_json_user_id_path = '"www.example.com/uid"'
    result = authenticator.json_walk({}, JSON.parse(json_string), :user_id)

    expect(result).to eq "myuid"
  end

  it "allows keys containing dots, if escaped" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"www.example.com/uid": "myuid"}'
    SiteSetting.oauth2_json_user_id_path = 'www\.example\.com/uid'
    result = authenticator.json_walk({}, JSON.parse(json_string), :user_id)

    expect(result).to eq "myuid"
  end

  it "allows keys containing literal backslashes, if escaped" do
    authenticator = OAuth2BasicAuthenticator.new
    # This 'single quoted heredoc' syntax means we don't have to escape backslashes in Ruby
    # What you see is exactly what the user would enter in the site settings
    json_string = <<~'_'.chomp
      {"www.example.com/uid\\": "myuid"}
    _
    SiteSetting.oauth2_json_user_id_path = <<~'_'.chomp
      www\.example\.com/uid\\
    _
    result = authenticator.json_walk({}, JSON.parse(json_string), :user_id)
    expect(result).to eq "myuid"
  end

  it "can walk json that contains an array" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string =
      '{"email":"[email protected]","identities":[{"user_id":"123456789","provider":"auth0","isSocial":false}]}'
    SiteSetting.oauth2_json_user_id_path = "identities.[].user_id"
    result = authenticator.json_walk({}, JSON.parse(json_string), :user_id)

    expect(result).to eq "123456789"
  end

  it "can walk json and handle an empty array" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"email":"[email protected]","identities":[]}'
    SiteSetting.oauth2_json_user_id_path = "identities.[].user_id"
    result = authenticator.json_walk({}, JSON.parse(json_string), :user_id)

    expect(result).to eq nil
  end

  it "can walk json and find values by index in an array" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"emails":[{"value":"[email protected]"},{"value":"[email protected]"}]}'
    SiteSetting.oauth2_json_email_path = "emails[1].value"
    result = authenticator.json_walk({}, JSON.parse(json_string), :email)

    expect(result).to eq "[email protected]"
  end

  it "can walk json and download avatar" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"user":{"avatar":"http://example.com/1.png"}}'
    SiteSetting.oauth2_json_avatar_path = "user.avatar"
    result = authenticator.json_walk({}, JSON.parse(json_string), :avatar)

    expect(result).to eq "http://example.com/1.png"
  end

  it "can walk json and appropriately assign a `false`" do
    authenticator = OAuth2BasicAuthenticator.new
    json_string = '{"user":{"id":1234, "data": {"address":"[email protected]", "is_cat": false}}}'
    SiteSetting.oauth2_json_email_verified_path = "user.data.is_cat"
    result =
      authenticator.json_walk(
        {},
        JSON.parse(json_string),
        "extra:user.data.is_cat",
        custom_path: "user.data.is_cat",
      )

    expect(result).to eq false
  end

  describe "debug logging" do
    let(:authenticator) { described_class.new }
    let(:messages) { [] }

    before do
      SiteSetting.oauth2_debug_auth = true
      allow(Rails.logger).to receive(:warn) { |message| messages << message }
    end

    it "redacts bearer credentials and URL substitutions and omits the user response" do
      access_token = "access-token-value"
      provider_id = "provider-user-id"
      response_secret = "response-client-secret"
      response_email = "[email protected]"
      SiteSetting.oauth2_user_json_url =
        "https://provider.com/users/:id/tokens/:token?access_token=query-token-value&view=profile"
      SiteSetting.oauth2_json_email_path = "account.email"
      response_body = {
        account: {
          email: response_email,
          client_secret: response_secret,
          refresh_token: "response-refresh-token",
        },
      }.to_json
      user_json_url =
        "https://provider.com/users/#{provider_id}/tokens/#{access_token}?access_token=query-token-value&view=profile"
      request =
        stub_request(:get, user_json_url).with(
          headers: {
            "Authorization" => "Bearer #{access_token}",
          },
        ).to_return(status: 200, body: response_body)

      result = authenticator.fetch_user_details(access_token, provider_id)

      expect(result[:email]).to eq(response_email)
      expect(request).to have_been_requested.once
      expect(messages.join).to include("view=profile", "[FILTERED]", "[OMITTED]")
      expect(messages.join).not_to include(
        access_token,
        "query-token-value",
        provider_id,
        response_secret,
        response_email,
        "response-refresh-token",
      )
    end

    it "redacts credentials, identity information, and extra authentication data" do
      auth =
        OmniAuth::AuthHash.new(
          "provider" => "oauth2_basic",
          "credentials" => {
            "token" => "access-token-value",
            "refresh_token" => "refresh-token-value",
          },
          "uid" => "provider-user-id",
          "info" => {
            "name" => "Private Name",
            "email" => "[email protected]",
          },
          "extra" => {
            "id_token" => "id-token-value",
          },
        )
      original_auth = auth.deep_dup
      SiteSetting.oauth2_callback_user_id_path = "uid"
      SiteSetting.oauth2_fetch_user_details = false
      SiteSetting.oauth2_email_verified = true

      authenticator.after_authenticate(auth)

      expect(messages.join).to include("after_authenticate response", "[FILTERED]")
      expect(messages.join).not_to include(
        "access-token-value",
        "refresh-token-value",
        "provider-user-id",
        "Private Name",
        "[email protected]",
        "id-token-value",
      )
      expect(auth).to eq(original_auth)
    end
  end

  describe "token_callback" do
    let(:user) { Fabricate(:user) }
    let(:strategy) { OmniAuth::Strategies::Oauth2Basic.new({}) }
    let(:authenticator) { OAuth2BasicAuthenticator.new }

    let(:auth) do
      OmniAuth::AuthHash.new(
        "provider" => "oauth2_basic",
        "credentials" => {
          "token" => "token",
        },
        "uid" => "e028b1b918853eca7fba208a9d7e9d29a6e93c57",
        "info" => {
          "name" => "Sammy the Shark",
          "email" => "[email protected]",
        },
        "extra" => {
        },
      )
    end

    let(:access_token) do
      {
        "params" => {
          "info" => {
            "name" => "Sammy the Shark",
            "email" => "[email protected]",
            "uuid" => "e028b1b918853eca7fba208a9d7e9d29a6e93c57",
          },
        },
      }
    end

    before(:each) do
      SiteSetting.oauth2_callback_user_id_path = "params.info.uuid"
      SiteSetting.oauth2_callback_user_info_paths = "name:params.info.name|email:params.info.email"
    end

    it "can retrieve user id from access token callback" do
      strategy.stubs(:access_token).returns(access_token)
      expect(strategy.uid).to eq "e028b1b918853eca7fba208a9d7e9d29a6e93c57"
    end

    it "can retrieve user properties from access token callback" do
      strategy.stubs(:access_token).returns(access_token)
      expect(strategy.info["name"]).to eq "Sammy the Shark"
      expect(strategy.info["email"]).to eq "[email protected]"
    end

    it "does apply user properties from access token callback in after_authenticate" do
      SiteSetting.oauth2_fetch_user_details = true
      authenticator.stubs(:fetch_user_details).returns(email: "[email protected]")
      result = authenticator.after_authenticate(auth)

      expect(result.extra_data[:uid]).to eq "e028b1b918853eca7fba208a9d7e9d29a6e93c57"
      expect(result.name).to eq "Sammy the Shark"
      expect(result.email).to eq "[email protected]"
    end

    it "does work if user details are not fetched" do
      SiteSetting.oauth2_fetch_user_details = false
      result = authenticator.after_authenticate(auth)

      expect(result.extra_data[:uid]).to eq "e028b1b918853eca7fba208a9d7e9d29a6e93c57"
      expect(result.name).to eq "Sammy the Shark"
      expect(result.email).to eq "[email protected]"
    end
  end
end