Spring Boot, Hibernate und OAuth2 wie komme ich an den User?

[Husker]

ich finde ja die Kombinationen aus den 3 Technologien ziemlich cool,
allerdings stellt sich mir eine frage: wenn ich OAuth zur anmeldung verwende, wie greife ich danach darauf zu:

ein Beispiel:
ich möchte nun über Hibernate abfragen welche Projekte ein Benutzer sehen kann,
Hibernate nutzt für seine Querys Namanskonventionen z.b. findProjectsByUser()
natürlich könnte ich einen benutzernamen übergeben aber ich will ja den Aktuell angemeldeten Benutzer haben.

wie kann ich also die OAuth Anmeldung mit in Querys einfließen lassen?
ich hätte das ja gegoogelt aber irgendwie lässt sich das Google Schwer erklären 🙂

 

[Flown]

https://stackoverflow.com/questions...t-the-currently-logged-in-user-in-spring-boot

 

[Husker]

sehr cool und einfach vielen dank !

 

[mrBrown]

Den Principal kann man sich auch mit @AuthenticationPrincipal injecten lassen 😉

 

[Husker]

ja ich muss da noch viel lernen
aber bei dem Punkt war das Googlen etwas schwer ... weil ich nicht genau wuste wie ich das formulieren muss.
aktuell versuche ich noch rauszufinden wie man die Models in beziehung setzt 🙂
Danke euch für die Promte hilfe

 

[Husker]

So ich hatte in zwischen etwas zeit und wollte mich mal an die Umsetzung machen, leider musste ich feststellen das eure Beiden Versionen bei mir so nicht Funktionieren, in beiden Fällen ist es NULL
hier mal mein Code, ist nur ein testcontroller, er wird auch sauber aufgerufen und ich kann ihn auch debuggen, aber warum in beiden Fällen der User NULL ist weiss ich leider nicht, habt ihr noch eine Idee was ich versuchen könnte?

@RestController
@RequestMapping("/hello")

public class HelloController
{
    private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
   
    @RequestMapping(method = RequestMethod.GET)
    public String helloWorld(@AuthenticationPrincipal ApiUserModel user)
    {
//       
//        @AuthenticationPrincipal ApiUserModel user
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();

        String userName;
        userName = auth.getName();
        logger.debug(userName);
        return user.getLogin();
    }
   
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String helloUser(@PathVariable String id)
    {
       
        return "";
    }
   
}

 

[mrBrown]

Der Fehler liegt zumindest nicht in dem Code.

Wie sieht denn ApiModelUser und deine Security-Configuration aus?

 

[Husker]

Hier das UserModel:

package com.microservice.api.models;

import java.sql.Date;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.TemporalType;
import javax.validation.constraints.NotNull;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.Generated;
import org.hibernate.annotations.GenerationTime;
import org.hibernate.annotations.Type;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.jpa.repository.Temporal;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

@Entity
@Table(name = "user")

