doorkeeper 5.1.0 → 5.3.0

data/spec/requests/flows/authorization_code_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 
 feature "Authorization Code Flow" do
   background do
+    default_scopes_exist :default
     config_is_set(:authenticate_resource_owner) { User.first || redirect_to("/sign_in") }
     client_exists
     create_resource_owner
@@ -23,13 +24,46 @@ feature "Authorization Code Flow" do
     url_should_not_have_param("error")
   end
 
+  context "when configured to check application supported grant flow" do
+    before do
+      config_is_set(:allow_grant_flow_for_client, ->(_grant_flow, client) { client.name == "admin" })
+    end
+
+    scenario "forbids the request when doesn't satisfy condition" do
+      @client.update(name: "sample app")
+
+      visit authorization_endpoint_url(client: @client)
+
+      i_should_see_translated_error_message("unauthorized_client")
+    end
+
+    scenario "allows the request when satisfies condition" do
+      @client.update(name: "admin")
+
+      visit authorization_endpoint_url(client: @client)
+      i_should_not_see_translated_error_message("unauthorized_client")
+      click_on "Authorize"
+
+      authorization_code = Doorkeeper::AccessGrant.first.token
+      create_access_token authorization_code, @client
+
+      access_token_should_exist_for(@client, @resource_owner)
+
+      should_not_have_json "error"
+
+      should_have_json "access_token", Doorkeeper::AccessToken.first.token
+      should_have_json "token_type", "Bearer"
+      should_have_json_within "expires_in", Doorkeeper::AccessToken.first.expires_in, 1
+    end
+  end
+
   context "with grant hashing enabled" do
     background do
       config_is_set(:token_secret_strategy, ::Doorkeeper::SecretStoring::Sha256Hash)
     end
 
-    scenario "Authorization Code Flow with hashing" do
-      @client.redirect_uri = Doorkeeper.configuration.native_redirect_uri
+    def authorize(redirect_url)
+      @client.redirect_uri = redirect_url
       @client.save!
       visit authorization_endpoint_url(client: @client)
       click_on "Authorize"
@@ -42,16 +76,28 @@ feature "Authorization Code Flow" do
       hashed_code = Doorkeeper::AccessGrant.secret_strategy.transform_secret code
       expect(hashed_code).to eq Doorkeeper::AccessGrant.first.token
 
+      [code, hashed_code]
+    end
+
+    scenario "using redirect_url urn:ietf:wg:oauth:2.0:oob" do
+      code, hashed_code = authorize("urn:ietf:wg:oauth:2.0:oob")
       expect(code).not_to eq(hashed_code)
+      i_should_see "Authorization code:"
+      i_should_see code
+      i_should_not_see hashed_code
+    end
 
+    scenario "using redirect_url urn:ietf:wg:oauth:2.0:oob:auto" do
+      code, hashed_code = authorize("urn:ietf:wg:oauth:2.0:oob:auto")
+      expect(code).not_to eq(hashed_code)
       i_should_see "Authorization code:"
       i_should_see code
       i_should_not_see hashed_code
     end
   end
 
-  scenario "resource owner authorizes using test url" do
-    @client.redirect_uri = Doorkeeper.configuration.native_redirect_uri
+  scenario "resource owner authorizes using oob url" do
+    @client.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
     @client.save!
     visit authorization_endpoint_url(client: @client)
     click_on "Authorize"
@@ -71,6 +117,17 @@ feature "Authorization Code Flow" do
     url_should_not_have_param("code_challenge_method")
   end
 
+  scenario "resource owner requests an access token without authorization code" do
+    create_access_token "", @client
+
+    access_token_should_not_exist
+
+    expect(Doorkeeper::AccessToken.count).to be_zero
+
+    should_have_json "error", "invalid_request"
+    should_have_json "error_description", translated_invalid_request_error_message(:missing_param, :code)
+  end
+
   scenario "resource owner requests an access token with authorization code" do
     visit authorization_endpoint_url(client: @client)
     click_on "Authorize"
@@ -92,12 +149,15 @@ feature "Authorization Code Flow" do
     click_on "Authorize"
 
     authorization_code = Doorkeeper::AccessGrant.first.token
-    page.driver.post token_endpoint_url(code: authorization_code, client_id: @client.uid,
-                                        redirect_uri: @client.redirect_uri)
+    page.driver.post token_endpoint_url(
+      code: authorization_code, client_id: @client.uid,
+      redirect_uri: @client.redirect_uri,
+    )
 
     expect(Doorkeeper::AccessToken.count).to be_zero
 
     should_have_json "error", "invalid_client"
