Authentifizieren mit SpringBoot

[Ray B]

Hallo zusammen,

ich habe eine Anwendung die ich über das Nezwerk anspreche. Ich Nutze dafür Feign / SpringBoot.

import feign.auth.BasicAuthRequestInterceptor;
import lombok.Data;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
public class FeignClientConfiguration  {

  public String user = "user";
  public String password = "Passwort";

    @Bean({"mybean"})
    public BasicAuthRequestInterceptor basicAuthRequestInterceptor() {
        return new BasicAuthRequestInterceptor(user, password );
    }

Diese Klasse binde ich im Code ein. zB:

@Component
@FeignClient(name="service", configuration = FeignClientConfiguration.class, url = "http:/usethatservice:8080/web/rest/json/article")

public interface PricingService {
    @PostMapping(path = "/{beliebigerName}/pricing")
    AllPricingSteps postSomething(@PathVariable("beliebigerName") Integer numb);
}

Und soweit funktioniert das dann auch. Wenn ich aber zur Laufzeit mit einem anderen User den Service nutzen will, dann klappt das nicht mehr. Die neuen Werte für user und Passwort werden schlicht ignoriert.
Ist ja auch soweit klar. Der Client authentifiziert sich beim Start des Programms und nicht mehr später. Ich möchte aber mit verschiedenen Usern den service nutzen können und weis nicht wie ich die Credentials zur Laufzeit setzten kann.

Weist jemand was ich zu tun habe ?

Besten Dank
Ray

(P.S. Ich habe die Anfrage so ähnlich schon mal gestellt, aber keine Antwort erhalten. Hoffe mein Problem wird jetzt deutlicher)

 

[dzim]

Hast du denn überhaupt die Security Config durchgeführt? Und spring-boot-security hinzugefügt?
Ich kenne Feign jetzt nicht wirklich, aber habe schon ein paar mal Security verwendet...

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.jdbcAuthentication()
                // explicitly define, that we are not using any role prefix
                .rolePrefix("")
                // set the datasource
                .dataSource(dataSource)
                // set the query to fetch all users
                .usersByUsernameQuery(GET_USER)
                .authoritiesByUsernameQuery(GET_ROLE)
                // Custom: Klasse, die org.springframework.security.crypto.password.PasswordEncoder implementiert
                .passwordEncoder(encoder);
    }

    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // hier wird festgelegt, wie du einloggst (z.B. Basic) und auf welchen Pfaden wer Zugriff hat
        // @EnableGlobalMethodSecurity(prePostEnabled = true) -> erlaubt aber auch @PreAuthorize("hasAuthority('basic')") an einzelnen Methoden, damit bleibt die SecurityConfig relativ kompakt
    }
}

Wie jetzt Feign als Http-Client (verstehe ich das richtig?) da ins Bild passt, weiss ich leider nicht.

 

[Ray B]

Hi dzim,

danke für die Antwort.

Ja, Feign ist der HTTP-Client. Die Security-Config sollte eigentlich Feign übernehmen.
Falls ich aber bei meiner Recherche auf keine Lösung komm, werde ich wohl Feign rausschmeissen und nur SpringBoot verwenden.
Da hätte ich dann wieder Fragen über Fragen

 

[dzim]

Also wenn du "nur" einen Http-Client innerhalb deiner Spring-Boot-Anwendung benötigst, kannst du auch Springs RestTemplates oder Retrofit (und OkHttp) verwenden. Aber wie gesagt: Ich kenne Feign zu wenig, um genauer etwas dazu sagen zu können. Von einer kurzen Recherche (und Tutorial auf Baeldung) würde ich sagen, dass er Retrofit recht ähnlich sieht.
Was mich dazu bringt, dass ich dich eventuelle auch einfach falsch verstanden habe!

Kann es sein, dass nicht Security benötigst um deinen Service abzudichten (was mein Code und Vorschlag im Grunde war) sondern du willst "nur" wissen, wie dein Client Http-Header ("Authentication: Basic <base64[userassword]>") injizieren kann. Mit Retrofit muss man den OkHttp-Client übergeben und kann dort Interceptoren schreiben. Alternativ kann man Header auch als Parameter an die Deklaration übergeben (also in der Interface-Methode wie @Header oder so). Ich denke, dass könnte bei Feign ähnlich laufen. Dann musst du dir nur einen Service, oder so, schreiben, der dir den Authentication-Header konstruieren kann...

Wenn du dir nur die Beschreibung auf GitHub anschaust, kannst du das wohl recht einfach machen:
https://github.com/OpenFeign/feign -> Suche "Set headers using apis"
Mit

@RequestLine("POST /doit")
@Headers("Authentication: Basic {auth}")
void postDoit(@Param("auth") String auth); // submit Base64 encoded String with format "<username>:<password>"

Ich vermute mal, dass ist, was du brauchen kannst. Eventuell kannst du aber auch in der API, wenn du den Client anhand der Deklaration generierst, eine Art Authentication-Interceptor oder so angeben. Das machst du oben zwar schon, aber ich denke, du müsstest auch die Erstellung des Feign-Client anpassen. Obwohl die Doku zu Spring Cloud und Feign ja eigentlich es auch nur beschreibt, wie du:
https://cloud.spring.io/spring-cloud-netflix/multi/multi_spring-cloud-feign.html
Nur noch eine Extra-Bean für den "Feign-Contract" ist drin und die application-Properties werden beschrieben. Vielleicht musst du dort mal schauen?

 

[Ray B]

Das hört sich schon mal sehr interessant an. Ich denke das geht in die richtige Richtung. Muss ich gleich ausprobieren.
Bei

 @Bean
    public Contract feignContract() {
        return new feign.Contract.Default();
    }

bekomm ich immer einen Fehler. Weis aber (noch) nicht warum.

Danke für die Hilfe. Ich sag hier dann was bei rausgekommen ist.