@Test
public void testMultipleCookieParameters() throws Exception {
    Class<?>[] argType = {String.class, String.class, Cookie.class};
    Method m = Customer.class.getMethod("testMultipleCookieParam", argType);
    Message messageImpl = createMessage();
    MultivaluedMap<String, String> headers = new MetadataMap<>();
    headers.add("Cookie", "c1=c1Value; c2=c2Value");
    headers.add("Cookie", "c3=c3Value");
    messageImpl.put(Message.PROTOCOL_HEADERS, headers);
    List<Object> params = JAXRSUtils.processParameters(new OperationResourceInfo(m,
                                                           new ClassResourceInfo(Customer.class)),
                                                       null,
                                                       messageImpl);
    assertEquals(3, params.size());
    assertEquals("c1Value", params.get(0));
    assertEquals("c2Value", params.get(1));
    assertEquals("c3Value", ((Cookie)params.get(2)).getValue());
}
 

@POST
@Path("/profile")
public Response verifySessionCookie(@CookieParam("session") Cookie cookie) {
  String sessionCookie = cookie.getValue();
  try {
    // Verify the session cookie. In this case an additional check is added to detect
    // if the user's Firebase session was revoked, user deleted/disabled, etc.
    final boolean checkRevoked = true;
    FirebaseToken decodedToken = FirebaseAuth.getInstance().verifySessionCookie(
        sessionCookie, checkRevoked);
    return serveContentForUser(decodedToken);
  } catch (FirebaseAuthException e) {
    // Session cookie is unavailable, invalid or revoked. Force user to login.
    return Response.temporaryRedirect(URI.create("/login")).build();
  }
}
 

@Test
public void testCreateHeaderProvider() throws Exception {
    assertSame(MediaTypeHeaderProvider.class,
               new RuntimeDelegateImpl().
                   createHeaderDelegate(MediaType.class).getClass());
    assertSame(EntityTagHeaderProvider.class,
               new RuntimeDelegateImpl().
                   createHeaderDelegate(EntityTag.class).getClass());
    assertSame(CacheControlHeaderProvider.class,
               new RuntimeDelegateImpl().
                   createHeaderDelegate(CacheControl.class).getClass());
    assertSame(CookieHeaderProvider.class,
               new RuntimeDelegateImpl().
                   createHeaderDelegate(Cookie.class).getClass());
    assertSame(NewCookieHeaderProvider.class,
               new RuntimeDelegateImpl().
                   createHeaderDelegate(NewCookie.class).getClass());
}
 

private Optional<UserInfoImpl> tryAutoLogin(ContainerRequestContext request, SessionInfo session) {
    Cookie cookie = request.getCookies().get(userWebOptions.autoLoginCookie);
    if (cookie != null) {
        try {
            TokenLoginRequest authenticationRequest = new TokenLoginRequest();
            authenticationRequest.token = cookie.getValue();
            LoginResponse authenticationResponse = userWebService.login(authenticationRequest);
            UserInfoImpl user = user(authenticationResponse.user);
            session.put(SESSION_USER_ID, user.id());
            return Optional.of(user);
        } catch (Throwable e) {
            logger.warn("invalid auto login token cookie, value={}", cookie.getValue());
        }
    }
    return Optional.empty();
}
 

@Override
public Response apply(ContainerRequestContext arg0) {
    OpenAPISpecFilter filter = FilterFactory.getFilter();
    if(filter != null) {
        Map<String, Cookie> cookiesvalue = arg0.getCookies();
        Map<String, String> cookies = new HashMap<>();
        if(cookiesvalue != null) {
            for(String key: cookiesvalue.keySet()) {
                cookies.put(key, cookiesvalue.get(key).getValue());
            }
        }

        MultivaluedMap<String, String> headers = arg0.getHeaders();
        // since https://github.com/swagger-api/swagger-inflector/issues/305 filtering of inflector extensions is handled at init time by ExtensionsUtils, and VendorSpecFilter is not needed anymore
        return Response.ok().entity(getOpenAPI()).build();
    }
    return Response.ok().entity(getOpenAPI()).build();
}
 