+    should_have_json "error_description", translated_error_message(:invalid_client)
   end
 
   scenario "resource owner requests an access token with authorization code but without client id" do
@@ -105,12 +165,15 @@ feature "Authorization Code Flow" do
     click_on "Authorize"
 
     authorization_code = Doorkeeper::AccessGrant.first.token
-    page.driver.post token_endpoint_url(code: authorization_code, client_secret: @client.secret,
-                                        redirect_uri: @client.redirect_uri)
+    page.driver.post token_endpoint_url(
+      code: authorization_code, client_secret: @client.secret,
+      redirect_uri: @client.redirect_uri,
+    )
 
     expect(Doorkeeper::AccessToken.count).to be_zero
 
     should_have_json "error", "invalid_client"
+    should_have_json "error_description", translated_error_message(:invalid_client)
   end
 
   scenario "silently authorizes if matching token exists" do
@@ -136,7 +199,7 @@ feature "Authorization Code Flow" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "plain"
+          code_challenge_method: "plain",
         )
         click_on "Authorize"
 
@@ -153,13 +216,14 @@ feature "Authorization Code Flow" do
         create_access_token authorization_code, @client, code_verifier
 
         should_have_json "error", "invalid_grant"
+        should_have_json "error_description", translated_error_message(:invalid_grant)
       end
 
       scenario "mobile app requests an access token with authorization code and plain code challenge method" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "plain"
+          code_challenge_method: "plain",
         )
         click_on "Authorize"
 
@@ -175,17 +239,36 @@ feature "Authorization Code Flow" do
         should_have_json_within "expires_in", Doorkeeper::AccessToken.first.expires_in, 1
       end
 
-      scenario "mobile app requests an access token with authorization code and code_challenge" do
-        visit authorization_endpoint_url(client: @client,
-                                         code_challenge: code_verifier,
-                                         code_challenge_method: "plain")
+      scenario "mobile app requests an access token with authorization code but without code_verifier" do
+        visit authorization_endpoint_url(
+          client: @client,
+          code_challenge: code_challenge,
+          code_challenge_method: "plain",
+        )
+        click_on "Authorize"
+
+        authorization_code = current_params["code"]
+        create_access_token authorization_code, @client, nil
+
+        should_not_have_json "access_token"
+        should_have_json "error", "invalid_request"
+        should_have_json "error_description", translated_invalid_request_error_message(:missing_param, :code_verifier)
+      end
+
+      scenario "mobile app requests an access token with authorization code with wrong code_verifier" do
+        visit authorization_endpoint_url(
+          client: @client,
+          code_challenge: code_challenge,
+          code_challenge_method: "plain",
+        )
         click_on "Authorize"
 
         authorization_code = current_params["code"]
-        create_access_token authorization_code, @client, code_verifier: nil
+        create_access_token authorization_code, @client, "wrong_code_verifier"
 
         should_not_have_json "access_token"
         should_have_json "error", "invalid_grant"
+        should_have_json "error_description", translated_error_message(:invalid_grant)
       end
     end
 
@@ -197,7 +280,7 @@ feature "Authorization Code Flow" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
@@ -210,7 +293,7 @@ feature "Authorization Code Flow" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
@@ -226,32 +309,24 @@ feature "Authorization Code Flow" do
         should_have_json_within "expires_in", Doorkeeper::AccessToken.first.expires_in, 1
       end
 
-      scenario "mobile app requests an access token with authorization code and without code_verifier" do
-        visit authorization_endpoint_url(
-          client: @client,
-          code_challenge: code_challenge,
-          code_challenge_method: "S256"
-        )
-        click_on "Authorize"
-        authorization_code = current_params["code"]
-        create_access_token authorization_code, @client
-        should_have_json "error", "invalid_request"
-        should_not_have_json "access_token"
-      end
-
       scenario "mobile app requests an access token with authorization code and without secret" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
         authorization_code = current_params["code"]
-        page.driver.post token_endpoint_url(code: authorization_code, client_id: @client.uid,
-                                            redirect_uri: @client.redirect_uri, code_verifier: code_verifier)
-        should_have_json "error", "invalid_client"
+        page.driver.post token_endpoint_url(
+          code: authorization_code,
+          client_id: @client.uid,
+          redirect_uri: @client.redirect_uri,
+          code_verifier: code_verifier,
+        )
         should_not_have_json "access_token"
