Location Research Breakthrough Possible @S-Logix pro@slogix.in

Isolating Unauthorized Service-to-Service Access Attempts in Istio Service Meshes Through Workload Identity Verification and Zero Trust Authorization Policies

Description

Modern microservice applications contain multiple services that communicate with one another over internal networks. Although these services may operate inside the same Kubernetes cluster or service mesh, network-level reachability does not necessarily mean that one workload should be permitted to access another workload.

Istio provides security controls for authenticating workloads and enforcing authorization policies between services. Istio mutual TLS can provide authenticated workload identity, while authorization policies can use the authenticated source identity to control access to target workloads. When peer authentication with mutual TLS is used, Istio exposes the authenticated workload identity through the `source.principal` authorization attribute.

In this use case, a controlled Istio service mesh is deployed on Ubuntu Linux inside an isolated VirtualBox laboratory. Multiple synthetic microservices are deployed to represent legitimate service-to-service communication.

A controlled unauthorized service-to-service access scenario is created by allowing a workload with a valid mesh identity to attempt communication with a protected service for which that workload has no authorization. The assessment verifies whether network reachability alone permits the unauthorized service to communicate with the protected workload and whether Istio can distinguish the authenticated workload identity from the authorization policy assigned to the target service.

Istio PeerAuthentication is used to enforce mutual TLS for protected workloads. Istio AuthorizationPolicy is then used to permit only explicitly authorized workload identities to access the protected service. Istio authorization policies support ALLOW, DENY, and CUSTOM actions, with DENY evaluated before ALLOW.

The controlled access attempt is generated from a test workload representing an unauthorized service. The workload possesses a valid Istio identity but attempts to access a service outside its permitted service-to-service authorization boundary. Kali Linux is used as the external security-testing environment for controlled service-discovery and validation activities, while Kubernetes test workloads generate the actual service-to-service requests inside the mesh.

Wazuh monitors relevant Ubuntu, Kubernetes, and security activity, while OpenSearch provides centralized investigation and correlation of the generated security telemetry. The same access attempts are repeated after the Zero Trust controls are configured to verify that unauthorized workload identities are denied while authorized service-to-service communication remains functional.

Complete Zero Trust Security Workflow: Istio Service Mesh → Workload Deployment → Workload Identity Assignment → Service-to-Service Communication → Unauthorized Access Attempt → mTLS Identity Verification → Source Workload Identification → Authorization Policy Evaluation → Unauthorized Request Denied → Security Event Monitoring → Authorized Communication Validation → Post-Remediation Verification

Existing Security Problem

Application: Istio Service Mesh

Istio is the target service-mesh platform in this use case. It provides service-to-service traffic management and security capabilities for workloads participating in the mesh. Istio authentication policies can enforce mutual TLS between workload proxies, while authorization policies can restrict access to workloads according to authenticated source identities and other request attributes.

Existing Problem:

Microservices may be able to establish network connections to other services even when the calling workload should not have permission to access the destination. If service-to-service authorization is not sufficiently restrictive, a compromised, misused, or unauthorized workload may attempt to communicate with protected internal services.

The security problem is therefore:

Istio Service Mesh → Multiple Microservices → Workload Receives Valid Network Connectivity → Unauthorized Service Attempts Internal Access → Target Service Receives Request → Insufficient Workload Authorization Restriction → Unauthorized Service-to-Service Communication → Protected Service Exposure → Potential Unauthorized Data or Function Access

The proposed solution introduces workload identity verification, mutual TLS enforcement, source-principal validation, least-privilege authorization policies, unauthorized-request blocking, security monitoring, and post-remediation validation. The protected service evaluates the authenticated source workload identity against its authorization policy before permitting access.

Attack

Specific Attack: Unauthorized Service-to-Service Access Attempt

The controlled attack evaluates whether a workload with valid mesh connectivity but without authorization to access a protected service can communicate with that service. The attacking workload is not required to forge or steal an identity. Instead, it represents a legitimate mesh workload whose identity is not authorized for the requested destination. This models a Zero Trust scenario in which a compromised or incorrectly authorized service attempts to move laterally toward another internal service. The assessment verifies whether Istio evaluates the identity of the requesting workload rather than relying only on network location or service reachability.