@Override
public ClientInfo get() {
    ClientInfo clientInfo = (ClientInfo) context.getProperty("__client_info");
    if (clientInfo == null) {
        String clientId;
        Map<String, Cookie> cookies = headers.getCookies();
        if (cookies.containsKey(webOptions.cookie.clientId)) {
            clientId = cookies.get(webOptions.cookie.clientId).getValue();
        } else {
            clientId = UUID.randomUUID().toString();
        }
        String language;
        if (cookies.containsKey(webOptions.cookie.language)) {
            language = cookies.get(webOptions.cookie.language).getValue();
        } else {
            language = app.language();
        }
        if (!app.supportLanguages().contains(language)) {
            language = app.language();
        }
        clientInfo = new ClientInfoImpl(clientId, language, context.getHeaderString("X-Client-IP"));
        context.setProperty("__client_info", clientInfo);
    }
    return clientInfo;
}
 

public ClientResponse put(String relativeURL, Object request, Cookie sessionId) throws Exception {
	ClientResponse response = null;
	int startIndex = this.lastKnownActiveUrlIndex;
	int currentIndex = 0;

	for (int index = 0; index < configuredURLs.size(); index++) {
		try {
			currentIndex = (startIndex + index) % configuredURLs.size();

			WebResource webResource = createWebResourceForCookieAuth(currentIndex, relativeURL);
			WebResource.Builder br = webResource.getRequestBuilder().cookie(sessionId);
			response = br.accept(RangerRESTUtils.REST_EXPECTED_MIME_TYPE).type(RangerRESTUtils.REST_MIME_TYPE_JSON)
					.put(ClientResponse.class, toJson(request));
			if (response != null) {
				setLastKnownActiveUrlIndex(currentIndex);
				break;
			}
		} catch (ClientHandlerException e) {
			LOG.warn("Failed to communicate with Ranger Admin, URL : " + configuredURLs.get(currentIndex));
			processException(index, e);
		}
	}
	return response;
}
 

@Path("/logout")
@POST
@Produces(MediaType.APPLICATION_JSON)
public Response logoutUser(@CookieParam("Q2R_AUTH_INFO") Cookie cookie){
	String cookieValue = cookie.getValue();
	String tokenPatterns[] = cookieValue.split("_0_");
	
	if(tokenPatterns.length!=3)
		return Response.serverError().entity("Corrupt Token").build();
	
	logger.info("Logging out user "+tokenPatterns[0]);
	try{
		boolean validToken = UserManager.getUserManager().validateToken(tokenPatterns[0], cookieValue);
		if(validToken){
			UserManager.getUserManager().logoutUser(tokenPatterns[0]);
			return Response.ok("User "+tokenPatterns[0]+" logged out.").build();
		}else{
			return Response.serverError().entity("Logout failed").status(Response.Status.UNAUTHORIZED).build();
		}
	}catch(Exception e){
		return Response.serverError().entity("Logout failed").build();
	}
}
 

public Request(
        String uri,
        Object entity,
        String mediaType,
        List<Cookie> cookies,
        Map<String, Object> headers) {
    
    _uri = uri;
    _entity = entity;
    _mediaType = mediaType;
    if (cookies != null) {
        _cookies = cookies;
    }
    if (headers != null) {
        _headers = headers;
    }
}
 

@Override
public String toString(Cookie cookie) {
    if (cookie == null) {
        throw new IllegalArgumentException();
    }
    StringBuilder sb = new StringBuilder();

    sb.append("$Version=").append(cookie.getVersion()).append(';');

    sb.append(cookie.getName()).append('=').append(addQuotesIfHasWhitespace(cookie.getValue()));

    if (cookie.getDomain() != null) {
        sb.append(';').append("$Domain=").append(addQuotesIfHasWhitespace(cookie.getDomain()));
    }

    if (cookie.getPath() != null) {
        sb.append(';').append("$Path=").append(addQuotesIfHasWhitespace(cookie.getPath()));
    }

    return sb.toString();
}
 

public Map<String, Cookie> getCookies() {
    List<String> values = headers.get(HttpHeaders.COOKIE);
    if (values == null || values.isEmpty()) {
        return Collections.emptyMap();
    }

    Map<String, Cookie> cl = new HashMap<>();
    for (String value : values) {
        if (value == null) {
            continue;
        }


        List<String> cs = getHeaderValues(HttpHeaders.COOKIE, value,
                                          getCookieSeparator(value));
        for (String c : cs) {
            Cookie cookie = Cookie.valueOf(c);
            cl.put(cookie.getName(), cookie);
        }
    }
    return cl;
}
 

