# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.OAuth.OAuthControllerTest do
import Pleroma.Factory
- alias Pleroma.Helpers.AuthHelper
alias Pleroma.MFA
alias Pleroma.MFA.TOTP
alias Pleroma.Repo
app: app,
conn: conn
} do
- user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
+ user = insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt("testpassword"))
registration = insert(:registration, user: nil)
redirect_uri = OAuthController.default_redirect_uri(app)
app: app,
conn: conn
} do
- user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt("testpassword"))
+ user = insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt("testpassword"))
registration = insert(:registration, user: nil)
unlisted_redirect_uri = "http://cross-site-request.com"
conn =
conn
- |> AuthHelper.put_session_token(token.token)
+ |> put_req_header("authorization", "Bearer #{token.token}")
|> get(
"/oauth/authorize",
%{
assert html_response(conn, 200) =~ ~s(type="submit")
end
- test "renders authentication page if user is already authenticated but user request with another client",
+ test "reuses authentication if the user is authenticated with another client",
%{
- app: app,
conn: conn
} do
- token = insert(:oauth_token, app: app)
+ user = insert(:user)
+
+ app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+ other_app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ token = insert(:oauth_token, user: user, app: app)
+ reusable_token = insert(:oauth_token, app: other_app, user: user)
conn =
conn
- |> AuthHelper.put_session_token(token.token)
+ |> put_req_header("authorization", "Bearer #{token.token}")
|> get(
"/oauth/authorize",
%{
"response_type" => "code",
- "client_id" => "another_client_id",
- "redirect_uri" => OAuthController.default_redirect_uri(app),
+ "client_id" => other_app.client_id,
+ "redirect_uri" => OAuthController.default_redirect_uri(other_app),
+ "scope" => "read"
+ }
+ )
+
+ assert URI.decode(redirected_to(conn)) ==
+ "https://redirect.url?access_token=#{reusable_token.token}"
+ end
+
+ test "does not reuse other people's tokens",
+ %{
+ conn: conn
+ } do
+ user = insert(:user)
+ other_user = insert(:user)
+
+ app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+ other_app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ token = insert(:oauth_token, user: user, app: app)
+ _not_reusable_token = insert(:oauth_token, app: other_app, user: other_user)
+
+ conn =
+ conn
+ |> put_req_header("authorization", "Bearer #{token.token}")
+ |> get(
+ "/oauth/authorize",
+ %{
+ "response_type" => "code",
+ "client_id" => other_app.client_id,
+ "redirect_uri" => OAuthController.default_redirect_uri(other_app),
+ "scope" => "read"
+ }
+ )
+
+ assert html_response(conn, 200) =~ ~s(type="submit")
+ end
+
+ test "does not reuse expired tokens",
+ %{
+ conn: conn
+ } do
+ user = insert(:user)
+
+ app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ other_app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ token = insert(:oauth_token, user: user, app: app)
+
+ _not_reusable_token =
+ insert(:oauth_token,
+ app: other_app,
+ user: user,
+ valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), -60 * 100)
+ )
+
+ conn =
+ conn
+ |> put_req_header("authorization", "Bearer #{token.token}")
+ |> get(
+ "/oauth/authorize",
+ %{
+ "response_type" => "code",
+ "client_id" => other_app.client_id,
+ "redirect_uri" => OAuthController.default_redirect_uri(other_app),
"scope" => "read"
}
)
assert html_response(conn, 200) =~ ~s(type="submit")
end
+ test "does not reuse tokens with the wrong scopes",
+ %{
+ conn: conn
+ } do
+ user = insert(:user)
+
+ app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ other_app = insert(:oauth_app, redirect_uris: "https://redirect.url")
+
+ token = insert(:oauth_token, user: user, app: app, scopes: ["read"])
+
+ _not_reusable_token =
+ insert(:oauth_token,
+ app: other_app,
+ user: user
+ )
+
+ conn =
+ conn
+ |> put_req_header("authorization", "Bearer #{token.token}")
+ |> get(
+ "/oauth/authorize",
+ %{
+ "response_type" => "code",
+ "client_id" => other_app.client_id,
+ "redirect_uri" => OAuthController.default_redirect_uri(other_app),
+ "scope" => "read write"
+ }
+ )
+
+ assert html_response(conn, 200) =~ ~s(type="submit")
+ end
+
test "with existing authentication and non-OOB `redirect_uri`, redirects to app with `token` and `state` params",
%{
app: app,
conn =
conn
- |> AuthHelper.put_session_token(token.token)
+ |> put_req_header("authorization", "Bearer #{token.token}")
|> get(
"/oauth/authorize",
%{
conn =
conn
- |> AuthHelper.put_session_token(token.token)
+ |> put_req_header("authorization", "Bearer #{token.token}")
|> get(
"/oauth/authorize",
%{
conn =
conn
- |> AuthHelper.put_session_token(token.token)
+ |> put_req_header("authorization", "Bearer #{token.token}")
|> get(
"/oauth/authorize",
%{
end
end
- test "authorize from cookie" do
- user = insert(:user)
- app = insert(:oauth_app)
- oauth_token = insert(:oauth_token, user: user, app: app)
- redirect_uri = OAuthController.default_redirect_uri(app)
-
- conn =
- build_conn()
- |> Plug.Session.call(Plug.Session.init(@session_opts))
- |> fetch_session()
- |> AuthHelper.put_session_token(oauth_token.token)
- |> post(
- "/oauth/authorize",
- %{
- "authorization" => %{
- "name" => user.nickname,
- "client_id" => app.client_id,
- "redirect_uri" => redirect_uri,
- "scope" => app.scopes,
- "state" => "statepassed"
- }
- }
- )
-
- target = redirected_to(conn)
- assert target =~ redirect_uri
-
- query = URI.parse(target).query |> URI.query_decoder() |> Map.new()
-
- assert %{"state" => "statepassed", "code" => code} = query
- auth = Repo.get_by(Authorization, token: code)
- assert auth
- assert auth.scopes == app.scopes
- end
-
test "redirect to on two-factor auth page" do
otp_secret = TOTP.generate_secret()
test "issues a token for `password` grant_type with valid credentials, with full permissions by default" do
password = "testpassword"
- user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
+ user = insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
app = insert(:oauth_app, scopes: ["read", "write"])
"client_secret" => app.client_secret
})
- assert %{"access_token" => token} = json_response(conn, 200)
+ assert %{"id" => id, "access_token" => access_token} = json_response(conn, 200)
- token = Repo.get_by(Token, token: token)
+ token = Repo.get_by(Token, token: access_token)
assert token
+ assert token.id == id
+ assert token.token == access_token
assert token.scopes == app.scopes
end
user =
insert(:user,
- password_hash: Pbkdf2.hash_pwd_salt(password),
+ password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password),
multi_factor_authentication_settings: %MFA.Settings{
enabled: true,
totp: %MFA.Settings.TOTP{secret: otp_secret, confirmed: true}
end
test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
- Pleroma.Config.put([:instance, :account_activation_required], true)
+ clear_config([:instance, :account_activation_required], true)
password = "testpassword"
{:ok, user} =
- insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password))
- |> User.confirmation_changeset(need_confirmation: true)
+ insert(:user, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
+ |> User.confirmation_changeset(set_confirmation: false)
|> User.update_and_set_cache()
refute Pleroma.User.account_status(user) == :active
user =
insert(:user,
- password_hash: Pbkdf2.hash_pwd_salt(password),
- deactivated: true
+ password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password),
+ is_active: false
)
app = insert(:oauth_app)
user =
insert(:user,
- password_hash: Pbkdf2.hash_pwd_salt(password),
+ password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password),
password_reset_pending: true
)
end
test "rejects token exchange for user with confirmation_pending set to true" do
- Pleroma.Config.put([:instance, :account_activation_required], true)
+ clear_config([:instance, :account_activation_required], true)
password = "testpassword"
user =
insert(:user,
- password_hash: Pbkdf2.hash_pwd_salt(password),
- confirmation_pending: true
+ password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password),
+ is_confirmed: false
)
app = insert(:oauth_app, scopes: ["read", "write"])
test "rejects token exchange for valid credentials belonging to an unapproved user" do
password = "testpassword"
- user = insert(:user, password_hash: Pbkdf2.hash_pwd_salt(password), approval_pending: true)
+ user =
+ insert(:user,
+ password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password),
+ is_approved: false
+ )
refute Pleroma.User.account_status(user) == :active
setup do: clear_config([:oauth2, :issue_new_refresh_token])
test "issues a new access token with keep fresh token" do
- Pleroma.Config.put([:oauth2, :issue_new_refresh_token], true)
+ clear_config([:oauth2, :issue_new_refresh_token], true)
user = insert(:user)
app = insert(:oauth_app, scopes: ["read", "write"])
end
test "issues a new access token with new fresh token" do
- Pleroma.Config.put([:oauth2, :issue_new_refresh_token], false)
+ clear_config([:oauth2, :issue_new_refresh_token], false)
user = insert(:user)
app = insert(:oauth_app, scopes: ["read", "write"])
response =
build_conn()
+ |> put_req_header("authorization", "Bearer #{access_token.token}")
|> post("/oauth/token", %{
"grant_type" => "refresh_token",
"refresh_token" => access_token.refresh_token,
build_conn()
|> Plug.Session.call(Plug.Session.init(@session_opts))
|> fetch_session()
- |> AuthHelper.put_session_token(oauth_token.token)
+ |> put_req_header("authorization", "Bearer #{oauth_token.token}")
|> post("/oauth/revoke", %{"token" => oauth_token.token})
assert json_response(conn, 200)
- refute AuthHelper.get_session_token(conn)
assert Token.get_by_token(oauth_token.token) == {:error, :not_found}
end
build_conn()
|> Plug.Session.call(Plug.Session.init(@session_opts))
|> fetch_session()
- |> AuthHelper.put_session_token(oauth_token.token)
+ |> put_req_header("authorization", "Bearer #{oauth_token.token}")
|> post("/oauth/revoke", %{"token" => other_app_oauth_token.token})
assert json_response(conn, 200)
- assert AuthHelper.get_session_token(conn) == oauth_token.token
assert Token.get_by_token(other_app_oauth_token.token) == {:error, :not_found}
end
projects / akkoma / blobdiff