Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -32,6 +32,7 @@
import org.apache.ranger.plugin.policyengine.RangerAccessResource;
import org.apache.ranger.plugin.policyengine.RangerAccessResult;
import org.apache.ranger.plugin.policyengine.RangerAccessResultProcessor;
import org.apache.ranger.plugin.policyengine.RangerConstraintResult;
import org.apache.ranger.plugin.policyengine.gds.GdsAccessResult;
import org.apache.ranger.plugin.service.RangerBasePlugin;
import org.apache.ranger.plugin.util.JsonUtilsV2;
Expand All @@ -43,6 +44,7 @@
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
Expand All @@ -52,6 +54,8 @@
import java.util.concurrent.atomic.AtomicInteger;

public class RangerDefaultAuditHandler implements RangerAccessResultProcessor {
public static final String ACCESS_TYPE_CONSTRAINT_PREFIX = "CONSTRAINT:";

private static final Logger LOG = LoggerFactory.getLogger(RangerDefaultAuditHandler.class);

private static final String CONF_AUDIT_ID_STRICT_UUID = "xasecure.audit.auditid.strict.uuid";
Expand Down Expand Up @@ -82,6 +86,7 @@ public void processResult(RangerAccessResult result) {
AuthzAuditEvent event = getAuthzEvents(result);

logAuthzAudit(event);
logAuthzAudits(getConstraintAuditEvents(result, event));

LOG.debug("<== RangerDefaultAuditHandler.processResult({})", result);
}
Expand Down Expand Up @@ -173,6 +178,7 @@ public Collection<AuthzAuditEvent> getAuthzEvents(Collection<RangerAccessResult>
}

ret.add(event);
ret.addAll(getConstraintAuditEvents(result, event));
}
}

Expand All @@ -181,6 +187,24 @@ public Collection<AuthzAuditEvent> getAuthzEvents(Collection<RangerAccessResult>
return ret;
}

public List<AuthzAuditEvent> getConstraintAuditEvents(RangerAccessResult result, AuthzAuditEvent accessEvent) {
if (accessEvent == null || result == null || !result.getIsAllowed() || result.getConstraints().isEmpty()) {
return Collections.emptyList();
}

List<AuthzAuditEvent> ret = new ArrayList<>(result.getConstraints().size());

for (RangerConstraintResult constraint : result.getConstraints()) {
if (constraint != null) {
ret.add(createConstraintAuditEvent(accessEvent, constraint));
}
}

LOG.debug("RangerDefaultAuditHandler.getConstraintAuditEvents({}): {}", result, ret);

return ret;
}