public ClientResponse post(String relativeURL, Map<String, String> params, Object obj, Cookie sessionId)
		throws Exception {
	ClientResponse response = null;
	int startIndex = getLastKnownActiveUrlIndex();
	int currentIndex = 0;

	for (int index = 0; index < getConfiguredURLs().size(); index++) {
		try {
			currentIndex = (startIndex + index) % getConfiguredURLs().size();

			WebResource webResource = createWebResourceForCookieAuth(currentIndex, relativeURL);
			webResource = setQueryParams(webResource, params);
			WebResource.Builder br = webResource.getRequestBuilder().cookie(sessionId);
			response = br.accept(RangerRESTUtils.REST_EXPECTED_MIME_TYPE).type(RangerRESTUtils.REST_MIME_TYPE_JSON)
					.post(ClientResponse.class, toJson(obj));
			if (response != null) {
				setLastKnownActiveUrlIndex(currentIndex);
				break;
			}
		} catch (ClientHandlerException e) {
			LOG.warn("Failed to communicate with Ranger Admin, URL : " + getConfiguredURLs().get(currentIndex));
			processException(index, e);
		}
	}
	return response;
}
 

public static AuthResult authenticateIdentityCookie(KeycloakSession session, RealmModel realm, boolean checkActive) {
    Cookie cookie = CookieHelper.getCookie(session.getContext().getRequestHeaders().getCookies(), KEYCLOAK_IDENTITY_COOKIE);
    if (cookie == null || "".equals(cookie.getValue())) {
        logger.debugv("Could not find cookie: {0}", KEYCLOAK_IDENTITY_COOKIE);
        return null;
    }

    String tokenString = cookie.getValue();
    AuthResult authResult = verifyIdentityToken(session, realm, session.getContext().getUri(), session.getContext().getConnection(), checkActive, false, true, tokenString, session.getContext().getRequestHeaders(), VALIDATE_IDENTITY_COOKIE);
    if (authResult == null) {
        expireIdentityCookie(realm, session.getContext().getUri(), session.getContext().getConnection());
        expireOldIdentityCookie(realm, session.getContext().getUri(), session.getContext().getConnection());
        return null;
    }
    authResult.getSession().setLastSessionRefresh(Time.currentTime());
    return authResult;
}
 

/**
 * If the user has a valid session token, set a new session token. The new one should have a later
 * expiration time.
 */
@Override public void filter(ContainerRequestContext request, ContainerResponseContext response)
    throws IOException {
  String sessionCookieName = sessionCookieConfig.getName();
  // If the response will be setting a session cookie, don't overwrite it; just let it go.
  if (response.getCookies().containsKey(sessionCookieName)) {
    return;
  }

  // If the request doesn't have a session cookie, we're not going to renew one.
  if (!request.getCookies().containsKey(sessionCookieName)) {
    return;
  }

  Cookie requestCookie = request.getCookies().get(sessionCookieName);
  Optional<User> optionalUser = authenticator.authenticate(requestCookie);
  if (optionalUser.isPresent()) {
    sessionLoginResource.cookiesForUser(optionalUser.get())
        .forEach(c -> response.getHeaders().add(HttpHeaders.SET_COOKIE, c));
  }
}
 

private boolean isAuthenticated(ContainerRequestContext containerRequestContext, ThirdEyePrincipal principal) {
  Map<String, Cookie> cookies = containerRequestContext.getCookies();

  if (cookies != null && cookies.containsKey(AuthResource.AUTH_TOKEN_NAME)) {
    String sessionKey = cookies.get(AuthResource.AUTH_TOKEN_NAME).getValue();
    if (sessionKey.isEmpty()) {
      LOG.error("Empty sessionKey. Skipping.");
    } else {
      SessionDTO sessionDTO = this.sessionDAO.findBySessionKey(sessionKey);
      if (sessionDTO != null && System.currentTimeMillis() < sessionDTO.getExpirationTime()) {
        // session exist in database and has not expired
        principal.setName(sessionDTO.getPrincipal());
        principal.setSessionKey(sessionKey);
        LOG.info("Found valid session {} for user {}", sessionDTO.getSessionKey(), sessionDTO.getPrincipal());
        return true;
      }
    }
  }
  return false;
}
 