public class ApiUserModel implements UserDetails
{
    static final long serialVersionUID = 1L;
    private static final Logger logger = LoggerFactory.getLogger(ApiUserModel.class);
   
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "ID",  nullable = false)
    private int id;
   
    @Column(name = "Name", length = 127)
    private String last_name;
   
    @Column(name = "Vorname", length = 127)
    private String first_name;
   
    @NotNull
    @Column(name = "login", length = 63,  nullable = false, unique = true)
    private String login;
   
    @NotNull
    @Column(name = "passwort", length = 255, nullable = false)
    private String password;
   
    @Column(name = "firma_id", length = 11)
    private int company_id;
   
    @Column(name = "lang", length = 2, nullable = false)
    private int lang;
   
    @Column(name = "session", length = 63)
    private String activationCode;
   
    @Column(name = "auphone", length = 30)
    private String phone;
   
    @Column(name = "aufax", length = 30)
    private String fax;
   
    @NotNull
    @Column(name = "status", length = 1, nullable = false)
    private int status;
   
    @NotNull
    @Generated(value=GenerationTime.ALWAYS)
    @Column(name = "lastchange", columnDefinition = "DATETIME default '1900-01-01 00:00:00'", nullable = false)
    private LocalDate lastchanged;
   
    private String username;
   
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities()
    {
        List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();
       
        return authorities;
    }
   
    @Override
    public String getUsername()
    {
        logger.info("Username is: " + this.login);
        return this.login;
    }

    @Override
    public boolean isAccountNonExpired()
    {
        return true;
    }

    @Override
    public boolean isAccountNonLocked()
    {
       
        logger.debug("isAccountNonLocked ... .. .");
       
        if (this.status == 1)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    @Override
    public boolean isCredentialsNonExpired()
    {
        return true;
    }

    @Override
    public boolean isEnabled()
    {
        logger.debug("isEnabled ... .. .");
        if (this.status != 1)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    public long getId() {
        return id;
    }

    public String getLast_name() {
        return last_name;
    }

    public void setLast_name(String last_name) {
        this.last_name = last_name;
    }

    public String getFirst_name() {
        return first_name;
    }

    public void setFirst_name(String first_name) {
        this.first_name = first_name;
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login)
    {
        this.login = login;
        this.username = login;
    }
    
    @Override
    public String getPassword()
    {
        String passwordA = password.replaceFirst("2y", "2a");
        return passwordA;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getCompany_id() {
        return company_id;
    }

    public void setCompany_id(int company_id) {
        this.company_id = company_id;
    }

    public int getLang() {
        return lang;
    }
   
    public void setLang(int lang) {
        this.lang = lang;
    }

    public String getActivationCode() {
        return activationCode;
    }

    public void setActivationCode(String activationCode) {
        this.activationCode = activationCode;
    }

    public String getPhone()
    {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getFax() {
        return fax;
    }

    public void setFax(String fax) {
        this.fax = fax;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public LocalDate getLastchanged() {
        return lastchanged;
    }

    public void setLastchanged(LocalDate lastchanged) {
        this.lastchanged = lastchanged;
    }
   
    public void setUsername(String username)
    {
        this.username = username;
        this.login = username;
    }
   
}

 

[Husker]

hier die OAuth2Config.java:

package com.microservice.api.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;

@Configuration
@EnableAuthorizationServer
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
   
    @Autowired
    @Qualifier("userDetailsService")
    private UserDetailsService userDetailsService;
   
    @Autowired
    private AuthenticationManager authenticationManager;
   
    @Value("${securty.oauth.tokenTimeout:3600}")
    private int expiration;
   
    @Bean
    public PasswordEncoder passwordEncoder()
    {
        return new BCryptPasswordEncoder();
    }
   
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer configurer)
    {
        configurer.authenticationManager(authenticationManager);
        configurer.userDetailsService(userDetailsService);
    }
   
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
            .withClient("applicationname")
            .secret("secret")
            .accessTokenValiditySeconds(expiration)
            .scopes("read", "write")
            .authorizedGrantTypes("password", "refresh_token")
            .resourceIds("resource");
    }
   
   
   
}

 

[Husker]

und die WebSecurtyConfig.java:

package com.microservice.api.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;

@Configuration
@EnableWebSecurity
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   
    public WebSecurityConfig()
    {
        super(true);
    }
   
   
    @Override
    public void configure(WebSecurity web) throws Exception
    {
        web.ignoring().antMatchers("/hello/*");
        //web.ignoring().antMatchers("/users/*");
    }
   
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.antMatcher("/api/**").authorizeRequests().anyRequest().authenticated();
    }
   
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
   
}

Reicht dir das oder brauchst du noch was um einen Einblick zu bekommen?

 

[mrBrown]

Stellst du die Anfrage überhaupt als authentifizierter Nutzer?

 

[Husker]

Ja das habe ich geprüft,
wenn ich am Token was verändere bekomme ich eine 401 Meldung zurück, also das Klapt oder hbe ich da einen Denkfehler?

 

[Husker]

okay ich muss mich da korregieren, aus irgendeinem Grund geht das GET auch ohne Token, also scheint hier was an der anmeldung wirklich nicht zu stimmen, ich muss jetzt nur mal rausfinden warum das Plötzlich so ist wie es ist

 

[Husker]

okay jetzt funktioniert es 🙂
kannst du mir vielleicht noch kurz erklären wie ich das jetzt in einem Query nutze?
kleines beispiel:
https://www.java-forum.org/thema/spring-boot-jpa-models-verknuepfen-join.180371/
also ich will den Username in einem Join verwenden zusammen mit einem anderen Parameter
was mir an der stelle noch nicht klar ist wie ich das jetzt in den Funktionskopf bekomme:

@OneToMany(mappedBy = "mappingId.projectID")
    private Set<ApiUserPermissionsModel> apiUserPermissions = new HashSet<ApiUserPermissionsModel>();

ich müsste jetzt das in die OneToMany Verknüpfung eingebettet bekommen.