Attack Behavior:
Kali Linux / Controlled Test Client
→
Istio Service Mesh Discovery
→
Unauthorized Test Workload
→
Valid Workload Identity
→
Service-to-Service Access Attempt
→
Protected Target Service
→
mTLS Peer Identity Verification
→
Source Workload Identity Extraction
→
AuthorizationPolicy Evaluation
→
Unauthorized Identity Detected
→
Service-to-Service Request Denied
→
Security Event Generated
→
Wazuh Monitoring
→
OpenSearch Investigation
→
Post-Remediation Validation

Security Concept

Workload Identity-Based Zero Trust Service Authorization:

The primary security concept is workload identity-based Zero Trust authorization. The security decision is based on the identity of the workload initiating the connection rather than simply trusting that the request originated from inside the cluster or service mesh. Istio peer authentication can enforce mutual TLS between workloads. When mutual TLS is used, Istio can extract the peer workload identity and expose it as `source.principal` for authorization decisions.The authorization layer then determines whether the authenticated source workload is permitted to access the destination workload.Istios authorization model supports workload selectors and source conditions such as principals, allowing policies to restrict which service identities may access a protected workload.

The secure processing flow is:

Workload Deployment
→
Workload Identity Assignment
→
Service-to-Service Request
→
mTLS Authentication
→
Authenticated Source Workload
→
`source.principal` Identification
→
AuthorizationPolicy Evaluation
→
Identity and Access Rule Matching
→
Authorized Request
→
Service Access Permitted
→
Policy Violation
→
Access Denied
→
Security Event Logging
→
Post-Remediation Validation

Defensive Mechanism

Workload Identity Verification

Istio verifies the identity of workloads participating in service-to-service connections through the configured mesh authentication mechanism.

Purpose

Ensure that service-to-service access decisions are associated with an authenticated workload identity rather than relying only on network location.

Mutual TLS Enforcement

Strict mutual TLS is applied to protected workloads so that incoming service-to-service connections require authenticated mTLS. Istio PeerAuthentication supports STRICT mode, which requires mTLS for incoming connections to the selected workload.

Purpose

Prevent protected workloads from accepting unauthenticated plaintext service-to-service connections.

Source Principal Validation

The authenticated source workload identity is evaluated through Istio authorization attributes such as `source.principal`.

Purpose

Associate each service-to-service request with the authenticated workload identity that initiated it.

Least-Privilege Authorization Policy

Authorization policies are configured so that protected services accept requests only from explicitly authorized workload identities.

Purpose

Restrict service-to-service communication to the minimum required workload relationships.

Unauthorized Access Blocking

Requests from authenticated workloads that do not satisfy the target service authorization policy are denied.

Purpose

Prevent valid but unauthorized workload identities from accessing protected services.

Explicit Service-to-Service Access Definition

Permitted workload-to-service relationships are explicitly defined instead of relying on implicit internal-network trust.

Purpose

Establish a controlled service communication boundary for the Zero Trust architecture.

Security Event Monitoring

Relevant access-control and workload activity is collected for security monitoring and investigation.

Purpose

Provide visibility into unauthorized service-to-service access attempts and policy enforcement.

Post-Remediation Validation

The same unauthorized and authorized access scenarios are repeated after policy enforcement.

Purpose

Verify that unauthorized service identities remain blocked while approved service communication continues to operate.

Security Tools

Primary Service Mesh Security Platform: Istio

Istio provides the service-mesh security architecture used to authenticate workloads and enforce service-to-service authorization.

Purpose
  • Deploy the controlled service mesh.
  • Provide workload-to-workload communication.
  • Provide mTLS-based workload authentication.
  • Apply AuthorizationPolicy controls.
  • Enforce service-to-service access boundaries.
  • Validate Zero Trust authorization behavior.

Workload Orchestration Platform: Kubernetes

Kubernetes hosts the controlled microservices used to demonstrate authorized and unauthorized service-to-service communication.

Purpose
  • Deploy laboratory workloads.
  • Assign Kubernetes service accounts.
  • Create controlled services.
  • Provide workload networking.
  • Support repeatable service-to-service access testing.

Workload Authentication Mechanism: Istio Mutual TLS

Istio mutual TLS provides authenticated communication between participating workloads. Istio can use the authenticated peer identity when processing authorization decisions.

Purpose
  • Authenticate workload-to-workload connections.
  • Protect service-to-service traffic.
  • Provide authenticated workload identity.
  • Support source-principal-based authorization.