+        should_have_json "error", "invalid_client"
+        should_have_json "error_description", translated_error_message(:invalid_client)
       end
 
       scenario "mobile app requests an access token with authorization code and without secret but is marked as not confidential" do
@@ -264,7 +339,7 @@ feature "Authorization Code Flow" do
           code: authorization_code,
           client_id: @client.uid,
           redirect_uri: @client.redirect_uri,
-          code_verifier: code_verifier
+          code_verifier: code_verifier,
         )
         should_not_have_json "error"
 
@@ -277,7 +352,7 @@ feature "Authorization Code Flow" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
@@ -286,13 +361,14 @@ feature "Authorization Code Flow" do
 
         should_not_have_json "access_token"
         should_have_json "error", "invalid_request"
+        should_have_json "error_description", translated_invalid_request_error_message(:missing_param, :code_verifier)
       end
 
       scenario "mobile app requests an access token with authorization code with wrong verifier" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
@@ -301,13 +377,14 @@ feature "Authorization Code Flow" do
 
         should_not_have_json "access_token"
         should_have_json "error", "invalid_grant"
+        should_have_json "error_description", translated_error_message(:invalid_grant)
       end
 
       scenario "code_challenge_mehthod in token request is totally ignored" do
         visit authorization_endpoint_url(
           client: @client,
           code_challenge: code_challenge,
-          code_challenge_method: "S256"
+          code_challenge_method: "S256",
         )
         click_on "Authorize"
 
@@ -316,11 +393,12 @@ feature "Authorization Code Flow" do
           code: authorization_code,
           client: @client,
           code_verifier: code_challenge,
-          code_challenge_method: "plain"
+          code_challenge_method: "plain",
         )
 
         should_not_have_json "access_token"
         should_have_json "error", "invalid_grant"
+        should_have_json "error_description", translated_error_message(:invalid_grant)
       end
 
       scenario "expects to set code_challenge_method explicitely without fallback" do
@@ -332,16 +410,15 @@ feature "Authorization Code Flow" do
 
   context "when application scopes are present and no scope is passed" do
     background do
-      @client.update(scopes: "public write read")
+      @client.update(scopes: "public write read default")
     end
 
-    scenario "access grant has no scope" do
+    scenario "scope is invalid because default scope is different from application scope" do
       default_scopes_exist :admin
       visit authorization_endpoint_url(client: @client)
-      click_on "Authorize"
-      access_grant_should_exist_for(@client, @resource_owner)
-      grant = Doorkeeper::AccessGrant.first
-      expect(grant.scopes).to be_empty
+      response_status_should_be 200
+      i_should_not_see "Authorize"
+      i_should_see_translated_error_message :invalid_scope
     end
 
     scenario "access grant have scopes which are common in application scopees and default scopes" do
@@ -442,6 +519,7 @@ describe "Authorization Code Flow" do
 
       should_not_have_json "access_token"
       should_have_json "error", "invalid_grant"
+      should_have_json "error_description", translated_error_message(:invalid_grant)
     end
   end
 end

data/spec/requests/flows/client_credentials_spec.rb

@@ -66,6 +66,44 @@ describe "Client Credentials Request" do
     end
   end
 
+  context "when configured to check application supported grant flow" do
+    before do
+      Doorkeeper.configuration.instance_variable_set(
+        :@allow_grant_flow_for_client,
+        ->(_grant_flow, client) { client.name == "admin" },
+      )
+    end
+
+    scenario "forbids the request when doesn't satisfy condition" do
+      client.update(name: "sample app")
+
+      headers = authorization client.uid, client.secret
+      params  = { grant_type: "client_credentials" }
+
+      post "/oauth/token", params: params, headers: headers
+
+      should_have_json "error", "unauthorized_client"
+      should_have_json "error_description", translated_error_message(:unauthorized_client)
+    end
+
+    scenario "allows the request when satisfies condition" do
+      client.update(name: "admin")
+
+      headers = authorization client.uid, client.secret
+      params  = { grant_type: "client_credentials" }
+
+      post "/oauth/token", params: params, headers: headers
+
+      should_have_json "access_token", Doorkeeper::AccessToken.first.token
+      should_have_json_within "expires_in", Doorkeeper.configuration.access_token_expires_in, 1
+      should_not_have_json "scope"
+      should_not_have_json "refresh_token"
+
+      should_not_have_json "error"
+      should_not_have_json "error_description"
+    end
+  end
+
   context "when application scopes contain some of the default scopes and no scope is passed" do
     before do
       client.update(scopes: "read write public")

