source.dussan.org Git - sonarqube.git/blob

   1 /*
   2  * SonarQube
   3  * Copyright (C) 2009-2024 SonarSource SA
   4  * mailto:info AT sonarsource DOT com
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20 package org.sonar.server.authentication;
  21
  22 import com.google.common.base.Splitter;
  23 import java.util.Collections;
  24 import java.util.Date;
  25 import java.util.EnumSet;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.Locale;
  29 import java.util.Map;
  30 import java.util.Optional;
  31 import javax.annotation.CheckForNull;
  32 import org.sonar.api.Startable;
  33 import org.sonar.api.config.Configuration;
  34 import org.sonar.api.server.authentication.Display;
  35 import org.sonar.api.server.authentication.IdentityProvider;
  36 import org.sonar.api.server.authentication.UserIdentity;
  37 import org.sonar.api.server.http.HttpRequest;
  38 import org.sonar.api.server.http.HttpResponse;
  39 import org.sonar.api.utils.System2;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.sonar.db.user.UserDto;
  43 import org.sonar.process.ProcessProperties;
  44 import org.sonar.server.authentication.event.AuthenticationEvent;
  45 import org.sonar.server.authentication.event.AuthenticationEvent.Source;
  46 import org.sonar.server.authentication.event.AuthenticationException;
  47 import org.sonar.server.exceptions.BadRequestException;
  48
  49 import static org.apache.commons.lang.time.DateUtils.addMinutes;
  50 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_EMAIL_HEADER;
  51 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_ENABLE;
  52 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_GROUPS_HEADER;
  53 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_LOGIN_HEADER;
  54 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_NAME_HEADER;
  55 import static org.sonar.process.ProcessProperties.Property.SONAR_WEB_SSO_REFRESH_INTERVAL_IN_MINUTES;
  56 import static org.sonar.server.user.ExternalIdentity.SQ_AUTHORITY;
  57
  58 /**
  59  * Authentication based on the HTTP request headers. The front proxy
  60  * is responsible for validating user identity.
  61  */
  62 public class HttpHeadersAuthentication implements Startable {
  63
  64   private static final Logger LOG = LoggerFactory.getLogger(HttpHeadersAuthentication.class);
  65
  66   private static final Splitter COMA_SPLITTER = Splitter.on(",").trimResults().omitEmptyStrings();
  67
  68   private static final String LAST_REFRESH_TIME_TOKEN_PARAM = "ssoLastRefreshTime";
  69
  70   private static final EnumSet<ProcessProperties.Property> PROPERTIES = EnumSet.of(
  71     SONAR_WEB_SSO_LOGIN_HEADER,
  72     SONAR_WEB_SSO_NAME_HEADER,
  73     SONAR_WEB_SSO_EMAIL_HEADER,
  74     SONAR_WEB_SSO_GROUPS_HEADER,
  75     SONAR_WEB_SSO_REFRESH_INTERVAL_IN_MINUTES);
  76
  77   private final System2 system2;
  78   private final Configuration config;
  79   private final UserRegistrar userRegistrar;
  80   private final JwtHttpHandler jwtHttpHandler;
  81   private final AuthenticationEvent authenticationEvent;
  82   private final Map<String, String> settingsByKey = new HashMap<>();
  83
  84   private boolean enabled = false;
  85
  86   public HttpHeadersAuthentication(System2 system2, Configuration config, UserRegistrar userRegistrar,
  87     JwtHttpHandler jwtHttpHandler, AuthenticationEvent authenticationEvent) {
  88     this.system2 = system2;
  89     this.config = config;
  90     this.userRegistrar = userRegistrar;
  91     this.jwtHttpHandler = jwtHttpHandler;
  92     this.authenticationEvent = authenticationEvent;
  93   }
  94
  95   @Override
  96   public void start() {
  97     if (config.getBoolean(SONAR_WEB_SSO_ENABLE.getKey()).orElse(false)) {
  98       LOG.info("HTTP headers authentication enabled");
  99       enabled = true;
 100       PROPERTIES.forEach(entry -> settingsByKey.put(entry.getKey(), config.get(entry.getKey()).orElse(entry.getDefaultValue())));
 101     }
 102   }
 103
 104   @Override
 105   public void stop() {
 106     // Nothing to do
 107   }
 108
 109   public Optional<UserDto> authenticate(HttpRequest request, HttpResponse response) {
 110     try {
 111       return doAuthenticate(request, response);
 112     } catch (BadRequestException e) {
 113       throw AuthenticationException.newBuilder()
 114         .setSource(Source.sso())
 115         .setMessage(e.getMessage())
 116         .build();
 117     }
 118   }
 119
 120   private Optional<UserDto> doAuthenticate(HttpRequest request, HttpResponse response) {
 121     if (!enabled) {
 122       return Optional.empty();
 123     }
 124     Map<String, String> headerValuesByNames = getHeaders(request);
 125     String login = getHeaderValue(headerValuesByNames, SONAR_WEB_SSO_LOGIN_HEADER.getKey());
 126     if (login == null) {
 127       return Optional.empty();
 128     }
 129     Optional<UserDto> user = getUserFromToken(request, response);
 130     if (user.isPresent() && login.equals(user.get().getLogin())) {
 131       return user;
 132     }
 133
 134     UserDto userDto = doAuthenticate(headerValuesByNames, login);
 135     jwtHttpHandler.generateToken(userDto, Map.of(LAST_REFRESH_TIME_TOKEN_PARAM, system2.now()), request, response);
 136     authenticationEvent.loginSuccess(request, userDto.getLogin(), Source.sso());
 137     return Optional.of(userDto);
 138   }
 139
 140   private Optional<UserDto> getUserFromToken(HttpRequest request, HttpResponse response) {
 141     Optional<JwtHttpHandler.Token> token = jwtHttpHandler.getToken(request, response);
 142     if (token.isEmpty()) {
 143       return Optional.empty();
 144     }
 145     Date now = new Date(system2.now());
 146     int refreshIntervalInMinutes = Integer.parseInt(settingsByKey.get(SONAR_WEB_SSO_REFRESH_INTERVAL_IN_MINUTES.getKey()));
 147     Long lastFreshTime = (Long) token.get().getProperties().get(LAST_REFRESH_TIME_TOKEN_PARAM);
 148     if (lastFreshTime == null || now.after(addMinutes(new Date(lastFreshTime), refreshIntervalInMinutes))) {
 149       return Optional.empty();
 150     }
 151     return Optional.of(token.get().getUserDto());
 152   }
 153
 154   private UserDto doAuthenticate(Map<String, String> headerValuesByNames, String login) {
 155     String name = getHeaderValue(headerValuesByNames, SONAR_WEB_SSO_NAME_HEADER.getKey());
 156     String email = getHeaderValue(headerValuesByNames, SONAR_WEB_SSO_EMAIL_HEADER.getKey());
 157     UserIdentity.Builder userIdentityBuilder = UserIdentity.builder()
 158       .setName(name == null ? login : name)
 159       .setEmail(email)
 160       .setProviderLogin(login);
 161     if (hasHeader(headerValuesByNames, SONAR_WEB_SSO_GROUPS_HEADER.getKey())) {
 162       String groupsValue = getHeaderValue(headerValuesByNames, SONAR_WEB_SSO_GROUPS_HEADER.getKey());
 163       userIdentityBuilder.setGroups(groupsValue == null ? Collections.emptySet() : new HashSet<>(COMA_SPLITTER.splitToList(groupsValue)));
 164     }
 165     return userRegistrar.register(
 166       UserRegistration.builder()
 167         .setUserIdentity(userIdentityBuilder.build())
 168         .setProvider(new SsoIdentityProvider())
 169         .setSource(Source.sso())
 170         .build());
 171   }
 172
 173   @CheckForNull
 174   private String getHeaderValue(Map<String, String> headerValuesByNames, String settingKey) {
 175     return headerValuesByNames.get(settingsByKey.get(settingKey).toLowerCase(Locale.ENGLISH));
 176   }
 177
 178   private static Map<String, String> getHeaders(HttpRequest request) {
 179     Map<String, String> headers = new HashMap<>();
 180     Collections.list(request.getHeaderNames()).forEach(header -> headers.put(header.toLowerCase(Locale.ENGLISH), request.getHeader(header)));
 181     return headers;
 182   }
 183
 184   private boolean hasHeader(Map<String, String> headerValuesByNames, String settingKey) {
 185     return headerValuesByNames.containsKey(settingsByKey.get(settingKey).toLowerCase(Locale.ENGLISH));
 186   }
 187
 188   private static class SsoIdentityProvider implements IdentityProvider {
 189     @Override
 190     public String getKey() {
 191       return SQ_AUTHORITY;
 192     }
 193
 194     @Override
 195     public String getName() {
 196       return getKey();
 197     }
 198
 199     @Override
 200     public Display getDisplay() {
 201       return null;
 202     }
 203
 204     @Override
 205     public boolean isEnabled() {
 206       return true;
 207     }
 208
 209     @Override
 210     public boolean allowsUsersToSignUp() {
 211       return true;
 212     }
 213   }
 214 }