@POST
@Path("/users/current/logout")
@Timed
public Response logoutCurrentUser(@Context UriInfo uriInfo,
                                  @Context SecurityContext securityContext) throws Exception {
    User currentUser = getCurrentUser(securityContext);
    // Set-Cookie	hadoop.auth=deleted;Version=1;Path=/;Max-Age=0;HttpOnly;Expires=Thu, 01 Jan 1970 00:00:00 GMT
    Cookie cookie = new Cookie(AuthenticatedURL.AUTH_COOKIE, "deleted", "/", null);
    NewCookie newCookie = new NewCookie(cookie, null, 0, new Date(0), securityContext.isSecure(), true);
    return Response.status(OK)
            .entity(currentUser)
            .cookie(newCookie)
            .build();
}
 

public static NewCookie getDeleteCookie(boolean secure)
{
    return new NewCookie(
            PRESTO_UI_COOKIE,
            "delete",
            "/ui",
            null,
            Cookie.DEFAULT_VERSION,
            null,
            0,
            null,
            secure,
            true);
}
 

@Override
protected String getCookieValue(String cookieName) {
    Cookie tokenCookie = requestContext.getCookies().get(cookieName);

    if (tokenCookie != null) {
        return tokenCookie.getValue();
    }
    return null;
}
 

@Test
public void testGetCookies() throws Exception {
    Map<String, Cookie> cookieMap = httpHeaders1.getCookies();
    assertNotNull(cookieMap);
    assertEquals(cookieMap.size(), 1);
    assertTrue(cookieMap.containsKey("JSESSIONID"));
    assertEquals(cookieMap.get("JSESSIONID").getValue(), "3508015E4EF0ECA8C4B761FCC4BC1718");

    Map<String, Cookie> cookieMap2 = httpHeaders2.getCookies();
    assertEquals(cookieMap2.size(), 0);
}
 

@SuppressWarnings("unchecked")
private Response responseAuthSuccess(final IAccessToken accessToken, final IRefreshToken refreshToken) {
    JSONObject resp = new JSONObject();
    resp.put(OAuth2Helper.Key.ACCESS_TOKEN, accessToken.toTokenString());
    resp.put(OAuth2Helper.Key.EXPIRES_IN, accessToken.expiresIn());
    if (refreshToken != null) {
        resp.put(OAuth2Helper.Key.REFRESH_TOKEN, refreshToken.toTokenString());
        resp.put(OAuth2Helper.Key.REFRESH_TOKEN_EXPIRES_IN, refreshToken.refreshExpiresIn());
    }
    resp.put(OAuth2Helper.Key.TOKEN_TYPE, OAuth2Helper.Scheme.BEARER);
    ResponseBuilder rb = Response.ok().type(MediaType.APPLICATION_JSON_TYPE);
    if (accessToken.getTarget() != null) {
        resp.put(OAuth2Helper.Key.TARGET, accessToken.getTarget());
        rb.header(HttpHeaders.LOCATION, accessToken.getTarget() + "__auth");
    }

    if (issueCookie) {
        String tokenString = accessToken.toTokenString();
        // dc_cookie_peerとして、ランダムなUUIDを設定する
        String dcCookiePeer = UUID.randomUUID().toString();
        String cookieValue = dcCookiePeer + "\t" + tokenString;
        // ヘッダに返却するdc_cookie値は、暗号化する
        String encodedCookieValue = LocalToken.encode(cookieValue,
                UnitLocalUnitUserToken.getIvBytes(AccessContext.getCookieCryptKey(requestURIInfo.getBaseUri())));
        // Cookieのバージョン(0)を指定
        int version = 0;
        String path = getCookiePath();

        // Cookieを作成し、レスポンスヘッダに返却する
        Cookie cookie = new Cookie("dc_cookie", encodedCookieValue, path, requestURIInfo.getBaseUri().getHost(),
                version);
        rb.cookie(new NewCookie(cookie, "", -1, DcCoreConfig.isHttps()));
        // レスポンスボディの"dc_cookie_peer"を返却する
        resp.put("dc_cookie_peer", dcCookiePeer);
    }
    return rb.entity(resp.toJSONString()).build();
}
 

