Comment changer le point final par défaut du token OAuth2 de spring security?

Avec la version 2.0.5.Libération ou au-dessus de spring-security-oauth2

en une ligne de la configuration basée sur java, testée et qui fonctionne bien, d'une certaine manière, elle supplante la valeur RequestMapping de la classe TokenEndpoint.

@Configuration
@EnableAuthorizationServer
protected static class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {      

        @Override
        public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
            endpoints
                .pathMapping("/oauth/token", "<your custom endpoint>")
        }
}

j'ai eu du mal avec ça pendant quelques jours, mais que ça marche maintenant sur Le Dernier Printemps Oauth2 1.0.5.PUBLIER. Je ne suis pas sûr à 100% que ma solution soit la plus classe (Étape 4 en particulier), mais elle fonctionne et je suis capable d'aller de l'avant.

dans mon cas, je voulais supprimer le /oauth le préfixe de l'url à la fin avec juste /token et /authorize. La solution pour moi était principalement la config xml, avec deux hacks pour outrepasser les mappages de requêtes de points terminaux.

1 - dans le contexte de l'application xml, ajouter authorization-endpoint-url et token-endpoint-url attributes to your <oauth:authorization-server> élément.

Moi:

<oauth:authorization-server client-details-service-ref="clientDetailsService" token-services-ref="tokenServices" user-approval-handler-ref="userApprovalHandler" authorization-endpoint-url="/authorize" token-endpoint-url="/token">

2 - dans le contexte de l'app xml, ajuster les paramètres de sécurité en conséquence. Il devrait y en avoir deux, qui gèrent respectivement la sécurité sur les urls token et auth. Besoin de mettre à jour le modèle prop <http> et <intercept-url> balises.

Moi:

<http pattern="/token/**" create-session="stateless" authentication-manager-ref="clientAuthenticationManager" xmlns="http://www.springframework.org/schema/security">
    <intercept-url pattern="/token/**" access="IS_AUTHENTICATED_FULLY" />

...

<http pattern="/authorize/**" access-denied-page="/login.jsp?authorization_error=true" disable-url-rewriting="true" xmlns="http://www.springframework.org/schema/security">
    <intercept-url pattern="/authorize/**" access="IS_AUTHENTICATED_FULLY" />