public void logAuthzAudit(AuthzAuditEvent auditEvent) {
LOG.debug("==> RangerDefaultAuditHandler.logAuthzAudit({})", auditEvent);

Expand Down Expand Up @@ -212,6 +236,40 @@ public AuthzAuditEvent createAuthzAuditEvent() {
return new AuthzAuditEvent();
}

protected AuthzAuditEvent createConstraintAuditEvent(AuthzAuditEvent accessEvent, RangerConstraintResult constraint) {
AuthzAuditEvent ret = createAuthzAuditEvent();

ret.setRepositoryName(accessEvent.getRepositoryName());
ret.setRepositoryType(accessEvent.getRepositoryType());
ret.setResourceType(accessEvent.getResourceType());
ret.setResourcePath(accessEvent.getResourcePath());
ret.setRequestData(accessEvent.getRequestData());
ret.setEventTime(accessEvent.getEventTime());
ret.setUser(accessEvent.getUser());
ret.setAction(accessEvent.getAction());
ret.setAccessResult(accessEvent.getAccessResult());
ret.setClientIP(accessEvent.getClientIP());
ret.setClientType(accessEvent.getClientType());
ret.setSessionId(accessEvent.getSessionId());
ret.setAclEnforcer(accessEvent.getAclEnforcer());
ret.setAgentId(accessEvent.getAgentId());
ret.setAgentHostname(accessEvent.getAgentHostname());
ret.setLogType(accessEvent.getLogType());
ret.setTags(accessEvent.getTags());
ret.setDatasets(accessEvent.getDatasets());
ret.setProjects(accessEvent.getProjects());
ret.setDatasetIds(accessEvent.getDatasetIds());
ret.setAdditionalInfo(accessEvent.getAdditionalInfo());
ret.setClusterName(accessEvent.getClusterName());
ret.setZoneName(accessEvent.getZoneName());

ret.setAccessType(ACCESS_TYPE_CONSTRAINT_PREFIX + constraint.getConstraintName());
ret.setPolicyId(constraint.getPolicyId());
ret.setPolicyVersion(constraint.getPolicyVersion());

return ret;
}

public final Set<String> getDatasets(RangerAccessRequest request) {
GdsAccessResult gdsResult = RangerAccessRequestUtil.getGdsResultFromContext(request.getContext());

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -30,6 +30,7 @@
import org.apache.ranger.plugin.policyengine.RangerAccessRequestImpl;
import org.apache.ranger.plugin.policyengine.RangerAccessResourceImpl;
import org.apache.ranger.plugin.policyengine.RangerAccessResult;
import org.apache.ranger.plugin.policyengine.RangerConstraintResult;
import org.apache.ranger.plugin.policyengine.gds.GdsAccessResult;
import org.apache.ranger.plugin.policyresourcematcher.RangerPolicyResourceMatcher;
import org.apache.ranger.plugin.service.RangerBasePlugin;
Expand All @@ -40,6 +41,7 @@
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
Expand All @@ -49,6 +51,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
Expand Down Expand Up @@ -374,6 +377,131 @@ public void test11_processResult_and_processResults() {
}
}

@Test
public void test12_getConstraintAuditEvents() {
RangerDefaultAuditHandler handler = new RangerDefaultAuditHandler();
RangerAccessResult result = constraintResult("svcC", true);
AuthzAuditEvent accessEvent = handler.getAuthzEvents(result);

List<AuthzAuditEvent> events = handler.getConstraintAuditEvents(result, accessEvent);

Assertions.assertEquals(2, events.size());

AuthzAuditEvent maxRows = events.get(0);
AuthzAuditEvent approval = events.get(1);

Assertions.assertEquals("CONSTRAINT:maxRows", maxRows.getAccessType());
Assertions.assertEquals(20L, maxRows.getPolicyId());
Assertions.assertEquals(Long.valueOf(3L), maxRows.getPolicyVersion());
Assertions.assertEquals("CONSTRAINT:requireApproval", approval.getAccessType());
Assertions.assertEquals(21L, approval.getPolicyId());
Assertions.assertEquals(Long.valueOf(1L), approval.getPolicyVersion());

for (AuthzAuditEvent event : events) {
// other fields come from the access audit event
Assertions.assertEquals("alice", event.getUser());
Assertions.assertEquals("svcC", event.getRepositoryName());
Assertions.assertEquals(accessEvent.getAction(), event.getAction());
Assertions.assertEquals(accessEvent.getAccessResult(), event.getAccessResult());
Assertions.assertEquals(accessEvent.getEventTime(), event.getEventTime());
Assertions.assertEquals(accessEvent.getClientIP(), event.getClientIP());
Assertions.assertEquals(accessEvent.getSessionId(), event.getSessionId());
// each constraint event gets its own id when logged
Assertions.assertNull(event.getEventId());
}

// the access audit event is unchanged
Assertions.assertEquals(10L, accessEvent.getPolicyId());
Assertions.assertEquals("select", accessEvent.getAction());
}

@Test
public void test13_getConstraintAuditEvents_none() {
RangerDefaultAuditHandler handler = new RangerDefaultAuditHandler();
RangerAccessResult allowed = constraintResult("svcC", true);
RangerAccessResult denied = constraintResult("svcC", false);
RangerAccessResult noConstraints = new RangerAccessResult(0, "svcC", null, accessRequest());

noConstraints.setIsAudited(true);
noConstraints.setIsAllowed(true);

// not audited
Assertions.assertTrue(handler.getConstraintAuditEvents(allowed, null).isEmpty());
// denied: constraints are cleared, no constraint audit
Assertions.assertTrue(handler.getConstraintAuditEvents(denied, handler.getAuthzEvents(denied)).isEmpty());
// allowed without constraints
Assertions.assertTrue(handler.getConstraintAuditEvents(noConstraints, handler.getAuthzEvents(noConstraints)).isEmpty());
Assertions.assertTrue(handler.getConstraintAuditEvents(null, new AuthzAuditEvent()).isEmpty());
}

@Test
public void test14_processResult_logsConstraintAuditEvents() {
RangerAccessResult result = constraintResult("svcL", true);

try (MockedStatic<RangerBasePlugin> mocked = Mockito.mockStatic(RangerBasePlugin.class)) {
AuditHandler auditProvider = Mockito.mock(AuditHandler.class);

Mockito.when(auditProvider.log(Mockito.any(AuthzAuditEvent.class))).thenReturn(true);
mocked.when(() -> RangerBasePlugin.getAuditProvider("svcL")).thenReturn(auditProvider);

RangerDefaultAuditHandler handler = new RangerDefaultAuditHandler();

handler.processResult(result);

ArgumentCaptor<AuthzAuditEvent> captor = ArgumentCaptor.forClass(AuthzAuditEvent.class);

Mockito.verify(auditProvider, Mockito.times(3)).log(captor.capture());

List<AuthzAuditEvent> logged = captor.getAllValues();

Assertions.assertEquals("select", logged.get(0).getAction());
Assertions.assertEquals("CONSTRAINT:maxRows", logged.get(1).getAccessType());
Assertions.assertEquals("CONSTRAINT:requireApproval", logged.get(2).getAccessType());

Set<String> eventIds = new HashSet<>();

for (AuthzAuditEvent event : logged) {
eventIds.add(event.getEventId());
}

Assertions.assertEquals(3, eventIds.size()); // unique event ids
}

// processResults() includes the constraint audit events too
Collection<AuthzAuditEvent> events = new RangerDefaultAuditHandler().getAuthzEvents(Collections.singletonList(result));

Assertions.assertEquals(3, events.size());
}

private static RangerAccessRequestImpl accessRequest() {
RangerAccessRequestImpl ret = new RangerAccessRequestImpl();

ret.setUser("alice");
ret.setAccessType("select");
ret.setAction("select");
ret.setClientIPAddress("10.1.1.1");
ret.setSessionId("sess-c");
ret.setAccessTime(new Date(1720000000000L));

return ret;
}

private static RangerAccessResult constraintResult(String serviceName, boolean isAllowed) {
RangerAccessResult ret = new RangerAccessResult(0, serviceName, null, accessRequest());

ret.setIsAudited(true);
ret.setIsAllowed(true);
ret.setPolicyId(10L);
ret.addConstraint(new RangerConstraintResult("maxRows", Collections.singletonMap("rowCount", 100), 20L, 3L, 0, RangerPolicyResourceMatcher.MatchType.SELF));
ret.addConstraint(new RangerConstraintResult("requireApproval", Collections.singletonMap("approver", "finance"), 21L, 1L, 0, RangerPolicyResourceMatcher.MatchType.SELF));

if (!isAllowed) {
ret.setIsAllowed(false); // clears the constraints
}

return ret;
}

private Set<String> invokeGetTags(RangerDefaultAuditHandler handler, RangerAccessRequest request) {
try {
Method m = RangerDefaultAuditHandler.class.getDeclaredMethod("getTags", RangerAccessRequest.class);
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,7 @@ public void processResult(RangerAccessResult result) {
}

auditEvents.add(auditEvent);
auditEvents.addAll(getConstraintAuditEvents(result, auditEvent));
}
}
}
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,82 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/