data/spec/requests/flows/implicit_grant_errors_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 
 feature "Implicit Grant Flow Errors" do
   background do
+    default_scopes_exist :default
     config_is_set(:authenticate_resource_owner) { User.first || redirect_to("/sign_in") }
     config_is_set(:grant_flows, ["implicit"])
     client_exists
@@ -15,20 +16,31 @@ feature "Implicit Grant Flow Errors" do
     access_token_should_not_exist
   end
 
-  [
-    %i[client_id invalid_client],
-    %i[redirect_uri invalid_redirect_uri],
-  ].each do |error|
-    scenario "displays #{error.last} error for invalid #{error.first}" do
-      visit authorization_endpoint_url(client: @client, error.first => "invalid", response_type: "token")
+  context "when validate client_id param" do
+    scenario "displays invalid_client error for invalid client_id" do
+      visit authorization_endpoint_url(client_id: "invalid", response_type: "token")
       i_should_not_see "Authorize"
-      i_should_see_translated_error_message error.last
+      i_should_see_translated_error_message :invalid_client
     end
 
-    scenario "displays #{error.last} error when #{error.first} is missing" do
-      visit authorization_endpoint_url(client: @client, error.first => "", response_type: "token")
+    scenario "displays invalid_request error when client_id is missing" do
+      visit authorization_endpoint_url(client_id: "", response_type: "token")
       i_should_not_see "Authorize"
-      i_should_see_translated_error_message error.last
+      i_should_see_translated_invalid_request_error_message :missing_param, :client_id
+    end
+  end
+
+  context "when validate redirect_uri param" do
+    scenario "displays invalid_redirect_uri error for invalid redirect_uri" do
+      visit authorization_endpoint_url(client: @client, redirect_uri: "invalid", response_type: "token")
+      i_should_not_see "Authorize"
+      i_should_see_translated_error_message :invalid_redirect_uri
+    end
+
+    scenario "displays invalid_redirect_uri error when redirect_uri is missing" do
+      visit authorization_endpoint_url(client: @client, redirect_uri: "", response_type: "token")
+      i_should_not_see "Authorize"
+      i_should_see_translated_error_message :invalid_redirect_uri
     end
   end
 end

data/spec/requests/flows/implicit_grant_spec.rb

@@ -4,6 +4,7 @@ require "spec_helper"
 
 feature "Implicit Grant Flow (feature spec)" do
   background do
+    default_scopes_exist :default
     config_is_set(:authenticate_resource_owner) { User.first || redirect_to("/sign_in") }
     config_is_set(:grant_flows, ["implicit"])
     client_exists
@@ -25,16 +26,15 @@ feature "Implicit Grant Flow (feature spec)" do
       @client.update(scopes: "public write read")
     end
 
-    scenario "access token has no scopes" do
+    scenario "scope is invalid because default scope is different from application scope" do
       default_scopes_exist :admin
       visit authorization_endpoint_url(client: @client, response_type: "token")
-      click_on "Authorize"
-      access_token_should_exist_for @client, @resource_owner
-      token = Doorkeeper::AccessToken.first
-      expect(token.scopes).to be_empty
+      response_status_should_be 200
+      i_should_not_see "Authorize"
+      i_should_see_translated_error_message :invalid_scope
     end
 
-    scenario "access token has scopes which are common in application scopees and default scopes" do
+    scenario "access token has scopes which are common in application scopes and default scopes" do
       default_scopes_exist :public, :write
       visit authorization_endpoint_url(client: @client, response_type: "token")
       click_on "Authorize"
@@ -46,6 +46,7 @@ end
 
 describe "Implicit Grant Flow (request spec)" do
   before do
+    default_scopes_exist :default
     config_is_set(:authenticate_resource_owner) { User.first || redirect_to("/sign_in") }
     config_is_set(:grant_flows, ["implicit"])
     client_exists
@@ -56,7 +57,7 @@ describe "Implicit Grant Flow (request spec)" do
     it "should return a new token each request" do
       allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(false)
 