Authorization Control: Istio AuthorizationPolicy

`AuthorizationPolicy` defines which workload identities can access the protected service. Istio authorization policies support ALLOW, DENY, and CUSTOM actions and can evaluate source workload identity attributes.

Purpose
  • Define permitted service relationships.
  • Restrict protected workloads.
  • Block unauthorized workload identities.
  • Implement least-privilege service authorization.

Service Identity Platform: Kubernetes Service Accounts

Kubernetes service accounts provide the workload identity association used by the laboratory services and are represented in Istio workload identity information.

Purpose
  • Associate workloads with controlled identities.
  • Create distinct identities for test services.
  • Support identity-based authorization policies.
  • Validate service-to-service identity boundaries.

Security Testing Platform: Kali Linux

Kali Linux provides the controlled security-testing environment for service discovery and application-level validation.

Purpose
  • Perform authorized service testing.
  • Generate controlled requests where externally reachable test interfaces exist.
  • Validate exposed service behavior.
  • Support post-remediation access testing.

Host Environment: Ubuntu Linux

Ubuntu Linux hosts the controlled Kubernetes and Istio security laboratory.

Purpose
  • Run the laboratory infrastructure.
  • Host Kubernetes components.
  • Run Istio control-plane components.
  • Store security-test configurations.
  • Support Wazuh monitoring.

Security Monitoring Tool: Wazuh

Wazuh monitors relevant Ubuntu, Kubernetes, and security activity associated with the controlled service-mesh assessment.

Purpose
  • Collect security telemetry.
  • Monitor service and host activity.
  • Record relevant authorization activity where available.
  • Support detection of unauthorized access attempts.
  • Provide post-remediation monitoring.

Security Investigation Platform: OpenSearch

OpenSearch provides centralized investigation of the security telemetry generated during the assessment.

Purpose
  • Search Wazuh events.
  • Review timestamps.
  • Correlate service-access activity.
  • Investigate unauthorized access attempts.
  • Compare pre- and post-remediation behavior.

Virtualization Platform: VirtualBox

VirtualBox provides the isolated laboratory infrastructure for the controlled Zero Trust service-mesh assessment.

Purpose
  • Host Ubuntu.
  • Host Kali Linux.
  • Provide controlled virtual networking.
  • Isolate Zero Trust testing.
  • Prevent unintended interaction with production systems.

Process

STEP 01

Step 1: Prepare the Isolated Zero Trust Security Laboratory

  • Create an isolated cybersecurity laboratory using VirtualBox.
  • Configure Ubuntu as the Kubernetes and Istio laboratory environment.
  • Configure Kali Linux as the controlled security-testing system.
  • Establish controlled network communication between the virtual machines.
  • Assign laboratory network addresses.
  • Verify connectivity between the required systems.
  • Confirm that all service-mesh testing remains restricted to the authorized laboratory.
Tools: VirtualBox + Ubuntu Linux + Kali Linux
STEP 02

Step 2: Deploy the Kubernetes Environment

  • Install the required Kubernetes components on the Ubuntu laboratory environment.
  • Create the laboratory Kubernetes cluster.
  • Verify that the Kubernetes control plane is operational.
  • Verify that worker resources are available.
  • Create a dedicated namespace for the Istio security assessment.
  • Record the initial Kubernetes configuration.
Tools: Kubernetes + Ubuntu Linux
STEP 03

Step 3: Deploy Istio Service Mesh

  • Install Istio into the controlled Kubernetes cluster.
  • Verify that the Istio control plane is operational.
  • Enable sidecar injection for the laboratory namespace where sidecar-mode testing is used.
  • Verify that the required Envoy proxies are deployed with the workloads.
  • Confirm that the test services can participate in the Istio mesh.
  • Record the initial Istio configuration and version.
Tools: Istio + Kubernetes + Ubuntu Linux
STEP 04

Step 4: Create Controlled Microservices

  • Deploy a legitimate client service.
  • Deploy an additional test service representing an unauthorized workload.
  • Deploy the protected target service.
  • Assign separate Kubernetes service accounts to the laboratory workloads.
  • Create Kubernetes Services for the required application endpoints.
  • Verify that the workloads are running correctly.
Tools: Kubernetes + Istio + Ubuntu Linux
STEP 05