package org.apache.ranger.authz.embedded;

import org.apache.ranger.audit.model.AuthzAuditEvent;
import org.apache.ranger.plugin.policyengine.RangerAccessRequestImpl;
import org.apache.ranger.plugin.policyengine.RangerAccessResult;
import org.apache.ranger.plugin.policyengine.RangerConstraintResult;
import org.apache.ranger.plugin.policyresourcematcher.RangerPolicyResourceMatcher.MatchType;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class TestRangerAuthzAuditHandlerConstraints {
@Test
public void testConstraintAuditEventsAreCollected() {
List<AuthzAuditEvent> events;
try (RangerAuthzAuditHandler handler = new RangerAuthzAuditHandler("test-app")) {
RangerAccessResult result = result(true);
result.addConstraint(new RangerConstraintResult("requireApproval", Collections.singletonMap("approver", "finance"), 21L, 1L, 0, MatchType.SELF));
handler.processResult(result);
events = new ArrayList<>(handler.getAuditEvents());
}

assertEquals(2, events.size());
assertEquals("select", events.get(0).getAction());
assertEquals("CONSTRAINT:requireApproval", events.get(1).getAccessType());
assertEquals(21L, events.get(1).getPolicyId());
assertEquals("test-app", events.get(1).getAgentId());
}

@Test
public void testDeniedResultReplacesConstraintAuditEvents() {
try (RangerAuthzAuditHandler handler = new RangerAuthzAuditHandler("test-app")) {
RangerAccessResult allowed = result(true);
allowed.addConstraint(new RangerConstraintResult("requireApproval", null, 21L, 1L, 0, MatchType.SELF));
handler.processResult(allowed);
handler.processResult(result(false));
// only the denied audit is kept, as for other audits
assertEquals(1, handler.getAuditEvents().size());
assertEquals((short) 0, handler.getAuditEvents().iterator().next().getAccessResult());
}
}

private static RangerAccessResult result(boolean isAllowed) {
RangerAccessRequestImpl request = new RangerAccessRequestImpl();

request.setUser("alice");
request.setAccessType("select");
request.setAction("select");

RangerAccessResult ret = new RangerAccessResult(0, "svc", null, request);

ret.setIsAudited(true);
ret.setIsAccessDetermined(true);
ret.setIsAllowed(isAllowed);
ret.setPolicyId(10L);

return ret;
}
}