3- (Si vous avez choisi d'utiliser le filtre optionnel clientcreeds.) Dans le contexte de l'application xml, vous devriez déjà avoir connecté clientCredentialsTokenEndpointFilter bean comme un <custom-filter> within yourelement. So, within the filter's bean, add afilterProcessesUrl la propriété.

Moi:

<bean id="clientCredentialsTokenEndpointFilter" class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
    <property name="authenticationManager" ref="clientAuthenticationManager" />
    <property name="filterProcessesUrl" value="/token" />
</bean>

4 - la dernière étape consiste à outrepasser les urls de mappage de requête des contrôleurs internes actuels. Le printemps oauth2 lib est livré avec deux classes: AuthorizationEndpoint et TokenEndpoint. Chaque utilisation @RequestMapping tapez des annotations pour lier l'url (comme nous le faisons tous pour les contrôleurs app de nos projets). Pour moi, c'était un tirage de cheveux de tenter de remplacer la valeur de la demande des mappages dans tout autre moyen que de (malheureusement) recréer le paquet classe spring dans mon dossier src, copier les classes AuthorizationEndpoint et TokenEndpoint mot à mot dans ledit dossier, et éditer le inline @RequestMapping valeurs d'annotation.

bref, ça fait l'affaire. J'aimerais entendre parler d'une façon plus gracieuse de passer outre les valeurs de mappage des requêtes du contrôleur de point final.

Merci.

Final, le travail d'application de contexte:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:sec="http://www.springframework.org/schema/security" xmlns:oauth="http://www.springframework.org/schema/security/oauth2"

  xsi:schemaLocation="
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.2.xsd
    http://www.springframework.org/schema/security/oauth2 http://www.springframework.org/schema/security/spring-security-oauth2.xsd
  "
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
>

  <!-- Declare OAuth2 services white-list. (This is the top of the config.) -->
  <oauth:authorization-server client-details-service-ref="clientDetailsService" token-services-ref="tokenServices" user-approval-handler-ref="userApprovalHandler" authorization-endpoint-url="/authorize" token-endpoint-url="/token">
    <oauth:authorization-code />
    <oauth:implicit />
    <oauth:refresh-token />
    <oauth:client-credentials />
    <!-- <oauth:password /> -->
  </oauth:authorization-server>
  <bean id="userApprovalHandler" class="org.springframework.security.oauth2.provider.approval.TokenServicesUserApprovalHandler">
    <!-- This bean bridges client auth service and user tokens... kind of an out of place requirement. -->
    <property name="tokenServices" ref="tokenServices" />
  </bean>

  <!-- This starts the far back-end config for client token management. -->
  <sec:authentication-manager id="clientAuthenticationManager">
    <sec:authentication-provider user-service-ref="clientDetailsUserService" />
  </sec:authentication-manager>
  <bean id="clientDetailsUserService" class="org.springframework.security.oauth2.provider.client.ClientDetailsUserDetailsService">
    <constructor-arg ref="clientDetailsService" />
  </bean>
  <bean id="clientDetailsService" class="com.mycompany.oauth.spring.security.oauth2.IntegratedOauth2ClientDetailsService">
    <!-- This bean is what wires OAuth2 into the persistence stack for client details stored in the oauth_client table. -->
  </bean>


  <!-- OAuth is layered on to spring security which is centered around users which requires a user auth manager.  -->
  <authentication-manager alias="authenticationManager" xmlns="http://www.springframework.org/schema/security">
    <authentication-provider ref="daoAuthenticationProvider" />
  </authentication-manager>
  <bean id="daoAuthenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">
    <property name="userDetailsService" ref="userDetailsService" />
  </bean>

  <bean id="tokenServices" class="org.springframework.security.oauth2.provider.token.DefaultTokenServices">
    <property name="tokenStore" ref="tokenStore" />
    <property name="supportRefreshToken" value="true" />
    <property name="clientDetailsService" ref="clientDetailsService" />
  </bean>
  <bean id="tokenStore" class="com.mycompany.oauth.spring.security.oauth2.IntegratedOAuth2TokenStore">
    <!-- This bean is what wires OAuth2 tokens into my company's application stack. -->
    <constructor-arg ref="dataSource" />
  </bean>

  <!-- **************************************************************************************** -->
  <!-- Finally, sew OAuth into spring security with some http tags... -->
  <!-- **************************************************************************************** -->

  <!-- The OAuth2 endpoint for direct token requests (i.e. for client_credentials flow). -->
  <http pattern="/token/**" create-session="stateless" authentication-manager-ref="clientAuthenticationManager" xmlns="http://www.springframework.org/schema/security">
    <intercept-url pattern="/token/**" access="IS_AUTHENTICATED_FULLY" />
    <anonymous enabled="false" />
    <http-basic entry-point-ref="clientAuthenticationEntryPoint" />
    <custom-filter ref="clientCredentialsTokenEndpointFilter" before="BASIC_AUTH_FILTER" />
    <access-denied-handler ref="oauthAccessDeniedHandler" />
  </http>
  <bean id="clientCredentialsTokenEndpointFilter" class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
    <property name="authenticationManager" ref="clientAuthenticationManager" />
    <property name="filterProcessesUrl" value="/token" />
  </bean>
  <bean id="clientAuthenticationEntryPoint" class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint">
    <property name="realmName" value="myrealm" />
  </bean>
  <bean id="oauthAccessDeniedHandler" class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler" />

  <!-- The OAuth2 endpoint for user-approved authorization (i.e. for "authorization" flow involving user login/approve). -->
  <http pattern="/authorize/**" access-denied-page="/login.jsp?authorization_error=true" disable-url-rewriting="true" xmlns="http://www.springframework.org/schema/security">
    <intercept-url pattern="/authorize/**" access="IS_AUTHENTICATED_FULLY" />
    <form-login authentication-failure-url="/login.jsp?authentication_error=true" default-target-url="http://www.mycompany.com/" login-page="/login.jsp" login-processing-url="/login.do" />
    <http-basic />
    <anonymous />
  </http>

</beans>

vous rendez les choses plus difficiles que ce qu'elles devraient être, c'est en fait très simple ! (Notez que j'utilise "oauth2:" au lieu de" oauth: "comme balise XML)

1. allez dans votre contexte de sécurité.xml

2. Rechercher "oauth2:autorisation-server" dans le fichier ci-dessus.

   <oauth2:authorization-server
                   client-details-service-ref="someService"
                   request-validator-ref="someScopeRequestValidator"
                   token-services-ref="someTokenServices" >
   

3. il suffit d'ajouter token-endpoint-url="/oauth/whatever_you_like"

   <oauth2:authorization-server
                   client-details-service-ref="someService"
                   request-validator-ref="someScopeRequestValidator"
                   token-services-ref="someTokenServices" 
   **token-endpoint-url="/oauth/whatever_you_like"** >
   

pour personnaliser L'URL du point final du jeton, faites les étapes suivantes.

1) Écrivez votre propre classe qui étend la classe ClientCredentialsTokenEndpointFilter class & call ClientCredentialsTokenEndpointFilter class constructor avec la valeur "/external/oauth/token".

super("/external/oauth/token");

2) Branchez votre nouveau filtre personnalisé dans la configuration de sécurité.

Remplacer

<custom-filter ref="clientCredentialsTokenEndpointFilter" after="BASIC_AUTH_FILTER" />

<custom-filter ref="your customize filter" after="BASIC_AUTH_FILTER" />

3) Créer votre propre classe pour la nouvelle cartographie (/externe/oauth/jeton) et prolonger tokenendpoint.

4) changer la valeur de l'attribut de l'élément http & intercept-url en "/ external/oauth / token"