Step 5: Establish the Initial Service-to-Service Baseline

  • Identify the legitimate client-to-target service relationship.
  • Identify the unauthorized test workload-to-target service relationship.
  • Submit controlled requests from the legitimate client.
  • Submit controlled requests from the unauthorized test workload.
  • Record whether network-level communication is possible before restrictive authorization policies are applied.
  • Preserve the initial connectivity results as the security baseline.
Tools: Kubernetes + Istio + cURL
STEP 06

Step 6: Review Workload Identity Configuration

  • Inspect the Kubernetes service accounts assigned to each laboratory workload.
  • Identify the service identity associated with the legitimate client.
  • Identify the service identity associated with the unauthorized test workload.
  • Identify the identity associated with the protected target workload.
  • Review the Istio workload identity information available for the deployed services.
  • Record the expected source identities for the authorization policies.
Tools: Kubernetes + Istio + kubectl
STEP 07

Step 7: Configure Mutual TLS for the Protected Services

  • Create the required `PeerAuthentication` policy.
  • Configure the protected namespace or workload to require strict mutual TLS.
  • Apply the policy to the laboratory environment.
  • Verify that the protected workload accepts mTLS connections.
  • Verify the behavior of connections that do not satisfy the configured mTLS requirement.
  • Confirm that the authenticated workload identity is available for authorization processing.
Tools: Istio PeerAuthentication + Kubernetes + kubectl
STEP 08

Step 8: Validate Workload Identity Authentication

  • Generate a service-to-service request from the legitimate workload.
  • Generate a service-to-service request from the unauthorized test workload.
  • Verify that both workloads are authenticated through the configured mesh security mechanism.
  • Identify the source workload identity associated with each request.
  • Verify that the identity information corresponds to the expected Kubernetes service account.
  • Record the identity-validation results.
Tools: Istio + Kubernetes + cURL + kubectl
STEP 09

Step 9: Configure the Protected Service Authorization Boundary

  • Create an `AuthorizationPolicy` for the protected target service.
  • Define the protected workload selector.
  • Specify the legitimate source workload identity that is permitted to access the service.
  • Do not grant the unauthorized test workload access to the protected service.
  • Define the required service operation or traffic conditions.
  • Apply the policy to the laboratory target workload.
Tools: Istio AuthorizationPolicy + Kubernetes
STEP 10

Step 10: Validate Authorized Service-to-Service Access

  • Generate a request from the authorized client workload to the protected service.
  • Verify that the request contains the expected authenticated workload identity.
  • Verify that the source identity matches the configured authorization rule.
  • Confirm that the protected service accepts the authorized request.
  • Record the response and access result.
  • Preserve the authorized communication as the positive security baseline.
Tools: Istio + Kubernetes + cURL
STEP 11

Step 11: Perform the Controlled Unauthorized Access Attempt

  • Generate a request from the unauthorized laboratory workload toward the protected service.
  • Use the same target service endpoint used during the authorized test.
  • Verify that the requesting workload possesses a valid mesh identity.
  • Observe the authorization decision made for the request.
  • Record the access result.
  • Preserve the unauthorized access attempt as controlled assessment evidence.
Tools: Kubernetes + Istio + cURL
STEP 12

Step 12: Validate Source-Identity-Based Authorization

  • Review the source identity associated with the unauthorized request.
  • Compare the authenticated source identity with the identities permitted by the `AuthorizationPolicy`.
  • Verify that the unauthorized workload identity does not satisfy the policy.
  • Confirm that the request is denied by the service-mesh authorization layer.
  • Repeat the test to confirm that the result is consistent.
  • Record the authorization decision and associated evidence.
Tools: Istio AuthorizationPolicy + Kubernetes + OpenSearch
STEP 13

Step 13: Assess Zero Trust Access Enforcement

  • Review the difference between network reachability and authorization.
  • Verify whether the unauthorized workload has service-level network reachability but does not receive application authorization.
  • Confirm that the protected service depends on authenticated workload identity and authorization policy.
  • Review whether any unintended workload identity is permitted.
  • Identify any excessive service-to-service permissions.
  • Document the required access-control remediation.
Tools: Istio + Kubernetes + cURL + OpenSearch
STEP 14

Step 14: Configure Security Monitoring

  • Configure Wazuh monitoring for the Ubuntu and Kubernetes environment.
  • Monitor relevant Istio and workload logs where available.
  • Monitor authorization-related security events.
  • Monitor Kubernetes workload activity.
  • Monitor configuration changes to the security policies.
  • Verify that the relevant telemetry is forwarded for investigation.
  • Establish the post-control monitoring baseline.
