From 1cec7552d93578efd730a79e10559b6a05f45e9a Mon Sep 17 00:00:00 2001 From: Vyom Mani Tiwari Date: Wed, 18 Nov 2026 10:42:09 +0530 Subject: [PATCH] RANGER-5870: Audit: record the constraints returned with an allowed access decision --- .../audit/RangerDefaultAuditHandler.java | 58 ++++++++ .../audit/TestRangerDefaultAuditHandler.java | 128 ++++++++++++++++++ .../embedded/RangerAuthzAuditHandler.java | 1 + ...estRangerAuthzAuditHandlerConstraints.java | 82 +++++++++++ 4 files changed, 269 insertions(+) create mode 100644 authz-embedded/src/test/java/org/apache/ranger/authz/embedded/TestRangerAuthzAuditHandlerConstraints.java diff --git a/agents-common/src/main/java/org/apache/ranger/plugin/audit/RangerDefaultAuditHandler.java b/agents-common/src/main/java/org/apache/ranger/plugin/audit/RangerDefaultAuditHandler.java index 395bfcd0990..d626494d06b 100644 --- a/agents-common/src/main/java/org/apache/ranger/plugin/audit/RangerDefaultAuditHandler.java +++ b/agents-common/src/main/java/org/apache/ranger/plugin/audit/RangerDefaultAuditHandler.java @@ -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; @@ -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; @@ -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"; @@ -82,6 +86,7 @@ public void processResult(RangerAccessResult result) { AuthzAuditEvent event = getAuthzEvents(result); logAuthzAudit(event); + logAuthzAudits(getConstraintAuditEvents(result, event)); LOG.debug("<== RangerDefaultAuditHandler.processResult({})", result); } @@ -173,6 +178,7 @@ public Collection getAuthzEvents(Collection } ret.add(event); + ret.addAll(getConstraintAuditEvents(result, event)); } } @@ -181,6 +187,24 @@ public Collection getAuthzEvents(Collection return ret; } + public List getConstraintAuditEvents(RangerAccessResult result, AuthzAuditEvent accessEvent) { + if (accessEvent == null || result == null || !result.getIsAllowed() || result.getConstraints().isEmpty()) { + return Collections.emptyList(); + } + + List 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); @@ -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 getDatasets(RangerAccessRequest request) { GdsAccessResult gdsResult = RangerAccessRequestUtil.getGdsResultFromContext(request.getContext()); diff --git a/agents-common/src/test/java/org/apache/ranger/plugin/audit/TestRangerDefaultAuditHandler.java b/agents-common/src/test/java/org/apache/ranger/plugin/audit/TestRangerDefaultAuditHandler.java index 21f543edc2c..4fb6002235c 100644 --- a/agents-common/src/test/java/org/apache/ranger/plugin/audit/TestRangerDefaultAuditHandler.java +++ b/agents-common/src/test/java/org/apache/ranger/plugin/audit/TestRangerDefaultAuditHandler.java @@ -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; @@ -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; @@ -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; @@ -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 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 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 captor = ArgumentCaptor.forClass(AuthzAuditEvent.class); + + Mockito.verify(auditProvider, Mockito.times(3)).log(captor.capture()); + + List 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 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 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 invokeGetTags(RangerDefaultAuditHandler handler, RangerAccessRequest request) { try { Method m = RangerDefaultAuditHandler.class.getDeclaredMethod("getTags", RangerAccessRequest.class); diff --git a/authz-embedded/src/main/java/org/apache/ranger/authz/embedded/RangerAuthzAuditHandler.java b/authz-embedded/src/main/java/org/apache/ranger/authz/embedded/RangerAuthzAuditHandler.java index f9eab585a71..800da08c6f2 100644 --- a/authz-embedded/src/main/java/org/apache/ranger/authz/embedded/RangerAuthzAuditHandler.java +++ b/authz-embedded/src/main/java/org/apache/ranger/authz/embedded/RangerAuthzAuditHandler.java @@ -52,6 +52,7 @@ public void processResult(RangerAccessResult result) { } auditEvents.add(auditEvent); + auditEvents.addAll(getConstraintAuditEvents(result, auditEvent)); } } } diff --git a/authz-embedded/src/test/java/org/apache/ranger/authz/embedded/TestRangerAuthzAuditHandlerConstraints.java b/authz-embedded/src/test/java/org/apache/ranger/authz/embedded/TestRangerAuthzAuditHandlerConstraints.java new file mode 100644 index 00000000000..f657bfd7135 --- /dev/null +++ b/authz-embedded/src/test/java/org/apache/ranger/authz/embedded/TestRangerAuthzAuditHandlerConstraints.java @@ -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 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; + } +}