-      token = client_is_authorized(@client, @resource_owner)
+      token = client_is_authorized(@client, @resource_owner, scopes: "default")
 
       post "/oauth/authorize",
            params: {
@@ -73,7 +74,7 @@ describe "Implicit Grant Flow (request spec)" do
     it "should return the same token if it is still accessible" do
       allow(Doorkeeper.configuration).to receive(:reuse_access_token).and_return(true)
 
-      token = client_is_authorized(@client, @resource_owner)
+      token = client_is_authorized(@client, @resource_owner, scopes: "default")
 
       post "/oauth/authorize",
            params: {

data/spec/requests/flows/password_spec.rb

@@ -31,6 +31,43 @@ describe "Resource Owner Password Credentials Flow" do
     context "with non-confidential/public client" do
       let(:client_attributes) { { confidential: false } }
 
+      context "when configured to check application supported grant flow" do
+        before do
+          Doorkeeper.configuration.instance_variable_set(
+            :@allow_grant_flow_for_client,
+            ->(_grant_flow, client) { client.name == "admin" },
+          )
+        end
+
+        scenario "forbids the request when doesn't satisfy condition" do
+          @client.update(name: "sample app")
+
+          expect do
+            post password_token_endpoint_url(
+              client_id: @client.uid,
+              client_secret: "foobar",
+              resource_owner: @resource_owner,
+            )
+          end.not_to(change { Doorkeeper::AccessToken.count })
+
+          expect(response.status).to eq(401)
+          should_have_json "error", "invalid_client"
+        end
+
+        scenario "allows the request when satisfies condition" do
+          @client.update(name: "admin")
+
+          expect do
+            post password_token_endpoint_url(client_id: @client.uid, resource_owner: @resource_owner)
+          end.to change { Doorkeeper::AccessToken.count }.by(1)
+
+          token = Doorkeeper::AccessToken.first
+
+          expect(token.application_id).to eq @client.id
+          should_have_json "access_token", token.token
+        end
+      end
+
       context "when client_secret absent" do
         it "should issue new token" do
           expect do
@@ -62,7 +99,7 @@ describe "Resource Owner Password Credentials Flow" do
               post password_token_endpoint_url(
                 client_id: @client.uid,
                 client_secret: "foobar",
-                resource_owner: @resource_owner
+                resource_owner: @resource_owner,
               )
             end.not_to(change { Doorkeeper::AccessToken.count })
 
@@ -204,9 +241,11 @@ describe "Resource Owner Password Credentials Flow" do
 
   context "with invalid scopes" do
     subject do
-      post password_token_endpoint_url(client: @client,
-                                       resource_owner: @resource_owner,
-                                       scope: "random")
+      post password_token_endpoint_url(
+        client: @client,
+        resource_owner: @resource_owner,
+        scope: "random",
+      )
     end
 
     it "should not issue new token" do
@@ -226,9 +265,11 @@ describe "Resource Owner Password Credentials Flow" do
   context "with invalid user credentials" do
     it "should not issue new token with bad password" do
       expect do
-        post password_token_endpoint_url(client: @client,
-                                         resource_owner_username: @resource_owner.name,
-                                         resource_owner_password: "wrongpassword")
+        post password_token_endpoint_url(
+          client: @client,
+          resource_owner_username: @resource_owner.name,
+          resource_owner_password: "wrongpassword",
+        )
       end.to_not(change { Doorkeeper::AccessToken.count })
     end
 
@@ -237,14 +278,30 @@ describe "Resource Owner Password Credentials Flow" do
         post password_token_endpoint_url(client: @client)
       end.to_not(change { Doorkeeper::AccessToken.count })
     end
+
+    it "should not issue new token if resource_owner_from_credentials returned false or nil" do
+      config_is_set(:resource_owner_from_credentials) { false }
+
+      expect do
+        post password_token_endpoint_url(client: @client)
+      end.to_not(change { Doorkeeper::AccessToken.count })
+
+      config_is_set(:resource_owner_from_credentials) { nil }
+
+      expect do
+        post password_token_endpoint_url(client: @client)
+      end.to_not(change { Doorkeeper::AccessToken.count })
+    end
   end
 
   context "with invalid confidential client credentials" do
     it "should not issue new token with bad client credentials" do
       expect do
-        post password_token_endpoint_url(client_id: @client.uid,
-                                         client_secret: "bad_secret",
-                                         resource_owner: @resource_owner)
+        post password_token_endpoint_url(
+          client_id: @client.uid,
+          client_secret: "bad_secret",
+          resource_owner: @resource_owner,
+        )
       end.to_not(change { Doorkeeper::AccessToken.count })
     end
   end