Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
defmodule Plausible.OAuthTest do
@moduledoc """
Covers OAuth grant lifecycle.
- `Step 1: create_authorization_code/3` issues a single-use code bound to a user,
team, scopes and resource
- `Step 2: consume_authorization_code/2` redeems that code, exactly once
- `Step 3: issue_token/1 and find_access_token/2`: opens a grant from the redeemed code, returns token AND resolves an access token back to its grant
- `Step 4: revoke_grant/1 and after_user_removed_from_team/2` invalidates both tokens
- `Step 5: refresh_token/2` rotates both tokens
Also covers the connected apps view: `list_grants/1` and `revoke_user_grant/2`.
"""
use Plausible.DataCase
use Plausible.Test.Support.DNS
alias Plausible.OAuth
alias Plausible.OAuth.{AuthorizationCode, Grant, ProtectedResources, Token}
@client_id "https://client.example.com/oauth-metadata"
@redirect_uri "https://client.example.com/callback"
setup [:create_user, :create_team]
describe "Step 1: create_authorization_code/3" do
test "refuses a resource this server does not know", %{user: user, team: team} do
{_verifier, challenge} = pkce()
for resource <- ["https://elsewhere.example.com/mcp", nil] do
assert {:error, :invalid_target} =
create_code(user, team, challenge, %{resource: resource})
end
assert Plausible.Repo.aggregate(AuthorizationCode, :count) == 0
end
test "refuses a scope set this server cannot grant", %{user: user, team: team} do
{_verifier, challenge} = pkce()
for scopes <- [
["sites:read:*", "admin:write"],
nil,
[],
"",
Enum.join(supported_scopes(), " ")
] do
assert {:error, :invalid_scope} = create_code(user, team, challenge, %{scopes: scopes})
end
assert Plausible.Repo.aggregate(AuthorizationCode, :count) == 0
end
test "stores a code bound to the user, team, scopes and resource", %{user: user, team: team} do
{_verifier, challenge} = pkce()
assert {:ok, raw_code} = create_code(user, team, challenge)
stored = Plausible.Repo.one!(AuthorizationCode)
assert_matches %AuthorizationCode{
code_hash: ^Token.hash(raw_code),
client_id: ^@client_id,
redirect_uri: ^@redirect_uri,
code_challenge: ^challenge,
code_challenge_method: "S256",
scopes: ^supported_scopes(),
resource: ^resource(),
user_id: ^user.id,
team_id: ^team.id
} = stored
assert NaiveDateTime.compare(stored.expires_at, NaiveDateTime.utc_now()) == :gt
end
end
describe "Step 2: consume_authorization_code/2" do
test "rejects an unknown code" do
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code("nope", %{
verifier: "v",
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
test "rejects when the presented values don't match the code", %{user: user, team: team} do
for override <- [
%{client_id: "https://other.example.com/oauth-metadata"},
%{client_id: nil},
%{redirect_uri: "https://client.example.com/other"},
%{resource: "https://elsewhere.example.com/mcp"}
] do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
presented =
Map.merge(
%{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
},
override
)
assert {:error, :invalid_grant} = OAuth.consume_authorization_code(code, presented)
end
end
test "rejects an expired code", %{user: user, team: team} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
Plausible.Repo.update_all(
from(c in AuthorizationCode, where: c.code_hash == ^Token.hash(code)),
set: [expires_at: past()]
)
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
test "rejects a code whose user has since left the team", %{user: user, team: team} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
Plausible.Repo.delete_all(
from(tm in Plausible.Teams.Membership,
where: tm.user_id == ^user.id and tm.team_id == ^team.id
)
)
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
test "rejects a code whose user has since been downgraded to guest" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
{verifier, challenge} = pkce()
{:ok, code} = create_code(member, team, challenge)
Plausible.Teams.Membership
|> Repo.get_by!(team_id: team.id, user_id: member.id)
|> Ecto.Changeset.change(role: :guest)
|> Repo.update!()
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
test "returns the code and binds user, team and scopes", %{user: user, team: team} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
assert {:ok, consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
assert_matches %AuthorizationCode{
user_id: ^user.id,
team_id: ^team.id,
scopes: ^supported_scopes(),
client_id: ^@client_id
} = consumed_code
end
test "burns the code on successful consume, it can't be consumed twice", %{
user: user,
team: team
} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
assert {:ok, _consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
test "burns the code even when validation fails, can't guess verifier", %{
user: user,
team: team
} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: "wrong-verifier",
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
assert {:error, :invalid_grant} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
end
end
describe "Step 3: issue_token/1 and find_access_token/2" do
test "rejects an unknown token" do
assert {:error, :invalid_token} = OAuth.find_access_token("made-up", mcp())
end
test "rejects a live token presented to a resource it was not issued for", %{
user: user,
team: team
} do
{_grant, access_token} = issue_grant(user, team)
assert {:error, :invalid_token} =
OAuth.find_access_token(access_token, %{
resource_path: "/elsewhere",
scopes_supported: []
})
# Verify that the token works for the correct resource.
assert {:ok, _grant, _role} = OAuth.find_access_token(access_token, mcp())
end
test "rejects an expired token", %{user: user, team: team} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
{:ok, consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
{:ok, response} = OAuth.issue_token(consumed_code)
Plausible.Repo.update_all(
from(g in Grant, where: g.access_token_hash == ^Token.hash(response.access_token)),
set: [access_token_expires_at: past(), refresh_token_expires_at: past()]
)
assert {:error, :invalid_token} = OAuth.find_access_token(response.access_token, mcp())
end
test "issues a bearer token resolving to the code's user, team and scopes", %{
user: user,
team: team
} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge, %{scopes: ["sites:read:*"]})
{:ok, consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
assert {:ok, response} = OAuth.issue_token(consumed_code)
assert_matches ^strict_map(%{
access_token: ^any(:string),
refresh_token: ^any(:string),
token_type: "Bearer",
expires_in: ^OAuth.access_token_ttl_seconds(),
scope: "sites:read:*"
}) = response
assert {:ok, token, _role} = OAuth.find_access_token(response.access_token, mcp())
resource = resource()
assert_matches %Grant{
user: %{id: ^user.id},
team: %{id: ^team.id},
scopes: ["sites:read:*"],
resource: ^resource
} = token
end
test "does not persist the raw token", %{user: user, team: team} do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge)
{:ok, consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
{:ok, response} = OAuth.issue_token(consumed_code)
stored =
Plausible.Repo.one!(
from g in Grant, where: g.access_token_hash == ^Token.hash(response.access_token)
)
assert_matches %Grant{
access_token_hash: ^Token.hash(response.access_token),
access_token_hint: ^String.slice(response.access_token, -4, 4)
} = stored
end
test "an access token stops resolving once the user leaves the team" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
{_grant, access_token} = issue_grant(member, team)
assert {:ok, _, _role} = OAuth.find_access_token(access_token, mcp())
Plausible.Teams.Membership
|> Repo.get_by!(team_id: team.id, user_id: member.id)
|> Repo.delete!()
assert {:error, :invalid_token} = OAuth.find_access_token(access_token, mcp())
end
test "an access token stops resolving once the user is demoted to guest" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
{_grant, access_token} = issue_grant(member, team)
assert {:ok, _, :editor} = OAuth.find_access_token(access_token, mcp())
Plausible.Teams.Membership
|> Repo.get_by!(team_id: team.id, user_id: member.id)
|> Ecto.Changeset.change(role: :guest)
|> Repo.update!()
assert {:error, :invalid_token} = OAuth.find_access_token(access_token, mcp())
end
end
describe "Step 4: revoke_grant/1 and after_user_removed_from_team/2" do
test "invalidates the grant's access token", %{user: user, team: team} do
{grant, access_token} = issue_grant(user, team)
assert :ok = OAuth.revoke_grant(grant)
assert {:error, :invalid_token} = OAuth.find_access_token(access_token, mcp())
end
test "keeps the original revoked_at when repeated", %{user: user, team: team} do
{grant, _access_token} = issue_grant(user, team)
assert :ok = OAuth.revoke_grant(grant)
revoked_at = past()
Plausible.Repo.update_all(
from(g in Grant, where: g.id == ^grant.id),
set: [revoked_at: revoked_at]
)
assert :ok = OAuth.revoke_grant(grant)
assert_matches %Grant{revoked_at: ^revoked_at} = Plausible.Repo.get!(Grant, grant.id)
end
test "removing a member revokes the grants they held against the team" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
{grant, access_token} = issue_grant(member, team)
other_owner = new_user()
{:ok, other_team} = Plausible.Teams.get_or_create(other_owner)
add_member(other_team, role: :editor, user: member)
{kept, kept_token} = issue_grant(member, other_team)
assert {:ok, _} =
Plausible.Teams.Memberships.Remove.remove(team, member.id, owner,
send_email?: false
)
assert %Grant{revoked_at: revoked_at} = Plausible.Repo.get!(Grant, grant.id)
assert revoked_at
assert {:error, :invalid_token} = OAuth.find_access_token(access_token, mcp())
assert_matches %Grant{revoked_at: nil} = Plausible.Repo.get!(Grant, kept.id)
assert {:ok, _, _role} = OAuth.find_access_token(kept_token, mcp())
end
test "a member leaving revokes the grants they held against the team" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
{grant, _access_token} = issue_grant(member, team)
other_owner = new_user()
{:ok, other_team} = Plausible.Teams.get_or_create(other_owner)
add_member(other_team, role: :editor, user: member)
{kept, kept_token} = issue_grant(member, other_team)
assert {:ok, _} =
Plausible.Teams.Memberships.Leave.leave(team, member, send_email?: false)
assert %Grant{revoked_at: revoked_at} = Plausible.Repo.get!(Grant, grant.id)
assert revoked_at
assert_matches %Grant{revoked_at: nil} = Plausible.Repo.get!(Grant, kept.id)
assert {:ok, _, _role} = OAuth.find_access_token(kept_token, mcp())
end
end
describe "Step 5: refresh_token/2" do
test "rejects an unknown token" do
assert {:error, :invalid_grant} = OAuth.refresh_token("made-up", %{})
assert {:error, :invalid_grant} = OAuth.refresh_token(nil, %{})
end
test "rejects a revoked grant", %{user: user, team: team} do
response_a = issue_tokens(user, team)
{:ok, grant, _role} = OAuth.find_access_token(response_a.access_token, mcp())
:ok = OAuth.revoke_grant(grant)
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
end
test "rejects an expired token", %{user: user, team: team} do
response_a = issue_tokens(user, team)
Plausible.Repo.update_all(
from(g in Grant, where: g.refresh_token_hash == ^Token.hash(response_a.refresh_token)),
set: [refresh_token_expires_at: past()]
)
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
end
test "rejects a grant whose user has since left the team" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
response_a = issue_tokens(member, team)
Plausible.Teams.Membership
|> Repo.get_by!(team_id: team.id, user_id: member.id)
|> Repo.delete!()
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
end
test "rejects a grant whose user has since been downgraded to guest" do
owner = new_user()
{:ok, team} = Plausible.Teams.get_or_create(owner)
member = add_member(team, role: :editor)
response_a = issue_tokens(member, team)
Plausible.Teams.Membership
|> Repo.get_by!(team_id: team.id, user_id: member.id)
|> Ecto.Changeset.change(role: :guest)
|> Repo.update!()
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
end
test "accepts valid refresh token, rotates access and refresh token, invalidates old access token",
%{user: user, team: team} do
response_a = issue_tokens(user, team)
assert {:ok, initial_grant, _role} = OAuth.find_access_token(response_a.access_token, mcp())
# make it about to expire
initial_grant =
initial_grant
|> Ecto.Changeset.change(
refresh_token_expires_at:
:second |> NaiveDateTime.utc_now() |> NaiveDateTime.add(5, :second)
)
|> Repo.update!()
assert {:ok, response_b} =
OAuth.refresh_token(response_a.refresh_token, %{})
assert_matches ^strict_map(%{
access_token: ^any(:string),
refresh_token: ^any(:string),
token_type: "Bearer",
expires_in: ^OAuth.access_token_ttl_seconds(),
scope: ^Enum.join(supported_scopes(), " ")
}) = response_b
refute response_b.access_token == response_a.access_token
refute response_b.refresh_token == response_a.refresh_token
assert {:error, :invalid_token} = OAuth.find_access_token(response_a.access_token, mcp())
assert {:ok, grant, _role} = OAuth.find_access_token(response_b.access_token, mcp())
assert_matches %Grant{
user_id: ^user.id,
team_id: ^team.id,
access_token_hash: ^Token.hash(response_b.access_token),
access_token_hint: ^String.slice(response_b.access_token, -4, 4),
refresh_token_hash: ^Token.hash(response_b.refresh_token),
refresh_token_hint: ^String.slice(response_b.refresh_token, -4, 4),
previous_refresh_token_hash: ^Token.hash(response_a.refresh_token),
rotated_at: %NaiveDateTime{},
revoked_at: nil
} = grant
assert NaiveDateTime.after?(
grant.refresh_token_expires_at,
initial_grant.refresh_token_expires_at
)
end
test "accepts a request specifying client ID, resource and scopes; rejects without invalidating the grant if any of them are invalid",
%{
user: user,
team: team
} do
response_a = issue_tokens(user, team)
expected_params = %{
client_id: @client_id,
resource: resource(),
scope: response_a.scope
}
assert {:ok, response_b} =
OAuth.refresh_token(response_a.refresh_token, expected_params)
for {invalid_params, expected_error} <- [
{%{expected_params | scope: "stats:write:*"}, {:error, :invalid_scope}},
{%{expected_params | client_id: "https://other.example.com/oauth-metadata"},
{:error, :invalid_grant}},
{%{expected_params | resource: "https://other.example.com/mcp"},
{:error, :invalid_grant}}
] do
assert ^expected_error = OAuth.refresh_token(response_b.refresh_token, invalid_params)
end
assert {:ok, _} = OAuth.refresh_token(response_b.refresh_token, expected_params)
end
test "replay during grace: the previous refresh token on file is accepted (to prevent loss of access when fumbling refresh attempt due to bad network)",
%{
user: user,
team: team
} do
response_a = issue_tokens(user, team)
# client presents refresh token A, it's accepted, but the client loses the response
{:ok, response_b} = OAuth.refresh_token(response_a.refresh_token, %{})
{:ok, grant_b, _role} = OAuth.find_access_token(response_b.access_token, mcp())
assert {:error, :invalid_token} = OAuth.find_access_token(response_a.access_token, mcp())
# client presents refresh token A again, it's accepted
assert {:ok, response_c} = OAuth.refresh_token(response_a.refresh_token, %{})
assert {:ok, grant_c, _role} = OAuth.find_access_token(response_c.access_token, mcp())
assert {:error, :invalid_token} = OAuth.find_access_token(response_b.access_token, mcp())
# a refresh during the grace period doesn't move rotated at
assert_matches %Grant{
id: ^grant_b.id,
previous_refresh_token_hash: ^Token.hash(response_b.refresh_token),
rotated_at: ^grant_b.rotated_at,
revoked_at: nil
} = grant_c
# refresh token A is not on file any more, so this is not considered a refresh token replay scenario, the grant is not revoked
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
assert {:ok, _grant, _role} = OAuth.find_access_token(response_c.access_token, mcp())
end
test "replay outside grace: the previous refresh token on file is rejected and the whole grant is invalidated (to protect the user from an attacker taking over the grant with a logged / leaked refresh token)",
%{
user: user,
team: team
} do
response_a = issue_tokens(user, team)
# attacker or client presents refresh token A, it's accepted
{:ok, response_b} = OAuth.refresh_token(response_a.refresh_token, %{})
{:ok, grant_b, _role} = OAuth.find_access_token(response_b.access_token, mcp())
assert {:error, :invalid_token} = OAuth.find_access_token(response_a.access_token, mcp())
grant_b
|> Ecto.Changeset.change(
rotated_at:
:second
|> NaiveDateTime.utc_now()
|> NaiveDateTime.add(
-OAuth.refresh_grace_period_seconds(),
:second
)
)
|> Repo.update!()
# attacker or client presents refresh token A, it's rejected
assert {:error, :invalid_grant} = OAuth.refresh_token(response_a.refresh_token, %{})
# both attacker and client locked out
assert {:error, :invalid_token} = OAuth.find_access_token(response_b.access_token, mcp())
assert {:error, :invalid_grant} = OAuth.refresh_token(response_b.refresh_token, %{})
assert Repo.reload!(grant_b).revoked_at
end
end
describe "list_grants/1" do
test "lists the user's live grants across teams, most recently connected first", %{
user: user,
team: team
} do
now = NaiveDateTime.utc_now(:second)
{:ok, other_team} = Plausible.Teams.get_or_create(new_user())
add_member(other_team, user: user, role: :viewer)
oldest =
insert(:oauth_grant,
user: user,
team: team,
inserted_at: NaiveDateTime.add(now, -3, :day)
)
older =
insert(:oauth_grant,
user: user,
team: other_team,
inserted_at: NaiveDateTime.add(now, -1, :day)
)
newest = insert(:oauth_grant, user: user, team: team, inserted_at: now)
assert [first, second, third] = OAuth.list_grants(user)
assert first.id == newest.id
assert second.id == older.id
assert second.team.id == other_team.id
assert third.id == oldest.id
end
test "leaves out revoked and expired grants", %{user: user, team: team} do
insert(:oauth_grant, user: user, team: team, revoked_at: past())
insert(:oauth_grant, user: user, team: team, refresh_token_expires_at: past())
assert OAuth.list_grants(user) == []
end
test "leaves out other users' grants", %{user: user, team: team} do
other_user = add_member(team, role: :editor)
insert(:oauth_grant, user: other_user, team: team)
assert OAuth.list_grants(user) == []
end
end
describe "revoke_user_grant/2" do
test "revokes the user's grant", %{user: user, team: team} do
{grant, access_token} = issue_grant(user, team)
assert :ok = OAuth.revoke_user_grant(user, to_string(grant.id))
assert %Grant{revoked_at: %NaiveDateTime{}} = Repo.reload!(grant)
assert {:error, :invalid_token} = OAuth.find_access_token(access_token, mcp())
end
test "does not revoke another user's grant", %{team: team} do
other_user = add_member(team, role: :editor)
grant = insert(:oauth_grant, user: other_user, team: team)
assert {:error, :not_found} = OAuth.revoke_user_grant(new_user(), grant.id)
assert %Grant{revoked_at: nil} = Repo.reload!(grant)
end
test "does not find an already revoked grant", %{user: user, team: team} do
revoked_at = past()
grant = insert(:oauth_grant, user: user, team: team, revoked_at: revoked_at)
assert {:error, :not_found} = OAuth.revoke_user_grant(user, grant.id)
assert_matches %Grant{revoked_at: ^revoked_at} = Repo.reload!(grant)
end
test "does not find a malformed id", %{user: user} do
assert {:error, :not_found} = OAuth.revoke_user_grant(user, "not-an-id")
end
end
defp pkce do
verifier = :crypto.strong_rand_bytes(32) |> Base.url_encode64(padding: false)
challenge = :crypto.hash(:sha256, verifier) |> Base.url_encode64(padding: false)
{verifier, challenge}
end
defp resource(), do: ProtectedResources.get_resource_url(mcp())
defp mcp(), do: ProtectedResources.mcp()
defp supported_scopes(), do: mcp().scopes_supported
defp create_code(user, team, challenge, overrides \\ %{}) do
attrs =
Map.merge(
%{
client_id: @client_id,
redirect_uri: @redirect_uri,
code_challenge: challenge,
code_challenge_method: "S256",
scopes: supported_scopes(),
resource: resource()
},
overrides
)
OAuth.create_authorization_code(user, team, attrs)
end
defp past, do: :second |> NaiveDateTime.utc_now() |> NaiveDateTime.add(-1, :second)
defp issue_grant(user, team, overrides \\ %{}) do
response = issue_tokens(user, team, overrides)
{:ok, grant, _role} = OAuth.find_access_token(response.access_token, mcp())
{grant, response.access_token}
end
defp issue_tokens(user, team, overrides \\ %{}) do
{verifier, challenge} = pkce()
{:ok, code} = create_code(user, team, challenge, overrides)
{:ok, consumed_code} =
OAuth.consume_authorization_code(code, %{
verifier: verifier,
client_id: @client_id,
redirect_uri: @redirect_uri,
resource: resource()
})
{:ok, response} = OAuth.issue_token(consumed_code)
response
end
end