Tools: Wazuh + Ubuntu Linux + Kubernetes + Istio
STEP 15

Step 15: Generate and Record the Unauthorized Access Security Event

  • Repeat the unauthorized workload-to-service request.
  • Record the request timestamp.
  • Record the source workload identity.
  • Record the target service identity.
  • Record the authorization decision.
  • Review the corresponding application and service-mesh telemetry.
  • Forward the relevant evidence to Wazuh and OpenSearch for investigation.
  • Preserve the generated event.
Tools: Istio + Kubernetes + Wazuh + OpenSearch
STEP 16

Step 16: Investigate the Access Attempt Through OpenSearch

  • Search OpenSearch for the recorded unauthorized service-to-service access event.
  • Correlate the source workload identity with the access attempt.
  • Correlate the target service with the requested operation.
  • Compare the event timestamp with the controlled test execution time.
  • Verify that the request was denied according to the configured authorization boundary.
  • Preserve the investigation evidence.
Tools: OpenSearch + Wazuh + Istio
STEP 17

Step 17: Perform Post-Remediation Unauthorized Access Testing

  • Repeat the controlled unauthorized service-to-service access attempt.
  • Verify that the workload is still authenticated.
  • Verify that the source identity is correctly identified.
  • Verify that the identity remains outside the permitted authorization policy.
  • Confirm that the protected service denies the request.
  • Compare the result with the initial security baseline.
Tools: Kubernetes + Istio + cURL
STEP 18

Step 18: Validate Legitimate Service Communication

  • Generate requests from the authorized workload.
  • Verify that the legitimate workload identity continues to satisfy the authorization policy.
  • Confirm that authorized requests reach the protected service.
  • Verify that normal application functionality remains available.
  • Review Wazuh telemetry for unexpected authorization failures.
  • Compare authorized and unauthorized service-to-service results.
Tools: Istio + Kubernetes + cURL + Wazuh
STEP 19

Step 19: Perform Final Zero Trust Security Validation

  • Review the complete workload identity configuration.
  • Review the final `PeerAuthentication` configuration.
  • Review the final `AuthorizationPolicy` configuration.
  • Repeat both authorized and unauthorized service-to-service tests.
  • Confirm that unauthorized workload identities remain blocked.
  • Confirm that authorized workloads retain required service access.
  • Review Wazuh and OpenSearch security telemetry.
  • Document residual access-control risks and policy limitations.
  • Preserve the final validation evidence.
  • Finalize the controlled Zero Trust service-to-service access assessment.
Tools: Istio + Kubernetes + Ubuntu Linux + Kali Linux + Wazuh + OpenSearch + cURL

Outcome

  1. A controlled Istio service-mesh environment is successfully deployed on Ubuntu and Kubernetes, providing an isolated platform for testing workload identity and Zero Trust service-to-service authorization.
  2. Multiple laboratory microservices with distinct workload identities are established, providing separate authorized and unauthorized service-to-service access conditions.
  3. Mutual TLS is configured for the protected workloads, establishing authenticated workload-to-workload communication within the service mesh.
  4. Workload identities are validated through the Istio service-mesh security layer, allowing service-to-service access decisions to be associated with authenticated source workloads.
  5. Istio AuthorizationPolicy is implemented to establish a least-privilege service-to-service access boundary, permitting the defined authorized workload while restricting unauthorized workload identities.
  6. Unauthorized service-to-service access attempts are denied, demonstrating that valid mesh connectivity or workload identity alone does not provide authorization to access the protected service.
  7. Wazuh provides security monitoring for the controlled service-mesh environment, recording relevant host, workload, and security activity associated with the access-control assessment.
  8. OpenSearch provides centralized investigation of the generated security telemetry, allowing workload identities, target services, timestamps, and access-control events to be correlated.
  9. Post-remediation testing confirms that authorized service-to-service communication continues to function while unauthorized workload access remains blocked, validating the implemented Zero Trust access boundary.
  10. The complete Istio workload identity verification → mutual TLS authentication → source-principal identification → AuthorizationPolicy evaluation → unauthorized access blocking → security monitoring → investigation → authorized communication validation → final Zero Trust security assessment workflow is successfully demonstrated.
← Previous Project
Project 7 of 7