@POST
@Path("/sessionLogout")
public Response clearSessionCookie(@CookieParam("session") Cookie cookie) {
  final int maxAge = 0;
  NewCookie newCookie = new NewCookie(cookie, null, maxAge, true);
  return Response.temporaryRedirect(URI.create("/login")).cookie(newCookie).build();
}
 

@Test
public void testGetCookies() throws Exception {

    Message m = createMessage(createHeader(HttpHeaders.COOKIE, "a=$b;c=d"));
    HttpHeaders h = new HttpHeadersImpl(m);
    Map<String, Cookie> cookies = h.getCookies();
    assertEquals(2, cookies.size());
    assertEquals("$b", cookies.get("a").getValue());
    assertEquals("d", cookies.get("c").getValue());
}
 

private LoginAJAXResponse loginAJAXResponse(String userId) {
    LoginAJAXResponse response = new LoginAJAXResponse();
    response.userId = userId;
    Cookie url = requestContext.getCookies().get(COOKIE_FROM_URL);
    if (url != null) {
        response.fromURL = url.getValue();
    }
    return response;
}
 

@Test
public void returnsNullWhenCookieNotFoundInRequestAndDefaultValueIsNotSet() throws Exception {
    when(cookieParam.value()).thenReturn("no cookie");
    when(parameter.getParameterClass()).thenReturn((Class)Cookie.class);

    Object resolvedCookie = cookieParameterResolver.resolve(parameter, applicationContext);

    assertNull(resolvedCookie);
}
 

public RuntimeDelegateImpl() {
    headerProviders.put(MediaType.class, new MediaTypeHeaderProvider());
    headerProviders.put(CacheControl.class, new CacheControlHeaderProvider());
    headerProviders.put(EntityTag.class, new EntityTagHeaderProvider());
    headerProviders.put(Cookie.class, new CookieHeaderProvider());
    headerProviders.put(NewCookie.class, new NewCookieHeaderProvider());
    headerProviders.put(Link.class, new LinkHeaderProvider());
    headerProviders.put(Date.class, new DateHeaderProvider());
}
 

public LocaleResolverContextImpl(List<Locale> acceptableLanguages, Configuration configuration,
	Map<String, Cookie> cookies, Map<String, String> headers, UriInfo uriInfo) {
	this.acceptableLanguages = acceptableLanguages;
	this.configuration = configuration;
	this.cookies = cookies;
	this.headers = headers;
	this.uriInfo = uriInfo;
}
 

private WebResourceFactory(final WebTarget target, final MultivaluedMap<String, Object> headers,
		final List<Cookie> cookies, final Form form, boolean isOSGiAsync) {
	this.target = target;
	this.headers = headers;
	this.cookies = cookies;
	this.form = form;
	this.isOSGiAsync = isOSGiAsync;
}
 

@Test
public void shouldNotCreateSessionIfAuthCookieIsNotFoundAndCreateIsFalse() {
	when(context.getCookies()).thenReturn(Maps.<String, Cookie>newHashMap());
	Session session = mock(Session.class);
	when(sessionStore.createSession(any(String.class))).thenReturn(session);
	assertNull(filter.getSession(context, false));
}
 

private Optional<String> getTokenFromCookie(ContainerRequestContext requestContext) {
    final Map<String, Cookie> cookies = requestContext.getCookies();

    if (cookieName != null && cookies.containsKey(cookieName)) {
        final Cookie tokenCookie = cookies.get(cookieName);
        final String rawToken = tokenCookie.getValue();
        return Optional.of(rawToken);
    }

    return Optional.empty();
}
 

private Locale getLocaleCookieSelection(RealmModel realm, HttpHeaders httpHeaders) {
    if (httpHeaders == null) {
        return null;
    }

    Cookie localeCookie = httpHeaders.getCookies().get(LOCALE_COOKIE);
    if (localeCookie == null) {
        return null;
    }

    return findLocale(realm, localeCookie.getValue());
}