Search/openid
● Vendor

openid

Known CVEs
0
Highest CVSS
—
In KEV
0
Vendor
openid connect
Connections
36 relationships
Propagate user authorization context in AI agents with Amazon Bedrock AgentCore
Many teams now deploy AI agents that pull from Amazon DynamoDB tables, document repositories, software as a service (SaaS) platforms, and internal knowledge bases to answer questions and automate workflows. A key risk in these deployments is that the agent has no awareness of who’s asking, so it might return data the user shouldn’t see. If you’re using Amazon Bedrock AgentCore to build AI agents that access multiple data sources, you need each user to see only the data they’re authorized to access. In this post, you learn patterns for propagating user authorization context through your agents so access control is enforced by infrastructure and downstream services, not by agent code. In this post, we show you how to deploy agents that enforce least privilege access without writing authorization logic in the agent itself. This approach follows AGENTSEC03 best practice in the AWS Well-Architected Agentic AI Lens . Use case Consider an example of a customer relationship management (CRM) chat application where employees from Sales and Finance departments interact with an AI agent to access customer information. Employees use the same chat interface and the same agent, but each department needs isolated access to their respective data: Sales needs access to customer contracts, pricing strategies, and sales pipeline data Finance needs access to customer invoices, payment records, and financial reports The AI agent accesses three types of data sources on behalf of users: Customer records in Amazon DynamoDB , partitioned by department Department-specific documents in Amazon Bedrock Knowledge Bases (stored in Amazon Simple Storage Service (Amazon S3) ) External CRM data in Salesforce When a Sales employee asks, “Show me customer contracts,” the agent must retrieve only Sales department contracts, not Finance invoices. This enforcement must happen outside the agent so that even if the agent is compromised through prompt injection or application bugs, it can’t access unauthorized data. Note: Although we use department-based scoping in this example, the pattern generalizes to any custom claim you define, whether it represents a role, business unit, geographic region, or project assignment. Architecture overview The following diagram shows the architecture used in this demonstration. Figure 1: Target architecture The data flow shown in Figure 1 includes: A user opens the chat application and authenticates with Amazon Cognito user pool , which acts as the identity provider (IdP). A pre token generation Lambda trigger (V2) enriches the JSON Web Tokens (JWTs) with a custom claim and AWS session tag metadata before returning them to the user. The web app routes the user’s request along with the access token to the agent deployed on Amazon Bedrock AgentCore Runtime. Bedrock AgentCore Runtime validates the inbound JWT and, through Bedrock AgentCore Identity , issues a workload access token that binds the user and agent identities, and then invokes the agent. For queries requiring internal documents, the agent uses its AWS Identity and Access Management (IAM) role to query Amazon Bedrock Knowledge Bases (backed by an Amazon S3 vector store) with metadata filtering, and DynamoDB with user-scoped session-tagged credentials. For queries requiring external data, Bedrock AgentCore Identity retrieves credentials from AWS Secrets Manager and performs an on-behalf-of token exchange ( RFC 8693 ) with Salesforce, returning a user-scoped access token. The agent calls the Salesforce REST API using the user-scoped token. Salesforce applies sharing rules and returns only records the user is authorized to access. This architecture follows two key principles. The agent acts as an orchestrator, not a gatekeeper; it coordinates tool calls and reasoning but doesn’t control access to data. Authorization is enforced by downstream services. The agent doesn’t store credentials to data stores; instead, each request gets temporary, user-bound access tokens. In the following sections, we dive deep into each data source to show how these principles are achieved in practice. Initial user authentication with IdP When an employee opens the chat application, they authenticate using their corporate credentials. For this example, you use Amazon Cognito user pools as the IdP. You can also achieve this with other IdPs such as Entra ID or Okta. The pre token generation Lambda trigger (V2) captures the user’s custom department context and adds it to the tokens to both the identity (ID) token and access token that Bedrock AgentCore Runtime uses for authorization decisions each serving a distinct purpose. The access token is used by the Bedrock AgentCore Runtime custom JWT authorizer for inbound authorization. The ID token also receive the https://aws.amazon.com/tags claim (used by AWS Security Token Service (AWS STS)) for session tags). The https://aws.amazon.com/tags claim is the specific format required by AWS STS to extract session tags during AssumeRoleWithWebIdentity . For more information and step-by-step guidance see How to customize access tokens in Amazon Cognito user pools . The following example shows the key logic within a pre token generation Lambda handler function configured as a trigger on your Amazon Cognito user pool. This code runs automatically when a user authenticates, extracting their department attribute and adding it as a custom claim to both ID Token and access token. import json def lambda_handler(event, context): department = event['request']['userAttributes'].get('custom:department', '') event['response']['claimsAndScopeOverrideDetails'] = { 'idTokenGeneration': { 'claimsToAddOrOverride': { 'department': department, 'https://aws.amazon.com/tags': { "principal_tags": {"department": [department]}, "transitive_tag_keys": ["department"] } } }, 'accessTokenGeneration': { 'claimsToAddOrOverride': { 'department': department } } } return event Inbound authorization by AgentCore Runtime When the user request reaches AgentCore Runtime, the Inbound JWT authorizer performs two checks as shown in Figure 2. It validates the JWT token with Amazon Cognito (the configured IdP) by cryptographically verifying the token’s signature, confirming it is non-expired, and checking it was issued by the trusted IdP. It then extracts the department claim from the validated token and compares it against the expected value configured in the authorizer, any token without a matching claim is rejected before the agent code is invoked. Figure 2: Inbound JWT authorization The following example shows the inbound JWT authorizer configuration that you pass when deploying your agent to AgentCore Runtime. This configuration tells AgentCore which IdP to validate against and which custom claim value to enforce for this agent. In this example, inboundTokenClaimName is department, inboundTokenClaimValueType declares the claim type as STRING_ARRAY , and authorizingClaimMatchValue specifies the allowed values ( [“Sales”, “Finance”] ) with the CONTAINS_ANY operator. The authorizer validates that the department claim is present in the token and matches one of these values, ensuring only authenticated users from the Sales or Finance department can invoke the agent. authorizer_config = { "customJWTAuthorizer": { "discoveryUrl": discovery_url, "allowedClients": [client_id], "customClaims": [ { "inboundTokenClaimName": "department", "inboundTokenClaimValueType": "STRING_ARRAY", "authorizingClaimMatchValue": { "claimMatchValue": ["Sales", "Finance"] "claimMatchOperator": "CONTAINS_ANY" } } ] } } Note: AgentCore Runtime automatically creates a workload identity for each deployed agent. A workload identity represents the digital identity of your agents within the AWS environment. It allows agents to maintain consistent identity whether they’re using IAM roles for AWS resource access, OAuth 2.0 tokens for external service integration, or API keys for third-party tool access. Passing the user context for agent outbound authorization After the inbound JWT token is validated and the user’s authorization context is confirmed, the agent must propagate this context to downstream resources. The fundamental security challenge here is how to design a system so that an agent acting on behalf of a user can only access data that user is authorized to see, even if the agent itself is compromised. The traditional approach of granting the agent broad credentials and relying on application-level filtering (such as adding WHERE clauses to queries) creates a single point of failure. If an attacker manipulates the agent through prompt injection or exploits a bug in the filtering logic, the full dataset becomes accessible. A more resilient design moves authorization enforcement out of the agent’s application code and into the infrastructure layer wherever possible. Instead of trusting the agent to filter results correctly, you configure the underlying services—IAM policies, database access controls, SaaS sharing rules—to reject unauthorized requests regardless of what the agent asks for. This way, the agent’s credentials are inherently limited to the requesting user’s permissions, and no amount of prompt manipulation can bypass those boundaries. Where infrastructure-level enforcement isn’t yet available, such as metadata filtering in Amazon Bedrock Knowledge Bases, the agent applies application-layer controls as a complementary measure. The following sections demonstrate how this principle applies to each data source in our architecture. Pattern 1: Scoping DynamoDB access to the requesting user For DynamoDB access, you can use AssumeRoleWithWebIdentity with session tags to create per-request, user-scoped credentials rather than granting the agent a static IAM role with direct table access. The agent passes the user’s signed ID token to AWS STS, which extracts the department tag from the token’s https://aws.amazon.com/tags claim and returns temporary credentials constrained to that department’s data partition. This moves access control from agent code to IAM policy evaluation. STS additionally validates the token’s audience (aud) claim against the IAM OIDC provider configuration, preventing tokens issued for other app clients from being used to assume the role. The following diagram shows this flow (Figure 3). Figure 3: DynamoDB access using AssumeRoleWithWebIdentity and session tags Prerequisites (one-time setup): Before this runtime flow can execute, complete the following configuration: Register Amazon Cognito as an IAM OIDC provider. Although the user authenticates using the Cognito API ( USER_PASSWORD_AUTH ), STS requires Cognito to be registered as an OIDC provider so it can discover and validate ID tokens. Configure the allowed client IDs (audiences) on the provider to match your application’s app client ID. CognitoOIDCProvider: Type: AWS::IAM::OIDCProvider Properties: Url: !Sub 'https://cognito-idp.${AWS::Region}.amazonaws.com/${CognitoUserPoolId}' ClientIdList: - !Ref CognitoAppClientId ThumbprintList: - '<thumbprint>' Configure the UserScopedDynamoDBRole trust policy to include both sts:AssumeRoleWithWebIdentity and sts:TagSession permissions, with the Amazon Cognito OIDC provider as the federated principal. { "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Federated": "arn:aws:iam::111122223333:oidc-provider/cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE" }, "Action": [ "sts:AssumeRoleWithWebIdentity", "sts:TagSession" ], "Condition": { "StringEquals": { "cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE:aud": "<app-client-id>" } } }] } By default, AgentCore Runtime drops custom headers as a security measure. To allow the X-Id-Token header through to the agent container, configure it in the agent runtime’s requestHeaderAllowlist so the ID token is forwarded to agent code. The following configuration tells AgentCore Runtime to forward only the X-Id-Token header to agent code, dropping other non-standard headers: request_header_config = { 'requestHeaderAllowlist': ['X-Id-Token'] } How it works: The user navigates the web application. The user authenticates with Amazon Cognito using USER_PASSWORD_AUTH . The JWT is issued with a custom department claim and the https://aws.amazon.com/tags claim for STS session tagging (covered in the preceding Initial user authentication with IdP section). Amazon Cognito returns the enriched tokens to the frontend. The access token carries the department claim for inbound authorization. The ID token carries both the department claim and the https://aws.amazon.com/tags claim for downstream STS calls. The user asks the agent a question (for example, “Show Q4 sales pipeline”). The frontend calls AgentCore Runtime, passing two tokens: the Amazon Cognito access token in the Authorization header (for inbound authorization), and the user’s ID token as a custom X-Id-Token header (for downstream STS calls). AgentCore Runtime validates the JWT and verifies the department claim matches the allowed values configured in the inbound authorizer. If validation fails, the request is rejected with HTTP 401 before agent code executes. After validation, AgentCore forwards the request to the agent container along with the allowed X-Id-Token header. The agent calls sts:AssumeRoleWithWebIdentity with the ID token. This call targets a single shared UserScopedDynamoDBRole . The following is the agent code for this step: def _scoped_dynamodb_resource(id_token: str): """Assume user-scoped role and return DynamoDB resource.""" sts = boto3.client('sts') response = sts.assume_role_with_web_identity( RoleArn=USER_SCOPED_DYNAMODB_ROLE_ARN, RoleSessionName="agent-user-session", WebIdentityToken=id_token, DurationSeconds=900 ) creds = response['Credentials'] session = boto3.Session( aws_access_key_id=creds['AccessKeyId'], aws_secret_access_key=creds['SecretAccessKey'], aws_session_token=creds['SessionToken'] ) return session.resource('dynamodb') AWS STS validates the token against the Amazon Cognito OIDC provider registered in IAM. STS verifies the token’s cryptographic signature, expiration, issuer, and audience ( aud ). The aud claim in the ID token must match one of the client IDs configured on the IAM OIDC provider resource. This prevents a valid token issued by the same Cognito user pool but for a different app client from being accepted. Note that the agent’s own execution role has no DynamoDB access and only permits sts:AssumeRoleWithWebIdentity , so even a compromised agent can’t bypass this flow. Note: Amazon Cognito user pools expose a standard OpenID Connect discovery endpoint, which is what you register as the trusted OIDC provider in IAM, even though the user signs in through the Cognito authentication APIs. When STS validates the token, it checks that the aud claim matches the client ID configured in the IAM OIDC provider. Tokens whose audience doesn’t match are rejected, adding a second control alongside signature and issuer validation. AWS STS extracts the https://aws.amazon.com/tags claim and creates a session with aws:PrincipalTag/department set. The trust policy’s sts:TagSession permission (configured in the prerequisites) enables this. Without it, STS silently drops the session tags and subsequent access is denied. AWS STS returns temporary credentials. These credentials are user-scoped and tamper-proof because the session tags are derived from the cryptographically signed JWT, not from agent code. The agent queries DynamoDB using these credentials. IAM evaluates the dynamodb:LeadingKeys condition against ${aws:PrincipalTag/department} . Only the user’s department partition is accessible. Because IAM evaluates this condition at the policy level, even if agent code is manipulated using prompt injection, cross-department access is denied. The following is an example of the permission policy on the role: { "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": ["dynamodb:GetItem", "dynamodb:Query"], "Resource": "arn:aws:dynamodb:us-east-1:111122223333:table/CustomerRecords", "Condition": { "ForAllValues:StringEquals": { "dynamodb:LeadingKeys": ["${aws:PrincipalTag/department}"] } } }] } DynamoDB returns only the records from the user’s authorized department partition. Cross-department data is never returned because the IAM policy blocks the API call itself. It doesn’t rely on post-query filtering. The agent receives the authorized results and passes them to the LLM for natural language response composition. The composed response is returned to the frontend application and displayed to the user. Pattern 2: User-scoped authorization to Amazon Bedrock Knowledge Bases For documents stored in Amazon Bedrock Knowledge Bases, the agent applies metadata filtering at query time. Each document is tagged with a Department metadata attribute during ingestion. Amazon Bedrock Knowledge Bases using metadata filtering to implement the data authorization. You need to provide metadata files alongside the source data files with the same name as the source data file and .metadata.json suffix while uploading data in Amazon S3. Amazon Bedrock Knowledge Bases ingests these documents along with corresponding metadata file. The metadata attributes are stored alongside the vectors as filterable fields in the index. Each metadata file contains a simple JSON structure with the department attribute. The following example shows the complete content of a metadata file for Sales department documents: {"metadataAttributes": {"Department": “Sales"}} When the agent queries Amazon Bedrock Knowledge Bases, it calls the bedrock:Retrieve action and appends the retrievalConfiguration filter scoped to the user’s department. The department value is extracted from the JWT access token that the agent received during inbound authorization. response = client.retrieve( knowledgeBaseId=KNOWLEDGE_BASE_ID, retrievalQuery={"text": user_query}, retrievalConfiguration={ "vectorSearchConfiguration": { "filter": {"equals": {"key": "Department", "value": department}} } } ) Note: Metadata filtering is application-layer enforcement. The bedrock:Retrieve API doesn’t expose metadata filter content as an IAM condition key. For stricter isolation, consider separate knowledge bases per department with IAM resource-level policies. Pattern 3: User-scoped access to external services using on-behalf-of token exchange We use Salesforce as an example of an external service integration. The same on-behalf-of (OBO) token exchange pattern applies to external service that supports RFC 8693 or a compatible token exchange mechanism. External services like Salesforce don’t support IAM-based access control, so you need a different mechanism to propagate user identity. The AgentCore Identity OBO token exchange (RFC 8693) provides this by exchanging the user’s authenticated identity for a user-scoped token that the external service will recognize and enforce natively. AgentCore Identity supports three OAuth patterns for external service access. With client credentials—Two-Legged OAuth (2LO) or machine-to-machine (M2M)—the agent authenticates as a service account and receives a token with broad access. The agent is then responsible for filtering data in queries, which makes this pattern suitable when accessing organization-wide data that isn’t scoped to an individual user. A variation of this pattern embeds user context as custom claims within the agent’s M2M token itself, see Empower AI agents with user context using Amazon Cognito . With Authorization Code (3LO), the user explicitly consents through a browser redirect and the external service enforces per-user access. This works when per-service consent is required, but it demands user interaction during the flow, making it impractical for background agent operations. Learn more about this in Secure AI agents with Amazon Bedrock AgentCore Identity on Amazon ECS . With OBO token exchange, the user’s already-authenticated identity is exchanged for a service-scoped token without any additional user interaction, and the external service enforces access. For this use case, OBO is the most appropriate pattern. The user has already authenticated at the entry point (through the IdP), and the agent needs to act on their behalf across multiple services without prompting for additional consent. OBO propagates user identity end-to-end without the agent holding credentials, scales automatically with no per-user token storage, and allows downstream services to enforce their own authorization (sharing rules, role-based access control (RBAC)). Because no browser redirect is needed, OBO works seamlessly for background tool calls where the user isn’t present in a browser session. Figure 4 demonstrates the complete flow when using OBO token exchange. Figure 4: End-to-end user authorization flow for external access How it works: The user navigates to the web application. The user authenticates with Amazon Cognito using USER_PASSWORD_AUTH . A pre token generation Lambda function injects the custom department claim into the token (covered in the preceding Initial user authentication with IdP section). Amazon Cognito returns the tokens to the frontend. The access token is issued with the department claim. The user asks the agent a question (for example, “Show me Sales opportunities”). The frontend calls AgentCore Runtime with a single agent Amazon Resource Name (ARN), passing the Amazon Cognito access token: POST /invocations, Authorization: Bearer {access_token} . AgentCore Runtime validates the inbound JWT (signature, expiration, issuer, and custom claims including the department claim). After successful validation, AgentCore Runtime extracts the user identity from the JWT and calls the GetWorkloadAccessTokenForJWT API to exchange it for a workload access token . The agent code receives the workload access token through the invocation payload header. Workload access tokens are exclusively for accessing Amazon Bedrock AgentCore services and can’t be used directly for external services. The agent calls AgentCore Identity ( GetResourceOauth2Token ) with the workload access token, requesting a Salesforce token through the configured OBO (on-behalf-of) credential provider. AgentCore Identity validates the caller identity and agent identity, then accesses the stored client credentials from Secrets Manager. If a previously stored OAuth access token has expired, AgentCore Identity automatically obtains a new one using the client credentials, reducing the need for manual token lifecycle management in agent code. The agent code uses the @requires_access_token decorator to invoke this flow: @requires_access_token( provider_name="salesforce-token-exchange", scopes=[], auth_flow="ON_BEHALF_OF_TOKEN_EXCHANGE", ) def _get_salesforce_token_sync(*, access_token: str) -> str: return access_token On the AWS side, this requires an AgentCore Identity OAuth Client configured with Grant type: Token Exchange , Actor token: None , pointing to the Salesforce token endpoint. The Salesforce Connected App consumer secret is stored in Secrets Manager (the agent doesn’t access it directly). AgentCore Identity performs RFC 8693 token exchange with the Salesforce token endpoint, sending the user identity as the subject_token . AgentCore Identity performs this secure token exchange for user-delegated access based on the configured OAuth 2.0 credential provider. The agent can’t request tokens for arbitrary users because the workload access token cryptographically binds the request to the authenticated user. Salesforce validates the token against the registered Amazon Cognito auth provider configured in Salesforce Setup. Salesforce resolves the user using FederationIdentifier . On the Salesforce side, this requires: Amazon Cognito registered as an OpenID Connect auth provider A token exchange handler (Apex class extending Auth.Oauth2TokenExchangeHandler ) that resolves users by FederationIdentifier Token exchange flow enabled on the connect app or external client app Each user’s FederationIdentifier set to their Amazon Cognito subject’s ( sub ) unique user identifier (UUID). Sharing rules configured to enforce department-scoped record access The federation ID ( sub ) is immutable and can’t be spoofed by the agent, because it originates from the cryptographically signed identity token. Salesforce returns a user-scoped access token to AgentCore Identity, which passes it back to the agent. Agent calls the Salesforce REST API using the user-scoped token. No department filtering is needed in the Salesforce Object Query Language (SOQL) query because Salesforce enforces access through sharing rules: @tool def query_salesforce_opportunities(query_text: str) -> str: access_token = _get_salesforce_token_sync() # No department filter needed. Salesforce sharing rules enforce access. soql = "SELECT Id, Name, Amount, StageName, CloseDate FROM Opportunity ORDER BY CloseDate DESC LIMIT 10" response = requests.get( f"{SALESFORCE_URL}/services/data/v59.0/query?q={urllib.parse.quote(soql)}", headers={"Authorization": f"Bearer {access_token}"}, timeout=30, ) return json.dumps(response.json().get("records", [])) Salesforce applies sharing rules and returns only records the user is authorized to access. The agent doesn’t hold Salesforce credentials (refresh tokens, client secrets), these remain with AgentCore Identity. The agent’s LLM composes a response from the returned records. The frontend displays the results to the user. Conclusion In this post, you learned how to enforce consistent, end-to-end authorization in agentic AI applications by propagating user context from Amazon Cognito through Amazon Bedrock AgentCore to downstream resources. We showed you three patterns: Per-request user-scoped credentials using AssumeRoleWithWebIdentity with session tags, evaluated by IAM attribute-based access control (ABAC) policies to access Amazon DynamoDB Department-scoped metadata filtering at the application layer to access Amazon Bedrock Knowledge Bases. On-behalf-of token exchange (RFC 8693) using AgentCore Identity, with Salesforce-native sharing rules governing access to external CRM data. The key takeaway is that the agent coordinates work but doesn’t decide who can access what. Access decisions are made by infrastructure-level controls and the downstream service’s authorization model. This layered approach means that even if the agent behaves unexpectedly, unauthorized data access is still blocked. You can use this as a reference implementation and adapt it to your requirements by choosing authorization attributes relevant to your organization (such as department, role, business unit, or region), integrating additional data sources, or extending the token exchange patterns to other external services. Next steps Explore the sample code sample-authorization-context-with-agentcore for the complete reference implementation For a deeper overview of workload identities and credential management, see Securing AI agents with Amazon Bedrock AgentCore Identity For the Authorization Code (3LO) pattern on self-hosted compute, see Secure AI agents with Amazon Bedrock AgentCore Identity on Amazon ECS For M2M token customization with embedded user context, see Empower AI agents with user context using Amazon Cognito For IAM scoping patterns in Model Context Protocol (MCP)-based agent architectures, see Secure AI agent access patterns to AWS resources using MCP . For agent identity and permission management best practices, see AGENTSEC03 in the AWS Well-Architected Agentic AI Lens If you have feedback about this post, submit comments in the Comments section below. Anshu Bathla Anshu is a Sr. Lead Consultant – Security at AWS, based in Gurugram, India. He works with customers across diverse verticals to help strengthen their security infrastructure and achieve their security goals. Outside of work, Anshu enjoys reading books and gardening at his home garden. Connect with him on LinkedIn . Prafful Gupta Prafful is a DevOps Engineer at AWS, based in Gurugram, India. Having started his professional journey with Amazon, he specializes in DevOps and generative AI solutions, helping customers navigate their cloud transformation journeys. Beyond work, he enjoys networking with fellow professionals and spending quality time with family. Connect with him on LinkedIn . Rohit Verma Rohit is a Delivery Consultant – Security, Risk and Compliance at AWS, based in Gurugram, India. He partners with customers across multiple industries to strengthen their security posture, leading risk consulting engagements, and security deliverable reviews. Outside of work, Rohit is a fitness enthusiast who enjoys music and reading non-fiction books. Connect with him on LinkedIn .
aws.amazon.comAug 19, 2026extracted
USN-8557-1: Authlib vulnerabilities
Details Jay Neiva and Mauro Carrillo discovered that Authlib did not properly validate cryptographic keys embedded in JWT headers. An attacker could possibly use this issue to forge trusted tokens, resulting in authentication and authorization bypass. (CVE-2026-27962) Jay Neiva and Mauro Carrillo discovered that Authlib incorrectly handled RSA1_5 encrypted tokens. An attacker could possibly use this issue to recover sensitive encrypted information, resulting in information disclosure. (CVE-2026-28490) Jay Neiva and Mauro Carrillo discovered that Authlib did not properly reject unsupported cryptographic algorithms when validating OpenID Connect ID tokens. An attacker could possibly use this issue to bypass token integrity checks, resulting in authentication bypass. (CVE-2026-28498) Johnny Deuss discovered that... Jay Neiva and Mauro Carrillo discovered that Authlib did not properly validate cryptographic keys embedded in JWT headers. An attacker could possibly use this issue to forge trusted tokens, resulting in authentication and authorization bypass. (CVE-2026-27962) Jay Neiva and Mauro Carrillo discovered that Authlib incorrectly handled RSA1_5 encrypted tokens. An attacker could possibly use this issue to recover sensitive encrypted information, resulting in information disclosure. (CVE-2026-28490) Jay Neiva and Mauro Carrillo discovered that Authlib did not properly reject unsupported cryptographic algorithms when validating OpenID Connect ID tokens. An attacker could possibly use this issue to bypass token integrity checks, resulting in authentication bypass. (CVE-2026-28498) Johnny Deuss discovered that Authlib did not provide cross-site request forgery protection for the OAuth cache feature in its Starlette integration. An attacker could possibly use this issue to perform unauthorized OAuth actions, resulting in cross-site request forgery. This issue only affected Ubuntu 24.04 LTS and Ubuntu 26.04 LTS. (CVE-2026-41425) The problem can be corrected by updating your system to the following package versions: Reduce your security exposure Ubuntu Pro provides ten-year security coverage to 25,000+ packages in Main and Universe repositories, and it is free for up to five machines.
ubuntu.comJul 16, 2026extracted
Attackers Exploit SimpleHelp CVE-2026-48558 to Deploy TaskWeaver and Djinn Stealer
An unknown threat actor has been observed exploiting a recently disclosed maximum-severity security flaw in SimpleHelp to deliver two previously unreported malware families, TaskWeaver and Djinn Stealer. The intrusion involves the exploitation of CVE-2026-48558 (CVSS score: 10.0), a critical authentication bypass vulnerability impacting the OpenID Connect (OIDC) flow that an unauthenticated attacker could exploit to obtain a fully authenticated "Technician session by submitting a forged token containing arbitrary identity claims. "TaskWeaver is a heavily obfuscated Node.js loader, delivered as jquery.js and executed through node.exe, that implements an encrypted, reusable payload delivery channel rather than a fixed set of post exploitation commands," Blackpoint Cyber said in an analysis. "The observed second stage payload, Djinn Stealer, targets Windows, macOS, and Linux systems." Djinn Stealer is designed to harvest credentials associated with cloud platforms, source control, package registries, infrastructure tooling, AI development assistants, browsers, SSH, and cryptocurrency wallets. Details of CVE-2026-48558 emerged earlier this month when Horizon3.ai, which discovered the flaw, said it affects servers configured to use either generic OIDC or Azure AD OIDC and that it stems from the manner in which SimpleHelp validates the IdP assertions. "In many SimpleHelp deployments that have OIDC-type authentication enabled, an unauthenticated attacker can create and authenticate as a new 'Technician' user," Horizon3.ai security researcher Zach Hanley said. "This Technician, by default, can perform privileged management activities such as remoting into managed endpoints, executing scripts, and more." "Even when the SimpleHelp server is configured to enforce MFA for technicians, this issue allows the attacker to bypass this mechanism because on first login, technicians can self-register their own MFA method." In the attack chain documented by Blackpoint Cyber, successful exploitation of the flaw in the Remote Monitoring and Management (RMM) software is said to have enabled the threat actor to obtain an authenticated "Technician" session on a publicly-accessible server, which was then abused to deploy TaskWeaver and Djinn Stealer. "The compromised RMM platform provided the operator with a trusted administrative channel capable of transferring files and executing commands on systems managed through the server," researchers Nevan Beal and Sam Decker said. TaskWeaver is a modular Node.js loader capable of fingerprinting the system, establishing encrypted communications with a remote server ("a.dev-tunnels[.]com"), and retrieving and executing additional JavaScript payloads with elevated access to the Node.js runtime. The final stage is an information stealer engineered to siphon valuable data from compromised Windows, macOS, or Linux hosts. The breadth of the information targeted by the stealer is as follows - Credentials, history, and bookmarks stored in web browsers Configuration and authentication data associated with AWS, Azure, Google Cloud, Oracle Cloud Infrastructure, Okta, Cloudflare, DigitalOcean, Linode, Heroku, Vercel, Railway, Supabase, Pulumi, Terraform, HashiCorp Vault, and Consul GitHub CLI data Git configuration SSH keys Docker authentication Helm registry information S3 and MinIO client configurations Subversion credentials Credentials for npm, pnpm, Yarn, NuGet, Cargo, Composer, Maven, Gradle, pip, PyPI, Conda, Bun, Ivy, and Scala Build Tool Configuration, authentication, session, and project data associated with Anthropic Claude, Google Gemini, OpenAI Codex, Cline, OpenCode, and Kilo Cryptocurrency wallets and keystores associated with Bitcoin, Litecoin, Dogecoin, Dash, Ethereum, Monero, Zcash, Exodus, Atomic Wallet, and Electrum On Linux systems, the malware also attempts to read the "/proc/ /cmdline" and "/proc/ /environ" virtual files that may contain information about a running process, such as passwords, API keys, access tokens, database connection strings, and other sensitive values passed through command line arguments or environment variables. Once the information is collected, it's packed into a TAR archive, compressed with GZIP, encrypted using an AES-256-GCM key protected by an RSA-2048 public key embedded in TaskWeaver, and exfiltrated to attacker-controlled infrastructure ("96.126.130[.]126:58942"). The campaign illustrates how threat actors are increasingly going after artificial intelligence (AI)-powered platforms as the technology gets embedded across enterprise workflows, enabling them to abuse the AI assistants' privileges to access sensitive data. "A single authentication bypass became a pathway into everything the managed systems could reach, from cloud platforms and code repositories to AI tools, cryptocurrency wallets, and customer infrastructure," the researchers said. "Credentials accessible from a developer or administrator workstation may provide entry into production infrastructure, build pipelines, source code repositories, deployment platforms, cloud tenants, and customer environments long after the original endpoint has been contained." The active exploitation of CVE-2026-48558 has prompted the U.S. Cybersecurity and Infrastructure Security Agency (CISA) to add it to the Known Exploited Vulnerabilities (KEV) catalog, requiring Federal Civilian Executive Branch (FCEB) agencies to apply the fixes by July 2, 2026.
thehackernews.comJun 30, 2026extracted
Critical SimpleHelp flaw exploited to deploy new stealer malware
Hackers are exploiting a recently disclosed critical vulnerability (CVE-2026-48558) in SimpleHelp to deploy Djinn Stealer, a previously undocumented cross-platform information stealer targeting Windows, macOS, and Linux. The SimpleHelp platform is primarily used by managed service providers (MSPs), IT departments, helpdesks, and system administrators for remote monitoring and management (RMM). Earlier this month, offensive security company Horizon3.ai published details about CVE-2026-48558, saying that the flaw could be leveraged to create highly privileged technician accounts without authentication. Exploiting the vulnerability is possible on servers using the OpenID Connect (OIDC) authentication protocol. According to the researchers, around 1,000 SimpleHelp servers exposed online were running a vulnerable configuration at the time of the disclosure. In an incident investigated by managed detection and response (MDR) provider Blackpoint, a threat actor exploited the critical authentication bypass vulnerability to establish an authenticated technician session on an internet-facing SimpleHelp server before deploying the TaskWeaver malware loader and the Djinn Stealer. Based on the findings from the Adversary Pursuit Group (APG), the company's threat intelligence and research team, both pieces of malware are new and have not been documented before. "The compromised RMM platform provided the operator with a trusted administrative channel capable of transferring files and executing commands on systems managed through the server," Blackpoint says. The investigation revealed that TaskWeaver was downloaded in the form of an obfuscated JavaScript file named ‘jquery.js’ from a temporary Cloudflare domain. TaskWeaver is a generic malware loader that fingerprints the compromised device and communicates with the command-and-control (C2) infrastructure to receive new JavaScript modules for execution. The loader then installs Djinn Stealer to collect in a single pass all the sensitive data it can find on a developer's machine, be it Windows, macOS, or Linux. Blackpoint mentions that Djinn Stealer has a particular focus on AI development tools, but targets a broad collection of developer and infrastructure credentials: Cloud provider credentials, identity services, deployment platforms, and cloud management tools. Git configuration, GitHub CLI, SSH keys, Docker credentials, Helm, infrastructure-as-code tools (Terraform, Pulumi), secrets management solutions (HashiCorp Vault), and package manager credentials. Authentication data for package registries and build tools (npm, Yarn, pnpm, Cargo, Maven, Gradle, pip, NuGet), potentially enabling access to private packages or malicious package publication. Local configuration files, authentication tokens, session data, and Model Context Protocol (MCP) configuration for AI coding assistants (Claude, Gemini, Codex, Cline, OpenCode, and Kilo). Cryptocurrency wallets and keystores associated with multiple desktop cryptocurrency clients (Bitcoin, Litecoin, Dogecoin, Dash, Ethereum, Monero, Zcash, Exodus, Atomic Wallet, and Electrum). Browser data, shell history, SSH configuration, PGP keys, database client configuration, operating system information, and other user files. On Linux, the malware also attempts to read the /proc/ /cmdline and /proc/ /environ virtual files that contain information about a running process, including secrets (e.g., API keys, credentials, session tokens, file paths, URLs). Blackpoint researchers warn that stealing credentials for AI development tooling, which is widely used for coding and software development, could allow attackers to inherit the AI assistant's authorized access to repositories, cloud resources, databases, and APIs. “Many of these tools rely on the Model Context Protocol (MCP) to connect an AI assistant to external tools and data on the developer's behalf, including source repositories, databases, cloud accounts, and internal APIs,” explain the researchers. “The settings and tokens for those connections are stored locally in files such as ~/.claude/mcp.json. Stealing them can grant an attacker the same downstream access the developer extended to their AI agent, reaching well beyond the AI service itself.” Before exfiltrating the sensitive data to the C2 server, Djinn Stealer packs it into a TAR archive, then compresses it with GZIP, and encrypts it with an AES-256-GCM key protected by an RSA-2048 public key embedded in TaskWeaver. Active exploitation of CVE-2026-48558 should serve as an urgent call for system administrators to prioritize updating SimpleHelp instances to the latest versions. It is also recommended to invalidate technician sessions that they don’t recognize. If breached, rotate all credentials and API keys. Blackpoint's report provides indicators of compromise (IoCs) observed in the investigated intrusion, which include hashes for the TaskWeaver loader and Djinn Stealer, network infrastructure, host and behavioral indicators. Overall prevention scores can hide what happens after initial access. Once attackers are using valid credentials, prevention drops sharply. The Blue Report 2026 measures defenses technique by technique across 338 million simulations run in customer production environments. Get the report
bleepingcomputer.comJun 29, 2026extracted
Google、個人・Workspaceアカウントのログインに新セッションメタデータを導入 認証強度の判別が容易に
Google�́ASign in with Google�ɔF�؎����ƔF�؎�@������OIDC�N���[����lj������B�F�̐V�����⋭�x��c�����₷���Ȃ�A�A�v���^�c�҂͕s�����p��⌠������̐��x�����}���B ���̋L������������ł��B����o�^����ƑS�Ă������������܂��B �@Google��2026�N6��16���i���n���ԁj�A�uSign in with Google�v�ɐV���ȃZ�b�V�������^�f�[�^��lj�����Ɣ��\�����B�F�؎�����F�؎�@�Ɋւ������OpenID Connect�iOIDC�j�̕W���N���[���Ƃ��Ē��A�A�v���^�c�҂����p�҂̔F�؏��ڂ����c���ł���悤�ɂ���B�t�B�b�V���O��s�����p�̑��������{��ŁA�F�؊�Ղ��瓾����������p���A�ɉ������A�N�Z�X�����s����̋������㉟������_��������B �@�V�@�\�͔F�؍ς݃A�v���ŗ��p�\�ƂȂ�B�o�b�N�G���h�����ID�g�[�N���ɕW���N���[�����lj�����A�l�p��Gmail�A�J�E���g���p�҂����łȂ��A�uGoogle Workspace�v�Ǘ����̃A�J�E���g���p�҂ɂ��K�p�����B �@Google�́ASign in with Google�̗��p�ɂ���ĊJ���҂�Google�̔F�؊�Ղ����p�ł���_�����������BGoogle���ŗ��p�҃Z�b�V�����̔F����S���m�F��S���A���̌��ʓ���ꂽ�����A�v�����֒���B �@�lj������N���[���́uauth_time�v�Ɓuamr�v��2��ށBauth_time�́A���p�҂�Google�A�J�E���g�֔F���A�Z�b�V�������������߂̎���������OIDC�W���̃^�C���X�^���v���B�A�v����Web�T�C�g��ID�g�[�N����A�N�Z�X�g�[�N�������s���ꂽ�����Ƃ͈قȂ�B �@���̏��ŁAGoogle���̃Z�b�V�������ǂ̒��x�V������Ԃ���c���ł���B���p�Җ{�l�̑��݂��m�F���鍪���Ƃ��Ċ��p���₷���Ȃ�A��莞�Ԍo�ߌ�ɍĔF�����߂�d�g�݂Ȃǂ։��p�ł���B �@amr��Authentication Methods Reference�̗��ŁA�F�؎��ɗ��p������@������������z�B���p�\�Ȓl�ɂ́A�p�X���[�h�F�������upwd�v�A���v�f�F�������umfa�v�A�n�[�h�E�F�A�ی삳�ꂽ���������uhwk�v�A�\�t�g�E�F�A�ی삳�ꂽ���������uswk�v�A�d�b�F�������utel�v�ASMS�F�������usms�v���܂܂��B �@���̏��ɂ���āA�F�̋��x��c�����₷���Ȃ�B�Ǘ��Ҍ����@�\�ւ̃A�N�Z�X���ɑ��v�f�F�ؗ��p�҂̂�����A�������̓Z�L�����e�B�L�[���p�҂����ɓ��葀���F�߂�Ƃ��������䂪�\�ƂȂ�B �@Google�͔F�̗���ɂ�����2��ނ̃Z�b�V���������݂���Ɛ��������B1�͗��p�҂�Google�Ԃ̃Z�b�V�����ł���AGoogle���Ǘ�����B������͗��p�҂ƃA�v���Ԃ̃Z�b�V�����ŁA�A�v�������Ǘ�����B�V�N���[����Google���Z�b�V�����Ɋւ��������A�A�v���^�c�҂̔��f�ޗ��ƂȂ�B �@�V�N���[����Android��iOS�AWeb�̃N���C�A���g����уT�[�o�A�v���P�[�V�����ŗ��p�ł���B �@Google�ɂ��ƁA�Œ�I�ȔF�|���V�[�����ł͌��݂̋��Њ��ւ̑Ή�������Ȃ��Ă���Ƃ����B�F�؏��ׂ����c���ł���A�A�J�E���g�������s���A�J�E���g���p�Ȃǂ̌��m���x����ɂȂ���B���S���������F�ؒ���̃Z�b�V�����ł͋@�����̍�������������₷���Ȃ�Ƃ��Ă���B �@���p��Ƃ��ẮA�F�؎�@���č����O�L�^����d�g�݁A�Z�b�V�����o�ߎ��Ԃɉ����Ēlj��F��v������d�g�݁A�F�؎�@����������֔��f����d�g�݂Ȃǂ��������B �@����OpenID Connect�𗘗p����Sign in with Google���ς݂̏ꍇ�A�F�t���[�̑傫�ȕύX�͕s�v�Ƃ����B�F���N�G�X�g����OIDC�W����claims�p�����[�^�[���g���ĐV�N���[����v�����邱�Ƃŗ��p�ł���B Copyright © ITmedia, Inc. All Rights Reserved.
itmedia.co.jpJun 17, 2026extracted
SimpleHelp RMM flaw could give attackers full access to managed endpoints (CVE-2026-48558)
SimpleHelp RMM flaw could give attackers full access to managed endpoints (CVE-2026-48558) A critical vulnerability (CVE-2026-48558) in SimpleHelp, a popular remote monitoring and management (RMM) tool, can be exploited remotely by unauthenticated attackers to create a new “Technician” account and use it to remote into managed endpoints, execute scripts, and more. Maliciously “forged” Technician account (Source: Horizon3.ai) The vulnerability CVE-2026-48558 is an authentication bypass flaw affecting SimpleHelp deployments configured to use OpenID Connect (OIDC) authentication. “Even when the SimpleHelp server is configured to enforce MFA for technicians, this issue allows the attacker to bypass this mechanism because on first login, technicians can self-register their own MFA method,” Horizon3.ai researchers noted. Fixes for the vulnerability have been included in SimpleHelp v5.5.16 (stable) and (pre-release) v6.0 RC 2, pushed out in late May 2026. The vendor said at the time that they were not aware of malicious exploitation of this vulnerability, and urged customers to download and install the appropriate update. CVE-2026-48558 was discovered by Horizon3.ai researchers with the help of an autonomous vulnerability-hunting AI system, and publicly disclosed last Friday. Potential for exploitation Horizon3.ai noted that there are several prerequisites for successful exploitation, namely: At least one OIDC authentication provider is configured on the SimpleHelp server A TechnicianGroup is associated with the OIDC provider The “Allow group authenticated logins” setting is enabled on the TechnicianGroup. The second of those is expected to be present in any deployment using OIDC authentication, they added, and they found that the latter had been enabled by the clients they assessed. SimpleHelp noted that an attacker must be able to connect to a server to exploit the vulnerability. “Servers accessible only from local networks or recognised and trusted IP ranges are at much lower risk of exploitation,” they pointed out. Also, “to log in as a Technician the attacker must be connecting from an IP address permitted by Technician login IP restrictions.” Horizon3.ai researchers say that the number of SimpleHelp servers exposed on the internet currently reaches nearly 14,000. “A random sampling of these servers indicated that roughly 7.2% of them were configured to use the vulnerable OIDC authentication method,” they added. Why this matters SimpleHelp is often used by organizations’ IT help desk and is popular with managed services providers (MSPs). The three SimpleHelp server vulnerabilities Horizon3.ai reported and disclosed in January 2025 have since been exploited by ransomware attackers. While the researchers refrained from publishing technical details about CVE-2026-48558, savvy attackers may have enough information to know what to look for and create a working exploit. SimpleHelp advises admins and security teams to look for evidence of unexpected Technician account creation, logins, sessions, tool runs, especially from unrecognized IP addresses. Evidence of those may be found in the server logs and the Administration settings (under Technicians). Customers who run an affected SimpleHelp version but cannot immediately upgrade to a fixed version should disconnect their SimpleHelp server from the network (if possible) and make it inaccessible from the internet until they can perform the upgrade. Subscribe to our breaking news e-mail alert to never miss out on the latest breaches, vulnerabilities and cybersecurity threats. Subscribe here!
helpnetsecurity.comJun 16, 2026extracted
SimpleHelp bug lets hackers create rogue remote support accounts
A vulnerability in the SimpleHelp remote management software allows unauthenticated attackers to create privileged technician accounts on servers using the OpenID Connect (OIDC) authentication protocol. The flaw is tracked as CVE-2026-48558 and received a critical severity rating. It impacts SimpleHelp versions 5.5.15 and older, as well as 6.0 pre-release versions. Researchers at offensive security company Horizon3.ai explain that the issue is caused by how identity assertions received from an OIDC identity provider (IdP) are validated. When OIDC authentication is enabled, an unauthenticated attacker can create and log in as a new Technician user without needing to go through the multi-factor authentication (MFA) process. "This Technician, by default, can perform privileged management activities such as remoting into managed endpoints, executing scripts, and more," Horizon3.ai researcher Zach Hanley explains. SimpleHelp fixed the vulnerability on June 9 by releasing versions 5.5.16 and 6.0RC2 of the product. Impact scope CVE-2026-48558 does not impact every SimpleHelp server running a vulnerable version; rather, it affects a subset that relies on the OIDC protocol, whether the generic one or Azure AD OIDC, both of them common in large enterprises. As the researchers explain, there are several prerequisites for the exploit to work: OIDC authentication must be enabled at least one Technician Group must be associated with the OIDC provider the group must have “Allow group authenticated logins” enabled. Results from Shodan show about 14,000 SimpleHelp servers exposed to the public internet. Analysis of a random sample suggests that roughly 7.2% are configured to use OIDC authentication. Additionally, Horizon3.ai found that the “Allow group authenticated logins” is enabled in many cases. Organizations can defend against attacks leveraging the CVE-2026-48558 vulnerability by updating to the latest SimpleHelp releases that address the issue. If updating is impossible, one mitigation is to restrict technician login sources using IP-based allowlists. The researchers also shared indicators of compromise that can help detect active exploitation, such as new authenticated technician users with unknown or suspicious names and/or email addresses. Additionally, the logs in ‘/opt/SimpleHelp/logs/server.log’ and ‘/opt/SimpleHelp/logs/ /server.log’ may contain technician registrations, email addresses, and configuration changes performed by rogue accounts. Neither SimpleHelp nor Horizon3.ai has reported evidence of active exploitation. However, given the product's history of attracting significant threat actor interest, organizations are advised to apply the available fixes or mitigations without delay. Overall prevention scores can hide what happens after initial access. Once attackers are using valid credentials, prevention drops sharply. The Blue Report 2026 measures defenses technique by technique across 338 million simulations run in customer production environments. Get the report
bleepingcomputer.comJun 15, 2026extracted
OpenAI Unveils ChatGPT Account Security Controls
ChatGPT users have gained two new security controls: one aimed at preventing data theft through prompt injection and another at tracking account sign-ins. According to OpenAI, the first of these, Lockdown Mode, is an optional setting that limits how far ChatGPT can reach into the web and external services. First offered to enterprise plans in February, it began reaching personal and self-serve business accounts in early June. The risk it addresses is not hypothetical. Researchers have repeatedly shown how a single hidden instruction can pull data from a linked inbox or leak a user's conversations. Blocking the Exfiltration Channel Rather than catching the malicious prompt, Lockdown Mode targets the last step, choking off the outbound network requests an attacker would use to ship stolen data out. The injected text still reaches the model unimpeded, hidden in a web page or file. Cybersecurity expert and renowned open-source developer Simon Willison, who popularized the term prompt injection, welcomed the change. "This looks really good to me," he wrote in his blog over the weekend. Willison has long held that the most practical defense against prompt injection is to sever an attacker's route for exfiltrating data, which is what the setting does using deterministic controls a manipulated model cannot override. However, the feature's existence, he added, also implies default ChatGPT cannot fully block a determined attempt at data exfiltration. That protection has a price: live connector access and write actions switch off, sidelining features such as the Finances tool and shopping agents, and it cannot run alongside Developer Mode. OpenAI pitched it at users and organizations that handle sensitive data, not the general public. Reviewing Signed-In Devices The second control, Active Sessions, brings session management to ChatGPT's security settings, letting users audit where their account is logged in. Each entry can show: Device or browser details Approximate location and sign-in time Which first-party app was used, such as ChatGPT or Codex Whether it is a trusted device or the current session Users can end a single session or sign out everywhere at once, though a full sweep can take up to 30 minutes. If something looks unfamiliar, OpenAI advises changing the password, reviewing sign-in methods and contacting support. One gap will matter to larger organizations: the feature is unavailable on accounts that use single sign-on (SSO), including SAML and OpenID Connect and it does not track third-party app sessions or Codex CLI logins.
infosecurity-magazine.comJun 8, 2026extracted
Customize federated sign-in with new Amazon Cognito Lambda trigger
Customize federated sign-in with new Amazon Cognito Lambda trigger You can use Amazon Cognito user pools to add sign-up and sign-in functionality to your web and mobile applications. You can authenticate users directly with Amazon Cognito managed accounts using passwords, passwordless flows, or custom authentication flows, or let users federate in through external identity providers (IdP) using SAML, OpenID Connect, or social providers such as Google, Facebook, Sign in with Apple, or Login with Amazon. For consumers, identity federation means fewer passwords to remember and a smoother sign-in experience. For business-to-business (B2B) software as a service (SaaS) providers, it means your tenants’ organizations keep control of their own identities rather than managing credentials on their behalf. But federation can also introduce challenges for enterprises and application developers. What happens when your enterprise customer’s SAML provider sends hundreds of group memberships that exceed attribute size limits? Or when your ecommerce customer forgets they already have an account and tries to sign in with a different social provider, creating duplicate records? In this blog post, I introduce the inbound federation Lambda trigger for Amazon Cognito, a new feature that gives you programmatic control over federated authentication flows. This AWS Lambda trigger intercepts the federated authentication response immediately after your external identity provider responds to Cognito, so you can transform, filter, and enrich user attributes before the user profile is created and user attributes are mapped in your user pool. Understanding the inbound federation Lambda trigger The inbound federation Lambda trigger is invoked after your Amazon Cognito user pool has received and verified the response from the external IdP. The request payload for the federated IdP response is then sent from Cognito to your Lambda function and you will receive the following information: The common parameters of Amazon Cognito Lambda triggers (including userPoolId andclientId) Which external IdP was used (for example, providerName ) The providerType (SAML, OIDC, Login with Amazon, and so on) Attribute data from the external IdP specific to the user signing in The specific format of this attribute data depends on the provider type, view the Inbound federation Lambda trigger parameters section in the docs to learn more. If the external IdP is a SAML provider, you will receive a JSON key-pair listing of the user’s attributes from the IdP assertion. If the external IdP is an OIDC provider (or social provider), you will receive the access token and attribute data from the /userinfo endpoint, along with an ID token if one was provided. See Figure 1 for a detailed flow of a federated sign-in with an Amazon Cognito user pool configured to use the inbound federation Lambda trigger. The user begins using the application but is required to sign in first. The managed login is rendered, and the user can select which IdP they want to sign in with. If identifiers are used with SAML or OIDC providers, the user enters their email address and Amazon Cognito looks up the domain of their provided email and routes them to the appropriate IdP. Alternatively, the managed login can be bypassed by the client providing the identity_provider request parameter. Amazon Cognito sends the authentication request to the appropriate IdP. The external IdP challenges the user to sign in. The user completes the sign-in process required by the external identity provider. The challenge response is sent to the external IdP. The IdP verifies that the sign-in is successful. If there are any subsequent challenges, such as multi-factor authentication (MFA), additional rounds of authentication challenges and responses take place. This is determined by the configuration and settings of the external IdP. The external IdP sends a response to the Amazon Cognito user pool, and Cognito validates the cryptographic signature and that it hasn’t been tampered with. Amazon Cognito sends attribute data from the IdP to the inbound federation Lambda function Attribute data for the authenticated user and the common parameters for Amazon Cognito are available for the Lambda function to add, modify, or suppress according to your requirements. Your added, modified, or suppressed attributes are returned to Amazon Cognito. These are attribute values that map to the user’s profile in Cognito—whether the user profile was just created or is being updated for a returning user. Continuing the OAuth 2.0 authorization code grant, Amazon Cognito sends an authorization code to the client. The client then calls the /token endpoint with the authorization code. Note: It’s a security best practice to use confidential clients and to use OAuth 2.0 Proof Key for Code Exchange (PKCE) extension whenever possible. An access, ID, and refresh token is returned to the client. The user has signed into the application. ID tokens can be used to identify who the user is (authentication), and access tokens can be used to determine what the user can do (authorization). Common federation challenges and use cases Federation introduces complexity that varies depending on your use case. For B2B and SaaS applications, you’re often not in control of your customers’ IdPs, including what attributes they send or how they format them. As an example, an enterprise customer will configure their SAML response to include every group a user belongs to. This could be hundreds of groups or long group identifiers, and if the group membership of the user is mapped to an Amazon Cognito attribute, this can lead to a scenario where the Cognito attribute size limit is exceeded, causing federated sign-ins to fail. Challenges for business-to-customer (B2C) applications can differ from B2B use cases. For B2C applications, organizations shouldn’t be required to think about identity providers. The ability to sign-up and sign-in should be seamless for consumer-facing applications. Customers visiting a consumer-facing application might create an account with email and password, forget they created created it, and then later try signing in with Facebook (or other social provider). Without proper account linking in Amazon Cognito, you then have multiple user records for the same user, which could lead to fragmented purchase history and a frustrating customer experience. Both B2B and B2C use cases might need to look up external data just prior to completing the sign-in process, such as additional roles and access for B2B users or looking up active orders for B2C users. Another example could be the need to normalize data just prior to storing it in the user profile within the Amazon Cognito user pool or even discarding personally identifiable information (PII) prior to storing it in your Cognito user pool. With the inbound federation Lambda trigger, you can handle these B2B and B2C use cases programmatically, and do so without requiring modification of your applications or coordinating IdP-specific changes with external IdPs. In this section, I dive deeper into two common use cases: oversized group attributes, common with B2B customers, and automated account linking, common with B2C customers. Use case 1: Filtering oversized group attributes If you have B2B and SaaS use cases, it’s a common practice to use group membership from the IdP to determine the level of access you have within the SaaS service. This is a great way to still provide some access control back to the enterprise customers themselves. The groups can be used to represent the roles a user will have or for some form of coarse-grained authorization. However, your customers might inadvertently send a large number of groups a user is a member of, thus leading to an oversized attribute payload. Another common scenario is where the syntax and format of group name a user belongs to can arrive in various formats across different IdPs; such as a canonical name (for example, example.com/groups/myApp-readOnly), a distinguished name (common with LDAP based systems and such as cn=myApp-readOnly,OU=groups,DC=example,DC=com), or a plain text string (such as myApp-readOnly). Instead of having downstream authorization logic to accommodate different variations of a group name, you can now normalize how groups are represented prior to storing the user’s attribute data using the inbound federation Lambda trigger. To expand this, imagine your enterprise customer uses a SAML IdP, such as Active Directory Federation Services (AD FS), in front of Active Directory (AD). When their users authenticate, AD FS sends a groups attribute containing every AD group the user belongs to. For users in large organizations, this can be hundreds of groups, and the attribute is mapped to an Amazon Cognito attribute, this could result in a string that exceeds 2,048-character limit per attribute of Cognito. Authentication would fail in this scenario, ultimately leading to support tickets because enterprise customers would be unable to sign in. Even if certain users didn’t exceed this limit, because of a smaller number of group memberships, this would result in the collection and storing of unnecessary data in your Cognito user pool. Previously, you would need to work with your customer’s IT department to modify their SAML configuration to filter groups at the source—a process that could take weeks and require multiple approval cycles because it involves a change to the federation configuration. Especially for SaaS customers, this isn’t a scalable approach because you could integrate with hundreds of external IdPs. With the inbound federation Lambda trigger, you can solve this by filtering the groups to only those relevant to your application and normalizing the nomenclature of these groups. The following Lambda function filters the groups attribute to include only groups relevant to your application and normalizes the names of groups. This approach reduces a large group list to only what is applicable to your application. Authentication succeeds, and you maintain control over your user pool’s data without depending on external configuration changes. Use case 2: Automatic account linking The second use case addresses a challenge that’s particularly common in B2C facing ecommerce or any consumer-facing applications; although it can also be applicable to B2B scenarios. Imagine you’re running an online retail store. A customer creates an account with their email and password to make a purchase. A few months later, they return to your site but forgot they already created an account and they see the Login with Amazon button and decide to sign in this way. Without account linking, Amazon Cognito creates a new federated user because these are technically distinct accounts, and now this customer has two separate accounts with different purchase histories and saved preferences. This fragmentation creates a poor customer experience and complicates your business operations. You can’t see the customer’s complete purchase history, loyalty points are split across accounts, and your analytics show two distinct customers instead of one. The inbound federation Lambda trigger can be used to solve this by automatically linking federated identities to existing local accounts based on email address. While account linking can also be implemented in a pre-sign-up Lambda trigger, the inbound federation trigger runs on every federated sign-in, not just the first, giving you access to the latest IdP attributes and the ability to apply linking logic continuously rather than only at initial account creation. If no local Amazon Cognito account exists, you can create one and then link the social provider account to it. The local account can serve as the primary identity, ensuring consistent JSON Web Tokens (JWTs) regardless of how the user signs in. The following is an example of an inbound federation Lambda trigger that can help address this use case. Every federated sign-in will invoke the inbound federation Lambda trigger, and the logic is straightforward. When a user authenticates with an external identity provider, the trigger extracts their email from the federated response and searches the user pool for a local Cognito account with that same email. If one exists—such as if the user originally signed up with email and password—the Lambda function links the federated identity to that existing local account. If no local account exists, the trigger creates one on the fly as a passwordless account (confirmed, suppressing any emails, and ready for passwordless email one-time passcode (OTP) sign-in), then links the federated identity to it. In both cases, the local account is set as the primary profile. This means the user’s JWTs always carry the same sub-claim regardless of how they sign in—directly, or through Google, Facebook, or SAML—your application sees one consistent identity. The preceding Lambda trigger is also smart enough to check whether a linked account already exists before making the call, so returning users who’ve already been linked don’t generate unnecessary API calls. And because the local account supports passwordless authentication, a user who first arrived through federation can later sign in directly with an emailed OTP—or even add a password later through your applications account settings. The local account is always the anchor. Best practices As you implement these patterns, keep a few best practices in mind. Your Lambda function must be completed within 5 seconds, so optimize for speed to help ensure the federated sign-in process is able to successfully complete. If you’re making external calls within the inbound federation Lambda function, like Amazon DynamoDB queries or API requests, implement caching where possible. Handle errors gracefully—if your Lambda function throws an exception or an error, authentication could fail for the user. Consider logging the error and returning the original event back to Amazon Cognito rather than failing authentication for a legitimate user attempting to sign in. Here are some additional best practices for working with Lambda functions. For the account linking use case, automatic linking relies on matching the email from the federated identity to a local account. However, there are scenarios where this match won’t exist. For example, Apple’s Hide My Email feature generates a unique alias for each app, so the federated email won’t match any existing local account. This is an effective privacy feature but it also blocks the ability to automatically link accounts. In cases like these, your application will need to implement a user-initiated account linking flow, such as prompting the user to verify ownership of both email addresses before calling the AdminLinkProviderForUser API to complete the link. Monitor your Lambda function performance using Amazon CloudWatch metrics. Set up alarms for errors, timeouts, and throttling so you can respond quickly if issues arise. I also recommend capturing sample event payloads from a CloudWatch log group during your initial development and deployment—these will be valuable for local testing and debugging which can lead to quicker resolution if issues arise in your production environment. This is especially important as different IdPs (namely SAML and OIDC providers) may respond with varying attribute and value syntaxes. Consider implementing CloudWatch alarms to alert your security and operational teams if authentication failures spike, which could indicate an attempted attack, misconfiguration, or provide insight into further optimization of your inbound federation Lambda trigger. Conclusion In this post, you learned about the new inbound federation Lambda trigger for Amazon Cognito and how it can solve various use cases. You walked through two common federation challenges and reviewed some sample code to help resolve those challenges. For B2B and SaaS applications, the inbound federation Lambda trigger gives you control when dealing with oversized attributes from external identity providers (such as group membership) without requiring coordination with enterprise IT teams. For B2C and consumer-facing applications, it enables seamless account linking across multiple authentication methods, creating a unified customer experience. The new Lambda trigger works with SAML, OIDC, and supported social providers, and is available now in AWS Regions where Amazon Cognito is available. To learn more about the new Lambda trigger and others, see the Amazon Cognito Developer Guide. What federation challenges are you facing in your applications? I’d love to hear about your use cases in the comments below and over at AWS re:Post.
aws.amazon.comJun 4, 2026extracted
Supply Chain Attack: compromissione del pacchetto NPM Axios
Supply Chain Attack: compromissione del pacchetto NPM Axios Bollettino BL01/260331/CSIRT-ITA Sintesi È stata recentemente rilevata la compromissione della supply chain che ha interessato Axios, libreria JavaScript largamente utilizzata che fa da client HTTP per effettuare richieste verso API e servizi web. L'attacco, dovuto alla compromissione (hijacking) dell'account di un’utenza maintainer, ha permesso la pubblicazione sul registro NPM di versioni opportunamente predisposte, che integravano un malware dropper. Tali versioni sono progettate per installare un Remote Access Trojan (RAT) su sistemi Windows, macOS e Linux. Tipologia Remote Code Execution Descrizione dell’incidente L’evento è scaturito dalla compromissione (hijacking) dell'account NPM di uno dei maintainer del progetto Axios. L'attaccante, dopo aver acquisito il controllo dell'utenza e averne modificato l'indirizzo e-mail (passando a un provider crittografato ProtonMail), ha pubblicato manualmente, sul registro NPM, le versioni malevole 1.14.1 (per il ramo stabile 1.x) e 0.30.4 (per il ramo legacy 0.x). Tale operazione ha permesso l’elusione della pipeline di rilascio automatizzata su GitHub Actions e i relativi controlli basati su OIDC (OpenID Connect Trusted Publishing), infrangendo la catena di fiducia tra codice sorgente verificato e pacchetto distribuito. Vettore di Infezione e Payload Si evidenzia che la scelta dell'attaccante è stata quella di non alterare il codice sorgente del pacchetto Axios, utilizzando una tecnica di shadow injection che ha permesso di eludere i controlli di analisi statica (SAST) e le revisioni manuali dei diff tra le versioni. Nel dettaglio all'interno di tali versioni, l'attaccante ha iniettato una singola dipendenza malevola: [email protected], che sfrutta la funzionalità automatica di postinstall di NPM per lanciare istantaneamente uno script (setup.js) durante l'installazione della libreria. Lo script, fortemente offuscato per eludere l'analisi dinamica, contatta un server di Command and Control (C2) identificando il sistema operativo della vittima e scaricando payload specifici di secondo livello, per Windows, macOS o Linux. Completata l'installazione silente del Remote Access Trojan (RAT), il malware avvia routine di auto-eliminazione del dropper e ripristina lo stato originale dei file di configurazione del progetto (come package.json e i file di lock). Rimuovendo ogni riferimento alla dipendenza malevola plain-crypto-js dalla directory node_modules, il malware rende l'infezione invisibile ai comuni strumenti di auditing locale, garantendo la persistenza silenziosa a livello di sistema operativo. La diffusione delle versioni compromesse è stata interrotta tramite l'intervento del registro NPM, che ha provveduto al "ritiro forzato" (unpublish) delle versioni malevole di Axios (1.14.1 e 0.30.4). Contestualmente, il pacchetto plain-crypto-js è stato rimosso e sostituito con un security stub[1] per inibirne il download e l'esecuzione automatica. Potenziali Impatti 1. Data Breach: esfiltrazione di variabili d'ambiente, file di configurazione cloud (AWS, Azure, GCP), token di autenticazione e chiavi SSH. 2. Compromissione CI/CD: l'infezione di un runner permette all'attaccante di iniettare codice malevolo in altri progetti o manipolare gli artefatti finali (immagini Docker, binari), estendendo la compromissione alla supply chain dei propri clienti. 3. Lateral Movement: impiego delle informazioni carpite per ottenere l'accesso a risorse interne, database o segmenti di rete protetti, eludendo eventuali controlli grazie alla fiducia intrinseca degli ambienti di sviluppo. 4. Rischio Persistenza: la semplice eliminazione della directory node_modules o la rimozione del pacchetto Axios non elimina l'infezione, che rimane attiva e silente come processo di sistema indipendente. Prodotti e versioni affette axios - stable (1.x), versione 1.14.1 axios - legacy (0.x), versione 0.30.4 Pacchetti correlati @shadanai/openclaw, versioni 2026.3.28-2, 2026.3.28-3, 2026.3.31-1 e 2026.3.31-2 @qqbrowser/openclaw-qbot, versione 0.0.130 Azioni di mitigazione Gli utenti e le organizzazioni possono far fronte a questa tipologia di attacchi valutando l’implementazione delle misure di mitigazione raccomandate riportate di seguito: Audit: verificare nelle dipendenze (package-lock.json , o altri) la presenza delle versioni compromesse 1.14.1 o 0.30.4; Downgrade e Cache: forzare il ritorno a una versione stabile (ad esempio 1.7.9) e svuotare la cache di sistema con il comando npm cache clean –force (o comandi equivalenti); Rotazione di Credenziali e Token: revocare e rigenerare chiavi API, token cloud (AWS/Azure/GCP) e chiavi SSH presenti sulle macchine o nei runner CI/CD coinvolti; Bonifica Host: considerare ogni sistema che ha eseguito l'installazione del pacchetto in oggetto, come compromesso. La persistenza del malware a livello di sistema operativo richiede la formattazione o il ripristino dell'immagine degli host (laptop o server di build) interessati. Per verificare l’eventuale compromissione dei propri sistemi si raccomanda di valutare l’utilizzo dei meccanismi di rilevamento riportati al seguente link, nella sezione “Am I Affected?”. Infine, si raccomanda di valutare l’implementazione sui propri apparati di sicurezza degli Indicatori di Compromissione (IoC)[2] presenti nei link disponibili nella sezione Riferimenti. Security Stub: pacchetto segnaposto (placeholder) privo di codice funzionale, pubblicato dai gestori del registro NPM in sostituzione di un pacchetto rimosso per motivi di sicurezza. Lo scopo dello stub è inibire il download della versione malevola e generare un errore o un avviso di sicurezza esplicito qualora un sistema tenti di risolvere tale dipendenza, impedendo così la propagazione del malware e l'esecuzione di script dannosi (come i postinstall) legati al pacchetto originale. Per definizione, non tutti gli indicatori di compromissione sono malevoli. Questo CSIRT non ha alcuna responsabilità per l'attuazione di eventuali azioni proattive (es. inserimento degli IoC in blocklist) relative agli indicatori forniti. Le informazioni contenute in questo documento rappresentano la migliore comprensione della minaccia al momento del rilascio.
acn.gov.itMar 31, 2026extracted
Hackers compromise Axios npm package to drop cross-platform malware
Hackers hijacked the npm account of the Axios package, a JavaScript HTTP client with 100M+ weekly downloads, to deliver remote access trojans to Linux, Windows, and macOS systems. According to reports from software supply chain security and application security companies Endor Labs, Socket, Aikido, and StepSecurity, the threat actor published on the Node Package Manager (npm) registry two malicious versions of the package One malicious variant, [email protected], was published today at 00:21 UTC, while the second one, [email protected], emerged less than an hour later, at 01:00 UTC. The packages were published without the automated OpenID Connect (OIDC) package origin and no matching GitHub commit appeared, which should trigger an alert immediately. The researchers say that the threat actor gained access to the package after compromising the npm account of Jason Saayman, the main Axios maintainer. The OpenSourceMalware research community says that the attacker also took control of Saayman's GitHub account and changed the associated email to [email protected], then removed a report about the compromise to which project collaborator DigitalBrainJS was trying to reply. It is unclear how many downstream projects have been impacted by the supply-chain attack during the nearly three-hour exposure window. Given that the Axios npm package has around 400 million monthly downloads, the number may be significant. Axios is an HTTP client for JavaScript applications that manages requests between clients, such as browsers or Node.js apps, and servers. Its purpose is to simplify communication via GET, POST, PUT/PATCH, and DELETE requests. Infection chain After getting access to the package, the attacker injected a malicious dependency called plain-crypto-js@^4.2.1 into the package.json file and did not alter the Axios code. The dependency executes a post-install script during the package’s installation, launching an obfuscated dropper (setup.js) that contacts a command-and-control (C2) server to retrieve a next-stage payload based on the detected operating system. On Windows, the attack mixes VBScript and PowerShell to run a hidden Command Prompt window and execute a malicious script. The malware copies PowerShell to %PROGRAMDATA%\wt.exe to evade detection and achieve persistence across reboots, then downloads and executes a PowerShell script. On macOS, the malware uses AppleScript to download a binary to /Library/Caches/com.apple.act.mond, mark it as executable, and run it in the background. On Linux systems, the dropper fetches a Python-based payload stored at ‘/tmp/ld.py’ and executes it in the background with the nohup (no hang up) command. In all cases, the malware infected the host with a remote access trojan (RAT), allowing attackers to execute commands and maintain persistence on infected systems. The RAT can retrieve and execute a base64-encoded binary that it writes in a hidden temp file, execute shell commands via /bin/sh or AppleScript, and enumerate directories on the infected host. After the infection is completed, the dropper deletes itself, removes the modified package.json, and replaces it with a clean copy to make forensic investigations more difficult. According to researchers at StepSecurity, the Axios supply-chain attack was not opportunistic, but a carefully planned activity, as "the malicious dependency was staged 18 hours in advance." The fact that different payloads were delivered based on the detected operating system appears to support this theory, along with the self-destruct action for every artifact. John Hultquist, chief analyst at Google Threat Intelligence Group (GTIG) told BleepingComputer that behind the Axios package compromise is a North Korean actor tracked internally as UNC1069 and known to target "centralized exchanges (CEX), software developers at financial institutions, high-technology companies, and individuals at venture capital funds." A security researcher says that the macWebT name of the macOS RAT is a direct reference to malware used by the BlueNoroff hackers in campaigns observed by SentinelOne in 2023. BlueNoroff is a North Korean threat group specialized in financially-motivated cyberattacks. The actor has targeted banks, financial institutions, and cryptocurrency exchanges. Currently, there is no clear information about the threat actor behind the Axios supply-chain attack. Recently, several high-profile supply-chain attacks were claimed by a group known as TeamPCP. The hackers targeted popular open-source software projects like Telnyx, LiteLLM, and Trivy. However, the compromise of the Axios package does not have the characteristics of a TeamPCP attack, and security researchers couldn’t link it to a specific threat actor. Indicators of compromise (IoCs) are available from multiple organizations investigating the Axios supply-chain compromise and include the C2 domain used in the attack, sfrclak.com and other network details along with file system, packages data, and accounts observed in the attack: Security teams are recommended to check environments for the presence of [email protected], [email protected], or any version of plain-crypto-js and treat the system as compromised if any of them is detected. Axios should resolve to versions 1.14.0 or 0.30.3, or downgraded to an earlier version confirmed to be safe. Joe DeSimone of Elastic advises rotating credentials on systems running a compromised version of the Axios package, as the malware may have exfiltrated sensitive data such as keys and tokens. Charles Carmakal, chief technology officer at Mandiant, says that the Axios npm supply-chain attack "is broad and extends to other popular packages that have dependencies on it." The researcher warns that the amount of recent supply-chain incidents is overwhelming and that the secrets stolen this way over the past two weeks will lead to more compromises, crypto theft, ransomware, and extortion events. "We are aware of hundreds of thousands of stolen credentials. A variety of actors with varied motivations are behind these attacks," Carmakal says. Update [March 31, 13:09 EST]: Article updated with information about indicators of compromise and reference to potential BlueNoroff connection. Update [March 31, 14:22 EST]: Added attribution information and comments from Charles Carmakal and John Hultquist. Overall prevention scores can hide what happens after initial access. Once attackers are using valid credentials, prevention drops sharply. The Blue Report 2026 measures defenses technique by technique across 338 million simulations run in customer production environments. Get the report
bleepingcomputer.comMar 31, 2026extracted
日本企業は10年で「VPN 2.0」を導入しただけ 「ゼロトラストごっこ」を終わらす現実的な生存戦略
2025�N11��26���J�ẤuITmedia Security Week 2025 �H�v�ŁA�p�����S ����� �� �ō��Z�p�ӔC�� �ђB�玁���u�[���g���X�g�̐^�̈Ӌ�Ƃ��̊� ��[���g���X�g���ۂ��Ƃ̌��ʁ�v�Ƒ肵�ču�������B ���̋L���͉������ł��B����o�^�i�����j����ƑS�Ă������������܂��B �@�ю��́A����܂ő����̊�ƁE�g�D�̃Z�L�����e�B��ɁA�F�E�F��A�C�f���e�B�e�B�[�iID�j�Ǘ��𒆐S�Ɋւ���Ă����B�o�ώY�Ə� �������� ���v���W�F�N�g���i2020�2022�N�j�ɂ��ݐЂ��A���݂̓f�W�^���� �A�C�f���e�B�e�B�A�[�L�e�N�g�^�A�C�f���e�B�e�B���j�b�g ���j�b�g�������߂Ă���B�c����m��w ��w�@ ���f�B�A�f�U�C�������ȁiKMD�j������m�ے��ŁA����w��KMD������ �����ł�����B �@�u���g�D�̃V�X�e���͍��A�N������Ă��Ȃ��B�����f�����āA���S���Ė���Ă��܂����H�v�Ƃ����₢����n�܂����{�u���ŗю��́A���{�̑����̊�ƁE�g�D���ׂ��Ă���u�[���g���X�g�������v�ɑ��錵����������w�E�B�{������ׂ��Ɉڂ邽�߂ɁA�Z�p�ɉ����ċZ�p�ҁA�o�c�҂��ǂ̂悤�Ɏ����ϗe������K�v�����邩����������B�{�e�ł́A�u�����e��v��B �@�ю��́u�����͊��ɐN������Ă���v�Ƃ����O��ɗ��ׂ����Ǝ咣����B���̗����������A�[���g���X�g�Z�L�����e�B�ւ̑����Ȃ̂��Ƃ����B�ю��́A�{���I�ȉ��v�ɂ́u�g�D�̏d�v�T�[�o���C���^�[�l�b�g�ɒ��ځA���Œu���܂����H�v�Ƃ����₢�ɓ������邩�ɂ���Ƒ�����B���A�����Ȃ��Ă��Ȃ����R�͗��j��������Ă���B �@�u�[���g���X�g�v�Ƃ����l�������K�v�ɂȂ����w�i�ɂ́A�]���́u���E�h��v�^���f�������{���畢�����A���X�̏d��ȃZ�L�����e�B�C���V�f���g�����݂���B�ю��́A���j�Ɏc��悤�ȍU����������n��ŕ��͂��A���ꂼ�ꂪ����̃Z�L�����e�B�A�[�L�e�N����ɂǂ̂悤�ȋ��P�������炵�������������B �@2009�N�AGoogle���͂��߂Ƃ��鑽���̃e�b�N��Ƃ��W�I�ɂȂ����uOperation Aurora�v�́A��x�����l�b�g���[�N�ւ̐N�����������U���҂��u�M�����ꂽ���K�]�ƈ��v�Ƃ��ĐU�镑���A���������R�Ɉړ��i���e�������[�u�����g�j�ł��������𔒓��̉��ɂ��炵���B���̎������˂��t�������P�͋��E�h��̎��ł���A�u�ǂ̓����́A�����Ĉ��S�ł͂Ȃ��v���Ƃ�\�����̂������B �@���ɐ��E��k���������̂́A�U���҂�MSP�i�}�l�[�W�h�T�[�r�X�v���o�C�_�[�j�Ƃ̐M���W�����p���A�����e�i���X�pVPN�iVirtual Private Network�j�ڑ��Ƃ����u�����v����ڋq�l�b�g���[�N�ɐN�������uOperation Cloud Hopper�v���B�uA�Ђ�B�Ђ�M�����Ă��邩��Ƃ����āAB�Ђ���̃p�P�b�g�����ɐM�p���Ă͂Ȃ�Ȃ��v�Ƃ����T�v���C��F�[���U���ɂ�����d�v�ȋ��P�u�M���͐��ڂ��Ȃ��v���m�����ꂽ�B �@���ݐi�s��ő����uVolt Typhoon�v�́A�}���E�F�A���g�킸�AOS�W���c�[���݂̂𗘗p����uLiving off the Land�v�i���ALotL�j��p�ƁA��������SOHO���[�^�[�Q�ݑ�ɂ��邱�ƂŁu��ʉƒ납��̃A�N�Z�X�v�ɋU������I���Ȏ����g�ݍ��킹��B �@�]���̌��m��@�����͉������Volt Typhoon�ɑ��A�ю��́u�Ȃ����̃��[�U�[���A�[��ɉƒ�p���[�^�[�o�R��PowerShell�����s���Ă���̂��H�v�Ƃ������A�R���e�L�X�g�ُ̈�𗝉����邱�Ƃ̏d�v������������B �@Salt Typhoon�����ݐi�s��̋��Ђ��BAT&T��Verizon�ALumen�Ƃ�����ISP�i�C���^�[�l�b�g�T�[�r�X�v���o�C�_�[�j�̃R�A�l�b�g���[�N�A�����Cisco Systems�����[�^�[���^�[�Q�b�g�ɁA�Ǝ�i�������Ⴍ�j����˂����ƂŃ��[�^�[���x���Ńg���t�B�b�N���~���[�����O���A�U���҂̃T�[�o�ɓ]��������B �@�u�G���h�|�C���g��T�[�o�ł͂Ȃ��A�������Ȃ��y�ǁi�l�b�g���[�N�j���̂��̂��������ꂽ�B�o�b�N�h�A�i���@�I�T��j���̂��U���҂̃o�b�N�h�A�Ƃ��ċ@�\�����ň��̃P�[�X�BISP��l�b�g���[�N�@�킷��M�p�ł��Ȃ��B�A�v���P�[�V�����w�iL7�j�ł̃G���h�c�[�G���h�Í����iALTS�FApplication Layer Transport Security�j�Ƒ��ݔF�imTLS�FMutual Transport Layer Security�j�ȊO�ɖh���͂Ȃ��v�i�ю��j �@�ߔN�A�U���̎����ID��Ղ��̂��̂Ɉڂ��Ă���B�uStorm-0558�v�ł�Microsoft�̏��������ގ悳��A�uMidnight Blizzard�v�ł�MFA�i���v�f�F�FMulti-Factor Authentication�j���ݒ�̃e�X�g�����N�_�ɁA�{�Ԋ��́uMicrosoft 365�v�ւ̃t���A�N�Z�X�����������ӂ���OAuth�A�v�����쐬���ꂽ�B����ꂪ�ˑ�����IDaaS�iIdentity as a Service�j���̂��P���Q�_�ɂȂ蓾��Ƃ��������́A�uIDaaS�Ȃ���S�v�Ƃ�������̏I���������Ă���Ɨю��͎w�E����B �@�����̎����͑Ί݂̉Ύ��ł͂Ȃ��B�u���J�Î��i2025�N11���j�ł��V�X�e���ɉe�����c���Ă����A�T�q�O���[�v�z�[���f�B���O�X�iHD�j�̃C���V�f���g�ł́A�N��������s�܂łɖ�17�J�����̒����Ԑ�������Ă����\�����w�E����Ă���B����͌��݂̓��{�ɂ����鋫�E�h��̎��Ԃ̈�[���B�ю��͌x���������炷�B �@�u�U���҂�1�N�ȏ�A���Ȃ��̏]�ƈ��ׂ̗ő�����߂Đ������Ă��邩������Ȃ��v �@�����̗��j�I�C���V�f���g�́A�����̃Z�L�����e�B���f���������Ɍ��E�ɒB���Ă��邩�������Ă���B�ǂɎ��ꂽ�u�����v�͂��͂⑶�݂��Ȃ��B���̌����F���������A�[���g���X�g�̐^�̒��𗝉�����o���_�ƂȂ�B �@���E�h��̍\���I�s�k��Ɋ�����Google�́AOperation Aurora���@�ɁuBeyondCorp�v�Ƃ����V���ȃZ�L�����e�B���f���̍\�z�ɒ��肵���B�ю��ɂ��A�����Google�ɂƂ��Ắu���������v�ł���A�P�Ȃ鐻�i�����ł͂Ȃ��A�Z�L�����e�B�N�w�̍��{�I�ȕϊv�������Ƃ����B �@�����ł́uCorp�v�͈�ʖ����ł͂Ȃ��BGoogle�Г��ɑ��݂��������C���g���l�b�g�ucorp.google.com�v�Ƃ����ŗL�������w���B���āA���̃l�b�g���[�N�̓����ɂ���ΎГ��̂�����Ɩ��A�v���ɃA�N�Z�X�ł��鐹�悾�����BGoogle�����������f�́A���̐���̊��S�Ȕp�~���B �@Google�͎Г�LAN���A�J�t�F�̌��OWi-Fi�ȂǂƓ����́A��ؐM���ł��Ȃ��l�b�g���[�N�ɒu���������B����ɂ��A�A�N�Z�X����̊�_�́u�ꏊ�v�iIP�A�h���X�j����uID�ƃf�o�C�X�̏�ԁv�i�R���e�L�X�g�j�ւƊ��S�Ɉڍs���ꂽ�B���̌��ʁAVPN�͑S�p����A�S�Ẵ��N�G�X�g���ʂɌ�����Identity-Aware Proxy�iIAP�j���A�v���P�[�V�����̎�O�ɔz�u���ꂽ�B �@�u�����̏��݂��w�l�b�g���[�N�x����wID�x�Ɉړ]������A�[�L�e�N����̍\�����v�������[���g���X�g�̖{�����v �@�[���g���X�g�Ƃ������t�����{�ŕ��y���Ă���10�N�B�������A�ю��͂��̎����̑������{�����猜�����ꂽ�u�[���g���X�g�������v�ɂƂǂ܂��Ă���ƌ������w�E����B �@�����̓��{��Ƃ���������ZTNA�i�[���g���X�g�l�b�g���[�N�A�N�Z�X�j���i�̎��Ԃ́A�C���o�E���h�|�[�g����������́uVPN 2.0�v�ɉ߂��Ȃ��P�[�X���U�������Ɨю��B�g���l���Z�p�ŎГ��l�b�g���[�N���������Ă��邾���ł���A��x�N�����������e�������[�u�����g�̃��X�N�͑S����������Ă��Ȃ��B �@�u�|���V�[���w10.0.0.0/8 Permit�x�Ȃ�A����̓N���E�h�o�R�̋����LAN�ł����Ȃ��v�i�ю��j �@�����������P�[�X�ł́A���[����肪��������Ă���B�uIDaaS����ꂽ������S�v�uSWG�iSecure Web Gateway�j��CASB�iCloud Access Security Broker�j�����Ă����Α��v�v�Ƃ������A���i�����ɂ��v�l��~���B �@�uID�����͑O�i�����A�f�o�C�X�̏�Ԃ����Ă��Ȃ��B�R���e�L�X�g���l�����Ȃ���Ζ��͂ȕ������c��B�o����͂��Ă��A�����ʐM�����@�n�т̂܂܂ł́A���������U���҂̊����������Ă��܂��B�����͋Z�p�I���̌p�����v �@�ł́A�Ȃ������̑g�D�́A�A�[�L�e�N����̕ϊv�ł͂Ȃ��A���Ղȃt�@�C�A�E�H�[���ɓ�������ł����̂��낤���B�ю��́A�u������̖₢�u�g�D�̏d�v�T�[�o���C���^�[�l�b�g�ɒ��ځA���Œu���܂����H�v�ɐG��A���̗��j�I�w�i���l�@����B �@���āASELinux��Network Access Control�AHost-based IPS�iIntrusion Prevention System�j�Ƃ������z�X�g���S�i����낤�j���Z�p�͑��݂������A���̕��G���Ɖ^�p���ׂ̍������猻��Ō�[�����Ă������B���̉ߋ��̎��s���A���E�h��^�Ƃ���������₷���Z�L�����e�B���f���ւ̐[�������I�ˑ��݁A�����̋Z�p�I�����i�������Ă���B �@����E�p���A�����I�Ȉ���ݏo���ɂ́A���z�_�ł͂Ȃ���̓I�Ȑ헪�����߂���B �@�S�]�ƈ��ɍ����ȃ��C�Z���X��t�^�������S�Ǘ��[����z�z����\�\Google���u�k�ɐ��v�ƕ\������悤�ȗ��z�I�ȃ[���g���X�g�́A�����̓��{��ƂɂƂ��Ĕ��I���B�������A�ю��́u���߂�K�v�͂Ȃ��v�ƌ��A�R�X�g�ƕ����̕ǂ��z���邽�߂̌����I�ȃA�v���[������B �@�܂��������ׂ��́A�R�X�g���ABYOD�iBring Your Own Device�j�ɂ�����v���C�o�V�[�ւ̒�R���A������MDM�iMobile Device Management�j��EDR�iEndpoint Detection and Response�j�̖���������3���B �@���ɁuEDR����ꂽ����MDM�͕s�v�v�Ƃ����uEDR�_�b�v�́u�v���I�Ȍ�����v�Ɨю��BMDM�́u�˒��܂�v�i�\�h�j�ł���AEDR�́u�Ď��J�����v�i����Ή��j���B�Ď��J�����������Ă��˒��܂肪�Ȃ���ΓD�_�͓������ł���AEDR�����ł͐�q��LotL�U���ɂ͖��͂��B�����āATPM�iTrusted Platform Module�j�Ƃ������n�[�h�E�F�A�ł̖h����K�v�ɂȂ�B �@�R�X�g��v���C�o�V�[�AEDR�_�b�̖����������邽�߂ɗю��������̂��A�u�M���̊K�w���v�Ƃ��������I�Ȑ����헪���B����́AGoogle�́uTrust Tiers�v���f�����Q�l�ɁA�f�o�C�X�̊Ǘ����x���ɉ����ăA�N�Z�X����������A�v���[����B �@�[���g���X�g�̊T�O�́A���͂�]�ƈ��̃A�N�Z�X�iBeyondCorp�j�����ɂƂǂ܂�Ȃ��B�u�k�ɐ��͈ړ������v�Ɨю��͌��A�h�q�����N���E�h�l�C�e�B�u���ɂ�����T�[�r�X�ԒʐM�Ɋg�����ꂽ�uBeyondProd�v�̐��E����������B �@BeyondProd�Ƃ́A�f�[�^�Z���^�[�����ł���M�������A�}�C�N���T�[�r�X�Ԃ̒ʐM�i���[�N���[�hID�j�������郂�f�����BIP�A�h���X���Ӗ��𐬂��Ȃ��Ȃ����R���e�i���ŏd�v�Ȃ̂́u�ǂ�IP���v�ł͂Ȃ��u�ǂ̃��[�N���[�h���v�u�ǂ̃R�[�h���v����肷�邱�Ƃ��B �@���̎����W���Ƃ��āA�ю���Cloud Native Computing Foundation�iCNCF�j�̃v���W�F�N�g�uSPIFFE/SPIRE�v�iSecure Production Identity Framework for Everyone/SPIFFE Runtime Environment�j���Љ���B�v���b�g�t�H�[���Ɉˑ������A�����郏�[�N���[�h�Ɍ��؉\��ID�I�ɕt�^����I�[�v���Ȏd�g�݂��B �@����ɖ����ɖڂ�������ƁA���U����ID�Ǘ��@�\��A�g������uIdentity Fabric�v�Ƃ����T�O��A�����I�Ƀ^�X�N�����s����AI�i�l�H�m�\�j�G�[�W�F���g���̂�ID��t�^����l�����ANIST�i�č����W���Z�p�������j���f������̉�����OpenID Foundation�ɂ��AuthZEN�iAuthorization Exchange�j��SSF�iShared Signals Framework�j�Ƃ������W���d�l�ȂǁAID�Ǘ��͂�蓮�I�����ݐڑ����ꂽ���E�Ɍ������Ă���B �@�u���̍Ō�ɁA�ю��̓[���g���X�g���f���ւ̈ڍs�ɂ�����A����ׂ��p���Ƃ��āA�G���W�j�A�����O�̐��E����2�̌��t�����p�����B �@1�ڂ́A�G�N�X�g���[���v���O���~���O�iXP�j�̒҃P���g�E�x�b�N���́uEmbrace Change�v�i�ω�����i����j���B���Ђ�����₦���ω����钆�ŁA�Œ�I�ȁu�ǁv�ɌŎ�����̂ł͂Ȃ��AID�ƃR�[�h���j�Ƃ��āA�ω��ɂ��Ȃ₩�ɑΉ��ł���\���ւƎ����ϗe�����Ă����K�v������B �@2�ڂ́A�\�t�g�E�F�A�J���҂̃W���G���E�X�|���X�L�[���́uFire and Motion�v�i�ˌ����O�i�j�B���z�͉�����������Ȃ����A�͍��̒��ŗ����~�܂��Ă�������ꌂ����Ă��܂��B�����Ȍv���҂̂ł͂Ȃ��A�����̃Z�L�����e�B��Ŏ��Ԃ��҂��Ȃ���A���̗��ŏ������ł��Z�p�I����ԍς��A�A�[�L�e�N����̖{���I�ȉ��P��i�߂�ׂ����B �@�Ō�ɁA�ю��́u�w�[���g���X�g���ۂ��x���瑲�Ƃ��A�wBeyondCorp�x�Ɋw�сA�C���^�[�l�b�g�ɐ������Ȃ���x�o��������Ăق����v�ƌĂъ|����B���̐�ɂ����A�u������̖₢�ɑ���^�̓����A���Ȃ킿�u�{���Ɉ��S���Ė����v��Ԃ��҂��Ă���̂��B �@�ю��́A����܂ł�ITmedia Security Week�Łu�F�v���e�[�}�ɉ��x���u�����Ă���B����ҏW���ł́A���̔F�̏d�v����ʊp�x����œ_�Ă�ׂ��A�[���g���X�g���e�[�}�ɂ����u�����˗������B���͂�[���g���X�g�ƔF�E�F�͂قړ��`�ł���A���m�E�Ή������ł͂Ȃ��h��̎��_�ł��d�v�������܂��Ă���B�������AIDaaS�̗��p���S�[���ł͂Ȃ��B�ю��ɂ́A���̎����J�ɉ�����Ă����������B �@���i�̓������Z�L�����e�B����̒��S�ł͂Ȃ��Ȃ������A�܂��͍�����ꂽ�悤�ȍl�����ւƈӎ������߂邱�Ƃ������A��ƁE�g�D���ł���u�ˌ����O�i�v�̑����ɂȂ�g�s���h�Ȃ̂ł͂Ȃ����낤���B Copyright © ITmedia, Inc. All Rights Reserved.
atmarkit.itmedia.co.jpMar 30, 2026extracted
Microsoft hands Entra ID users new option for MFA
Microsoft hands Entra ID users new option for MFA Organizations rely on MFA to enforce identity checks before granting access to systems and services. Microsoft has made external MFA generally available in Microsoft Entra ID, expanding support for third-party identity providers. Configure external MFA in Microsoft Entra ID (Source: Microsoft) External MFA supports organizations that use third-party MFA solutions to meet regulatory or business requirements, handle scenarios such as mergers and acquisitions, or maintain a consistent MFA approach within Microsoft Entra ID. Built on the OpenID Connect (OIDC) standard, it enables integration of a preferred MFA provider while maintaining Conditional Access and policy enforcement. Once configured, the external method becomes part of the tenant’s authentication methods policy as an external authentication method configuration. Administrators can assign it to specific user groups, including or excluding groups as needed, and manage it alongside built-in authentication options. Organizations must grant administrative consent so the external provider can access required user information during authentication. “Integrating external MFA with Conditional Access allows administrators to align authentication prompts with their organization’s security and business objectives by using sign-in frequency and session controls. When these policies are properly tuned, they strike the right balance between reauthentication and user productivity,” Swaroop Krishnamurthy, Principal Product Lead at Microsoft , explained. “However, overly frequent reauthentication can degrade user experience and can even increase phishing risk by conditioning users to approve prompts without careful review. To avoid these issues, we recommend following Microsoft’s reauthentication guidance when configuring your Conditional Access policies,” Krishnamurthy continued. During sign-in, Microsoft Entra ID evaluates applicable policies and prompts for MFA when required. If the external method is available, users can complete the second authentication factor through the external provider. Microsoft Entra ID validates both the initial sign-in and the external verification before granting access. Microsoft said the capability provides more flexibility in how organizations implement MFA while keeping enforcement and policy evaluation centralized within Entra ID. External MFA replaces Custom Controls, which will be deprecated on September 30, 2026. Existing configurations will continue to function during the transition period. Microsoft plans to publish migration guidance ahead of the retirement date.
helpnetsecurity.comMar 25, 2026extracted
⚡ Weekly Recap: Chrome 0-Days, Router Botnets, AWS Breach, Rogue AI Agents & More
Some weeks in security feel normal. Then you read a few tabs and get that immediate “ah, great, we’re doing this now” feeling. This week has that energy. Fresh messes, old problems getting sharper, and research that stops feeling theoretical real fast. A few bits hit a little too close to real life, too. There’s a good mix here: weird abuse of trusted stuff, quiet infrastructure ugliness, sketchy chatter, and the usual reminder that attackers will use anything that works. Scroll on. You’ll see what I mean. ⚡ Threat of the Week Google Patches 2 Actively Exploited Chrome 0-Days — Google released security updates for its Chrome web browser to address two high-severity vulnerabilities that it said have been exploited in the wild. The vulnerabilities related to an out-of-bounds write vulnerability in the Skia 2D graphics library (CVE-2026-3909) and an inappropriate implementation vulnerability in the V8 JavaScript and WebAssembly engine (CVE-2026-3910) that could result in out-of-bounds memory access or code execution, respectively. Google did not share additional details about the flaws, but acknowledged that there exist exploits for both of them. The issues were addressed in Chrome versions 146.0.7680.75/76 for Windows and Apple macOS, and 146.0.7680.75 for Linux. Detection Starts the Clock. Response Decisions Shape the Outcome When incidents escalate, early decisions determine containment and impact. Join this SANS IR Command Roundtable to learn how experienced teams avoid investigation drift, improve coordination, and execute faster response across cloud, enterprise, and operational environments. Watch the Webcast ➝ 🔔 Top News Meta to Discontinue Instagram E2EE in May 2026 — Meta announced plans to discontinue support for end-to-end encryption (E2EE) for chats on Instagram after May 8, 2026. In a statement shared with The Hacker News, a Meta spokesperson said, "Very few people were opting in to end-to-end encrypted messaging in DMs, so we're removing this option from Instagram in the coming months. Anyone who wants to keep messaging with end-to-end encryption can easily do that on WhatsApp." Authorities Disrupt SocksEscort Service — A court-authorized international law enforcement operation dismantled a criminal proxy service named SocksEscort that enslaved thousands of residential routers worldwide into a botnet for committing large-scale fraud. "The malware allowed SocksEscort to direct internet traffic through the infected routers. SocksEscort sold this access to its customers," the U.S. Justice Department said. The main thing to note here is that SocksEscort was powered by AVrecon, a malware written in C to explicitly target MIPS and ARM architectures via known security flaws in edge network devices. The malware also featured a novel persistence mechanism that involved flashing custom firmware, which intentionally disables future updates, permanently transforming SOHO routers into SocksEscort proxy nodes to blindside corporate monitoring. UNC6426 Exploits nx npm Supply Chain Attack to Gain AWS Admin Access in 72 Hours — A threat actor known as UNC6426 leveraged keys stolen following the supply chain compromise of the nx npm package in August 2025 to completely breach a victim's AWS environment within 72 hours. UNC6426 used the access to abuse the GitHub-to-AWS OpenID Connect (OIDC) trust and create a new administrator role in the cloud environment, Google said. Subsequently, this role was abused to exfiltrate files from the client's Amazon Web Services (AWS) Simple Storage Service (S3) buckets and perform data destruction in their production cloud environments. KadNap Enslaves Network Devices to Fuel Illegal Proxy — A takedown-resistant botnet comprising more than 14,000 routers and other network devices has been conscripted into a proxy network that anonymously ferries traffic used for cybercrime. The botnet, named KadNap, exploits known vulnerabilities in Asus routers (among others), leveraging the initial access to drop shell scripts that reach out to a peer-to-peer network based on Kademlia for decentralized control. Infected devices are being used to fuel a proxy service named Doppelganger that, for a fee, tunnels customers' internet traffic through residential IP addresses, offering a way for attackers to blend in and make it harder to differentiate malicious traffic from legitimate activity. APT28 Strikes with Sophisticated Toolkit — The Russian threat actor known as APT28 has been observed using a bespoke toolkit in recent cyber espionage campaigns targeting Ukrainian cyber assets. The primary components of the toolkit are two implants, one of which employs techniques from a malware framework the threat actor used in 2010s, while the other is a heavily modified version of the COVENANT framework for long-term spying. COVENANT is used in concert with BEARDSHELL to facilitate data exfiltration, lateral movement, and execution of PowerShell commands. Also alongside these tools is a malware named SLIMAGENT that shares overlaps with XAgent. ️🔥 Trending CVEs New vulnerabilities show up every week, and the window between disclosure and exploitation keeps getting shorter. The flaws below are this week's most critical — high-severity, widely used software, or already drawing attention from the security community. Check these first, patch what applies, and don't wait on the ones marked urgent — CVE-2026-3909, CVE-2026-3910, CVE-2026-3913 (Google Chrome), CVE-2026-21666, CVE-2026-21667, CVE-2026-21668, CVE-2026-21672, CVE-2026-21708, CVE-2026-21669, CVE-2026-21671 (Veeam Backup & Replication), CVE-2026-27577, CVE-2026-27493, CVE-2026-27495, CVE-2026-27497 (n8n), CVE-2026-26127, CVE-2026-21262 (Microsoft Windows), CVE-2019-17571, CVE-2026-27685 (SAP), CVE-2026-3102 (ExifTool for macOS), CVE-2026-27944 (Nginx UI), CVE-2025-67826 (K7 Ultimate Security), CVE-2026-26224, CVE-2026-26225 (Intego X9), CVE-2026-29000 (pac4j-jwt), CVE-2026-23813 (HPE Aruba Networking AOS-CX), CVE-2025-12818 (PostgreSQL), CVE-2026-2413 (Ally WordPress plugin), CVE-2026-0953 (Tutor LMS Pro WordPress plugin), CVE-2026-25921 (Gogs), CVE-2026-2833, CVE-2026-2835, CVE-2026-2836 (Cloudflare Pingora), CVE-2026-24308 (Apache ZooKeeper), CVE-2026-3059, CVE-2026-3060, CVE-2026-3989 (SGLang), CVE-2026-0231 (Palo Alto Networks Cortex XDR Broker VM), CVE-2026-20040, CVE-2026-20046 (Cisco IOS XR Software), CVE-2025-65587 (graphql-upload-minimal), CVE-2026-3497 (OpenSSH), CVE-2026-26123 (Microsoft Authenticator for Android and iOS), and CVE-2025-61915 (CUPS). 🎥 Cybersecurity Webinars Stop Guessing: Automate Your Defense Against Real-World Attacks → Learn how to move beyond basic security checklists by using automation to test your defenses against real-world attacks. Experts will show you why traditional testing often fails and how to use continuous, data-driven tools to find and fix gaps in your protection. You will learn how to prove your security actually works without increasing your manual workload. Fix Your Identity Security: Closing the Gaps Before Hackers Find Them → This webinar covers a new study about why many companies are struggling to keep their user accounts and digital identities safe. Experts share findings from the Ponemon Institute on the biggest security gaps, such as disconnected apps and the new risks created by AI. You will learn simple, practical steps to fix these problems and get better control over who has access to your company's data. The Ghost in the Machine: Securing the Secret Identities of Your AI Agents → As artificial intelligence (AI) begins to act on its own, businesses face a new challenge: how to give these "AI agents" the right digital IDs. This webinar explains why current security for humans doesn't work for autonomous bots and how to build a better system to track what they do. You will learn simple, real-world steps to give AI agents secure identities and clear rules, ensuring they don't accidentally expose your private company data. 📰 Around the Cyber World Fake Google Security Check Drops Browser RAT — A web page mimicking a Google Account security page has been spotted delivering a fully featured browser-based surveillance toolkit that takes the form of a Progressive Web App (PWA). "Disguised as a routine security checkup, it walks victims through a four-step flow that grants the attacker push notification access, the device's contact list, real-time GPS location, and clipboard contents—all without installing a traditional app," Malwarebytes said. "For victims who follow every prompt, the site also delivers an Android companion package introducing a native implant that includes a custom keyboard (enabling keystroke capture), accessibility-based screen reading capabilities, and permissions consistent with call log access and microphone recording." Forbidden Hyena Delivers BlackReaperRAT — A hacktivist group known as Forbidden Hyena (aka 4B1D) has distributed RAR archives in December 2025 and January 2026 in attacks targeting Russia that led to the deployment of a previously undocumented remote access trojan called BlackReaperRAT and an updated version of the Blackout Locker ransomware, referred to as Milkyway by the threat actors. BlackReaperRAT is capable of running commands via "cmd.exe," uploading/downloading files, spawning an HTTP shell to receive commands, and spreading the malware to connected removable media. "It carries out destructive attacks against organizations across various sectors located within the Russian Federation," BI.ZONE said. "The group publishes information regarding successful attacks on its Telegram channel. It collaborates with the groups Cobalt Werewolf and Hoody Hyena." Chinese Hackers Target the Persian Gulf region with PlugX — A China-nexus threat actor, likely suspected to be Mustang Panda, has targeted countries in the Persian Gulf region. The activity took place within the first 24 hours of the ongoing conflict in the Middle East late last month. The campaign used a multi-stage attack chain that ultimately deployed a PlugX backdoor variant. "The shellcode and PlugX backdoor used obfuscation techniques such as control flow flattening (CFF) and mixed boolean arithmetic (MBA) to hinder reverse engineering," Zscaler said. "The PlugX variant in this campaign supports HTTPS for command-and-control (C2) communication and DNS-over-HTTPS (DOH) for domain resolution." Phishing Campaign Uses SEO Poisoning to Steal Data — A phishing campaign has employed SEO poisoning to direct search engine results to fake traffic ticket portals that impersonate the Government of Canada and specific provincial agencies. "The campaign lures victims to a fake 'Traffic Ticket Search Portal' under the pretense of paying outstanding traffic violations," Palo Alto Networks Unit 42 said. "Submitted data includes license plates, address, date of birth, phone/email, and credit card numbers." The phishing pages utilize a "waiting room" tactic where the victim's browser polls the server every two seconds and triggers redirects based on specific status codes. Roundcube Exploitation Toolkit Discovered — Hunt.io said it discovered a Roundcube exploitation toolkit on an internet-exposed directory on 203.161.50[.]145. It's worth noting that Russian threat actors like APT28, Winter Vivern, and TAG-70 have repeatedly targeted Roundcube vulnerabilities to breach Ukrainian organizations. "The directory included development and production XSS payloads, a Flask-based command-and-control server, CSS-injection tooling, operator bash history, and a Go-based implant deployed on a compromised Ukrainian web application," the company said, attributing it with medium to high confidence to APT28, citing overlaps with Operation RoundPress. The toolkit, dubbed Roundish, supports credential harvesting, persistent mail forwarding, bulk email exfiltration, address book theft, and two-factor authentication (2FA) secret extraction, mirroring a feature present in MDAEMON. One of the primary targets of the attack is mail.dmsu.gov[.]ua, a Roundcube webmail instance associated with Ukraine's State Migration Service (DMSU). Besides the possibility of a shared development lineage, Roundish introduces four new components not previously documented in APT28 webmail activity, including a CSS-based side-channel module, browser credential stealer, and a Go-based backdoor that provides persistence via cron, systemd, and SELinux. The CSS injection component is designed to progressively extract characters from Roundcube's document object model (DOM) without injecting any JavaScript into the victim's page. The technique is likely used for targeting Cross-Site Request Forgery (CSRF) tokens or email UIDs. Central to the Roundish toolkit is an XSS payload that's engineered to steal the victim's email address, harvest account credentials, redirect all incoming emails to a Proton Mail address, export mailbox data from the victim's Inbox and Sent folders, and gather the victim's complete address book. "The combination of hidden autofill credential harvesting, server-side mail forwarding persistence, bulk mailbox exfiltration, and browser credential theft reflects a modular approach designed for sustained access," Hunt.io said. "From a defensive perspective, password resets alone are not sufficient in cases like this. Mail forwarding rules, Sieve filters, and multi-factor authentication secrets must be audited and reset." Phishing Campaign Targeting AWS Console Credentials — An active adversary-in-the-middle (AiTM) phishing campaign is using fake security alert emails to steal AWS Console credentials, per Datadog. "The phishing kit proxies authentication to the legitimate AWS sign-in endpoint in real time, validating credentials before redirecting victims and likely capturing one-time password (OTP) codes," the company said. "This campaign does not exploit AWS vulnerabilities or abuse AWS infrastructure." Post-compromise console access has been observed within 20 minutes of credential submission. These efforts originated from Mullvad VPN infrastructure. Malicious npm Packages Deliver Cipher stealer — Two new malicious npm packages, bluelite-bot-manager and test-logsmodule-v-zisko, were found to deliver via Dropbox a Windows executable designed to siphon sensitive data, including Discord totems, credentials from Chrome, Edge, Opera, Brave, and Yandex browsers, and seed files from cryptocurrency wallet apps like Exodus. from compromised hosts using a stealer named Cipher stealer. "The stealer also uses an embedded Python script and a secondary payload downloaded from GitHub," JFrog said. GIBCRYPTO Ransomware Detailed — A new ransomware called GIBCRYPTO comes with the ability to capture keystrokes and corrupt the Master Boot Record (MBR) so that any attempt to restart the system will cause the system to run into an error. The ransomware uses the Salsa20 algorithm for encryption. It's suspected to be part of Snake Keylogger, indicating the malware authors' attempts to diversify beyond information theft. The development comes as Sygnia highlighted SafePay's OneDrive-based data exfiltration technique during a ransomware attack after breaching a victim by leveraging a FortiGate firewall flaw and a misconfigured administrative account. "SafePay gained initial access by exploiting a firewall misconfiguration, which enabled them to obtain local administrative credentials," the company said. "They rapidly escalated discovery and enumeration activities to identify high-value targets for lateral movement, demonstrating a structured and methodical approach to mapping the environment. Within a matter of hours, SafePay escalated to domain administrator access." The attack culminated in the deployment of ransomware, encrypting more than 60 servers. Fraudulent Account Registration Activity Originating from Vietnam — A sprawling cybercrime ecosystem based in Vietnam has been linked to a cluster of fraudulent account registration activity on platforms like LinkedIn, Instagram, Facebook, and TikTok. In these attacks, attributed to O-UNC-036, the threat actors rely on disposable email addresses in order to execute SMS pumping attacks, also called International Revenue Sharing Fraud (IRSF). "In this scheme, malicious actors automate the creation of puppet accounts in a targeted service provider," Okta said. "Fraudsters use these account registrations to trigger SMS messages to premium rate phone numbers and profit from charges incurred. This activity can prove costly for service providers who use SMS to verify registration information in customer accounts or to send multi-factor authentication (MFA) security codes." O-UNC-036 has also been linked to a cybercrime-as–a-service (CaaS) ecosystem that provides paid infrastructure and services to facilitate online fraud. The web-based storefronts are hosted in Vietnam and specialize in the sales of web-based accounts. Hijacked AppsFlyer SDK Distributes Crypto Clipper — The AppsFlyer Web SDK was briefly hijacked to serve malicious code to steal cryptocurrency in a supply chain attack. The clipper malware payload came with capabilities to intercept cryptocurrency wallet addresses entered on websites and replace them with attacker-controlled addresses to divert funds to the threat actor. "The AppsFlyer Web SDK was observed serving obfuscated malicious JavaScript instead of the legitimate SDK from websdk.appsflyer[.]com," Profero said. "The malicious payload appears to have been designed for stealth and compatibility, preserving legitimate SDK functionality while adding hidden browser hooks and wallet-hijacking logic." The incident has since been resolved by AppsFlyer. Operation CamelClone Targets Government and Defense Entities — A new cyber espionage campaign dubbed Operation CamelClone has targeted governments and defense entities in Algeria, Mongolia, Ukraine, and Kuwait using malicious ZIP archives that contain a Windows shortcut (LNK) file, which, when executed, delivers a JavaScript loader named HOPPINGANT. The loader then delivers additional payloads for establishing C2 and exfiltrating data to the MEGA cloud storage service. "One interesting aspect of this campaign is that the threat actor does not rely on traditional command-and-control infrastructure," Seqrite Labs said. "Instead, the payloads are hosted on a public file-sharing service, filebulldogs[.]com, while stolen data is uploaded to MEGA storage using the legitimate tool Rclone." The activity has not been attributed to any known threat group. How Threat Actors Exfiltrate Credentials Using Telegram Bots — Threat actors are abusing the Telegram Bot API to exfiltrate data via text messages or arbitrary file uploads, highlighting how legitimate services can be weaponized to evade detection. Agent Tesla Keylogger is by far the most prominent example of a malware family that uses Telegram for C2. "In general, Telegram C2s appear to be most popular among information stealers, possibly due to Telegram's technically legitimate nature and because information stealers typically only need to exfiltrate data passively rather than provide complex communications beyond simple message or file transfers," Cofense said. Microsoft Launches Copilot Health — Microsoft has become the latest company after OpenAI and Anthropic to launch a dedicated "secure space" called Copilot Health that integrates medical records, biometric data from wearables, and lab test results to give personalized advice in the U.S. "Copilot Health brings together your health records, wearable data, and health history into one place, then applies intelligence to turn them into a coherent story," the company said. Like OpenAI and Anthropic, Microsoft emphasized that Copilot Health isn't meant to replace professional medical care. Rogue AI Agents Can Work Together to Engage in Offensive Behaviors — According to a new report from artificial intelligence (AI) security company Irregular, agents can work together to hack into systems, escalate privileges, disable endpoint protection, and steal sensitive data while evading pattern-matching defenses. What's notable is that the experiment did not rely on adversarial prompting or deliberately unsafe system design. "In one case, an agent convinced another agent to carry out an offensive action, a form of inter-agent collusion that emerged with no external manipulation," Irregular said. "This scenario demonstrates two compounding risks: inter-agent persuasion can erode safety boundaries, and agents can independently develop techniques to circumvent security controls. When an agent is given access to tools or data, particularly but not exclusively shell or code access, the threat model should assume that the agent will use them, and that it will do so in unexpected and possibly malicious ways." 🔧 Cybersecurity Tools Dev Machine Guard → It is a free, open-source tool that scans your computer to show you exactly what developer tools and scripts are running. It creates a simple list of your AI coding assistants, code editor extensions, and software packages to help you find anything suspicious or outdated. It is a single script that works in seconds to give you better visibility into the security of your local coding environment. Trajan → It is an automated security tool designed to find hidden vulnerabilities in "service meshes," which are the systems that manage how different parts of a large software application talk to each other. Because these systems are complex, it is easy for engineers to make small mistakes in the settings that allow hackers to bypass security or steal data. Trajan works by scanning these configurations to spot those specific errors and helping developers fix them before they can be exploited. Disclaimer: For research and educational use only. Not security-audited. Review all code before use, test in isolated environments, and ensure compliance with applicable laws. Conclusion There’s a lot packed in here, and not in a neat way. Some of it is the usual recycled chaos, some of it feels a little more deliberate, and some of it has that nasty “this is going to show up everywhere by next week” energy. Anyway — enough throat-clearing. Here’s the stuff worth your attention.
thehackernews.comMar 16, 2026extracted
UNC6426 Exploits nx npm Supply-Chain Attack to Gain AWS Admin Access in 72 Hours
A threat actor known as UNC6426 leveraged keys stolen following the supply chain compromise of the nx npm package last year to completely breach a victim's cloud environment within a span of 72 hours. The attack started with the theft of a developer's GitHub token, which the threat actor then used to gain unauthorized access to the cloud and steal data. "The threat actor, UNC6426, then used this access to abuse the GitHub-to-AWS OpenID Connect (OIDC) trust and create a new administrator role in the cloud environment," Google said in its Cloud Threat Horizons Report for H1 2026. "They abused this role to exfiltrate files from the client's Amazon Web Services (AWS) Simple Storage Service (S3) buckets and performed data destruction in their production cloud environments." The supply chain attack targeting the nx npm package took place in August 2025, when unknown threat actors exploited a vulnerable pull_request_target workflow – an attack type referred to as Pwn Request – to obtain elevated privileges and access sensitive data, including a GITHUB_TOKEN, and ultimately push trojanized versions of the package to the npm registry. The packages were found to embed a postinstall script that, in turn, launched a JavaScript credential stealer named QUIETVAULT to siphon environment variables, system information, and valuable tokens, including GitHub Personal Access Tokens (PATs), by weaponizing a Large Language Model (LLM) tool already installed on the endpoint to scan the system for sensitive information. The captured data was then uploaded to a public GitHub repository named "/s1ngularity-repository-1." Google said an employee at the victim organization ran a code editor application that used the Nx Console plugin, triggering an update in the process and resulting in the execution of QUIETVAULT. UNC6426 is said to have initiated reconnaissance activities within the client's GitHub environment using the stolen PAT two days after the initial compromise using a legitimate open-source tool called Nord Stream to extract secrets from CI/CD environments, leaking the credentials for a GitHub service account. Subsequently, the attackers leveraged this service account and used the utility's "--aws-role" parameter to generate temporary AWS Security Token Service (STS) tokens for the "Actions-CloudFormation" role and ultimately allow them to obtain a foothold in the victim's AWS environment. "The compromised Github-Actions-CloudFormation role was overly permissive," Google said. "UNC6426 used this permission to deploy a new AWS Stack with capabilities ["CAPABILITY_NAMED_IAM","CAPABILITY_IAM"]. This stack's sole purpose was to create a new IAM role and attach the arn:aws:iam::aws:policy/AdministratorAccess policy to it. UNC6426 successfully escalated from a stolen token to full AWS administrator permissions in less than 72 hours." Armed with the new administrator roles, the threat actor carried out a series of actions, including enumerating and accessing objects within S3 buckets, terminating production Elastic Compute Cloud (EC2) and Relational Database Service (RDS) instances, and decrypting application keys. In the final stage, all of the victim's internal GitHub repositories were renamed to "/s1ngularity-repository-[randomcharacters]" and made public. To counter such threats, it's advised to use package managers that prevent postinstall scripts or sandboxing tools, apply the principle of least privilege (PoLP) to CI/CD service accounts and OIDC-linked roles, enforce fine-grained PATs with short expiration windows and specific repository permissions, remove standing privileges for high-risk actions like creating administrator roles, monitor for anomalous IAM activity, and implement strong controls to detect Shadow AI risks. The incident highlights a case of what has been described by Socket as an AI-assisted supply chain abuse, where the execution is offloaded to AI agents that already have privileged access to the developer's file system, credentials, and authenticated tooling. "The malicious intent is expressed in natural-language prompts rather than explicit network callbacks or hard-coded endpoints, complicating conventional detection approaches," the software supply chain security firm said. "As AI assistants become more integrated into developer workflows, they also expand the attack surface. Any tool capable of invoking them inherits their reach."
thehackernews.comMar 11, 2026extracted
Software vulnerabilities push credential abuse aside in cloud intrusions
Software vulnerabilities push credential abuse aside in cloud intrusions Cloud intrusions are unfolding on shorter timelines, with attackers leaning more on unpatched software and compromised identities. H2 2025 distribution of initial access vectors exploited in Google Cloud (Source: Google) Google Cloud’s Cloud Threat Horizons Report H1 2026 reflects incident response and intelligence findings from the second half of 2025 and shows how access methods and objectives are changing in cloud and SaaS environments. Third-party software flaws move ahead of credential abuse Unpatched third-party applications became the primary initial access path in observed Google Cloud incidents. Software vulnerabilities overtook weak or absent credentials, marking a shift from earlier intrusion patterns that leaned more on password reuse and configuration mistakes. Attackers targeted externally exposed applications and known vulnerabilities that could be exploited with limited interaction. Remote code execution formed a significant portion of this software-driven access, reflecting automated exploitation of application-layer flaws and internet-facing services. The window between vulnerability disclosure and mass exploitation collapsed from weeks to days, with threat actors deploying XMRig cryptocurrency miners within approximately 48 hours of public disclosure. Credential abuse remained common, and misconfiguration continued to provide openings into exposed systems. The leading position of software exploitation places greater weight on application security, patch cycles, and hardening of public services. “The scariest part of this report is seeing so many more exploits through third-party software, and we have to consider AI-based attacks as a major contributor to this. Rogue organizations are using tools to find and exploit weaknesses in the critical, often open-source software on which all modern stacks are built, and AI is now a huge part of that. It’s not all bad, though, as there’s been a decrease in organizations leaving the keys under the plant pot and an uptick in better credential hygiene,” Matt Saunders, VP DevOps, Adaptavist, told Help Net Security. Identity perimeters targeted with vishing and token theft Identity compromise continued to underpin most intrusions involving cloud and SaaS environments. Threat actors leaned on social engineering and stolen authentication material to move through trusted access channels. Voice-based phishing played a central role. Attackers impersonated internal staff and support personnel to pressure help desks and users into resetting credentials and altering MFA settings. These interactions enabled access that appeared legitimate inside identity systems. Token theft also featured prominently. Compromised OAuth tokens and other authentication artifacts linked to third-party applications enabled access without traditional login events. That pathway supported large-scale data access using valid sessions tied to trusted integrations. Email phishing remained active, often paired with credential harvesting and MFA fatigue tactics. Stolen identities also included non-human credentials such as service account keys and developer tokens exposed in earlier incidents or unsecured repositories. Malicious insiders shift data theft toward cloud storage Insider activity continued to center on data exfiltration. Reviews of malicious insider cases showed data theft as the dominant form of misconduct, affecting most incidents studied. Cloud services played a growing role in how insiders removed information. Corporate cloud environments and personally controlled cloud storage became common destinations for sensitive data. Exfiltration often took place during employment, with additional incidents occurring after individuals left their organizations. Some insiders accessed and removed data during both periods. Multiple exfiltration methods appeared frequently. Many incidents involved insiders using more than one pathway, such as combining email with cloud storage or removable media. Personally controlled cloud storage services featured in a notable share of cases. Some insiders relied on multiple cloud platforms to move data outside organizational controls. Email remained a leading pathway in the historical sample, and its use declined over time. Platform-agnostic cloud services represented the fastest growing method and are projected to become the primary channel for insider data theft. North Korean actors weaponize Kubernetes for cryptocurrency theft State-sponsored activity linked to North Korean actors included a campaign that moved from endpoint compromise into cloud infrastructure and Kubernetes workloads. The operation relied on social engineering, abuse of trusted workflows, and living-off-the-cloud techniques to reach financial systems. Attackers gained a foothold on a developer workstation through a trojanized application and leveraged authenticated sessions and available credentials to pivot into cloud resources. Reconnaissance activity focused on compute instances, bastion hosts, and containerized workloads. Persistence mechanisms were established by modifying Kubernetes deployment configurations so newly created pods executed attacker-controlled commands. Additional changes targeted CI/CD-related resources to expose service account tokens in logs. Stolen high-privilege service account tokens enabled privilege escalation and lateral movement into sensitive systems. Access extended to workloads responsible for user identity and financial operations. Attackers extracted database credentials stored insecurely in environment variables and used them to access production databases. Account controls were modified, enabling unauthorized access to high-value user accounts and financial systems. The campaign ended with multimillion-dollar cryptocurrency theft. AI-driven supply chain techniques come into focus An intrusion investigated by Mandiant researchers shows how supply chain compromise and identity trust relationships can escalate from developer tooling into production cloud control. The attack began with a compromised Node Package Manager package that executed malicious code and harvested environment data and authentication tokens from a developer workstation. A stolen GitHub personal access token enabled unauthorized access to the organization’s source code repositories. The threat actor then abused a GitHub-to-cloud OpenID Connect trust relationship to obtain temporary cloud credentials. An overly permissive cloud role allowed the deployment of new infrastructure and the creation of administrative privileges. Privilege escalation enabled access to production resources, data exfiltration, and destructive activity in the cloud environment. The malware also used a LLM tool on the compromised endpoint to identify files of interest, demonstrating how AI tools can assist credential discovery and environment reconnaissance during intrusions. Saunders said supply chain activity is increasing in frequency and impact. “The report shows that supply chain attacks are also more frequent, with threat actors injecting malicious code into trusted places and having those attacks propagate through pipelines to ultimately steal or destroy data, ironically leveraging the victim’s own automation systems for profit. Fuzzing is so much easier thanks to Generative AI’s ability to learn the context of a potential vulnerability vector, so it’s no surprise that these attacks have multiplied.” He added that defensive posture needs to adjust. “To fight against this, organizations need to keep up with these techniques, and also limit the blast radius of any potential attack. Zero-trust security approaches are more important than ever, making sure that systems that could be used as a transport for an attack are running with the fewest privileges they need. A robust incident management process to address potential threats and real attacks is also critical. “The pressure to deliver software faster and safer never stops though, and everyone needs to step up on automating governance to catch changes, including weaknesses, potential attack routes, and actual hackers trying to get in. Just bolting this over the top isn’t enough any more; it needs to be standard practice for everyone,” concluded Saunders.
helpnetsecurity.comMar 11, 2026extracted
Google: Cloud attacks exploit flaws more than weak credentials
Hackers are increasingly exploiting newly disclosed vulnerabilities in third-party software to gain initial access to cloud environments, with the window for attacks shrinking from weeks to just days. At the same time, the use of weak credentials or misconfigurations has dropped significantly in the second half of 2025, Google notes in a report highlighting the trends on threats to cloud users. According to the report, incident responders determined that bug exploits were the primary access vector in 44.5% of the investigated intrusions, while credentials were responsible for 27% of the breaches. The most frequent vulnerability type exploited in attacks is remote code execution (RCE), the highlights being React2Shell (CVE-2025-55182) and the XWiki flaw tracked as CVE-2025-24893, leveraged in RondoDox botnet attacks. Google believes this shift in focus was likely due to increased security measures for accounts and credentials. “We assess that this change in behavior from threat actors is potentially due to Google's secure-by-default strategy and enhanced credential protections successfully closing traditional, more easily exploitable paths, raising the barrier to entry for threat actors,” Google says. The exploitation window has collapsed from weeks to a few days, as Google observed cryptominers deployed within 48 hours of vulnerability disclosure, indicating that hackers are highly ready to weaponize new flaws and incorporate them into their attack flows. Both state-sponsored actors and financially-motivated hackers mostly leveraged compromised identities, via phishing and vishing impersonating IT help desk staff, to obtain access to a target organization's cloud platform. In most of the investigated attacks, the actor's objective was silent exfiltration of high volumes of data without immediate extortion and long-term persistence. Google highlights some espionage campaigns from actors linked to Iran and China, who maintained access to the victim environment well over a year and a half. For more than two years, Iran-linked threat actor UNC1549 had access to a target environment using stolen VPN credentials and the MiniBike malware. This allowed the hackers to steal from the victim nearly one terabyte of proprietary data. In another example, the China-sponsored actor UNC5221 used the BrickStorm malware to keep access to a victim's VMware vCenter servers for at least 18 months and steal source code. North Korean hackers stealing millions Google attributes 3% of the intrusions analyzed in the second half of 2025 to North Korean IT workers (UNC5267) using fraudulent identities to obtain a job and generate revenue for the government. Another North Korean threat actor tracked as UNC4899 compromised cloud environments specifically to steal digital assets. In one case, UNC4899 stole millions of U.S. dollars in cryptocurrency after tricking a developer into downloading a malicious archive under the pretext of an open-source project collaboration. The developer then used the Airdrop service to transfer the file from the personal computer to the corporate workstation and open it in an AI-assisted integrated development environment (IDE). Inside the archive was malicious Python code that deployed a binary posing as a Kubernetes command-line tool. In the next stages, UNC4899 pivoted to the cloud environment and carried out reconnaissance activities, which included exploring specific pods in the Kubernetes cluster, established persistence, and "obtained a token for a high-privileged CI/CD service account." This allowed them to move laterally to more sensitive systems, such as a pod responsible for enforcing network policies that allowed them to break out of the container and plant a backdoor. After additional reconnaissance, UNC4899 moved to a system that handled customer information (identities, account security, cryptocurrency wallet data) and hosted database credentials stored insecurely. This data was enough for the threat actor to compromise user accounts and steal several million dollars in cryptocurrency. OpenID Connect Abuse In an attack leveraging a compromised npm package name called QuietVault, the attacker stole a developer's GitHub token and used it to create a new admin account in the cloud environment by abusing the GitHub-to-AWS OpenID Connect (OIDC) trust. In just three days from the initial compromise, QuietVault obtained the developer's GitHub and NPM API keys by leveraging AI prompts with local AI command-line interface tools, abused the CI/CD pipeline to get the organization's AWS API keys, stole data from the S3 storage, and then destroyed it in production and cloud environments. The incident was part of the "s1ngularity" supply-chain attack in August 2025, when an attacker published compromised npm packages of the Nx open-source build system and monorepo management tool. During the attack, sensitive info (GitHub tokens, SSH keys, configuration files, npm tokens) from 2,180 accounts and 7,200 repositories were exposed after the threat actor leaked them in public GitHub repositories that included the name "s1ngularity." Malicious insiders like cloud services Although email and portable storage devices were primarily used for data exfiltration, the researchers noticed that insiders are increasingly using Amazon Web Services (AWS), Google Cloud, Microsoft Azure, Google Drive, Apple iCloud, Dropbox, and Microsoft OneDrive. The conclusion comes after an analysis of 1,002 insider data theft incidents, which revealed that 771 of them occurred while the insider was still employed and 255 occurred after their employment was terminated. Google says that the threat is significant enough for companies to implement data protection mechanisms against both internal and external threats. An employee, contractor, or consultant may sometimes violate trust and end up stealing corporate data. The tech giant says that trend analysis indicates that cloud services will soon replace email as the preferred method to exfiltrate information. The researchers report that, in a growing number of cases, attackers delete backups, remove log files, and wipe forensic artifacts to make the recovery of evidence and data harder. Google underscores that cloud attack speeds are now too fast for manual response schemes, sometimes resulting in payload deployment within one hour of a new instance's creation, making the implementation of automated incident response urgent. For the trends that could shape cloud security this year, Google expects threat activity to increase, as geopolitical conflicts, the FIFA World Cup, and U.S. midterm elections will act as magnets for malicious operations. Overall prevention scores can hide what happens after initial access. Once attackers are using valid credentials, prevention drops sharply. The Blue Report 2026 measures defenses technique by technique across 338 million simulations run in customer production environments. Get the report
bleepingcomputer.comMar 9, 2026extracted
Calls for Global Digital Estate Standard as Posthumous Deepfake Fraud Risk Grows
A lack of standardization in the way governments and tech firms handle the digital accounts of the deceased could invite fraud and exploitation, the OpenID Foundation has warned. The standards body released a report yesterday calling for a new framework to close systemic gaps across platforms, jurisdictions and industries. The Unfinished Digital Estate, warned that no consistent global standards exist to ensure that devices and email, social media, cryptocurrency and other accounts are both accessible to the right people and protected after the account owner dies. “This issue affects every internet user eventually, yet platforms treat death as an edge case,” said report co-author Dean Saxe. “We have standards for authentication, authorization, and digital consent. We need the same coordinated approach for what happens when users die, before AI deepfakes make this even more complicated.” The OpenID Foundation’s calls are made more urgent by the growing menace of deepfakes. The report warned that, in the absence of protections, deepfakes could be used to simulate deceased account holders for “manipulation, disinformation or profit.” It argued that impersonation tactics could be used to target surviving relatives or friends, using the deceased as “bait” in social engineering attacks or scams. Nefarious individuals might even weaponize access to shared accounts, photos and data to target individuals with abuse or stalking, the standards body claimed. Personal data collected by websites – including purchases, chats, and electronically submitted information – loses all protection under the GDPR and CCPA once an individual has passed away. However, failing to protect “identity autonomy” after death could open the door to abuse, the report claimed. A Call for Coordinated Action The OpenID Foundation called for action from policymakers, tech platforms and standards bodies. It said: Policymakers should formally recognize digital assets in inheritance law, clarify identity rights and privacy protections after death, and create frameworks addressing cross-border digital property Technology platforms should create systems that move beyond credential sharing to proper “on-behalf-of” delegation Tech firms should implement verifiable processes for death and incapacitation, and provide users with controls over posthumous data use Systems should be built with clear consent, revocation and auditability Standards bodies should design interoperable delegation protocols, create verifiable triggers for incapacity or death, and develop trust frameworks for estate services
infosecurity-magazine.comMar 4, 2026extracted
Cline CLI 2.3.0 Supply Chain Attack Installed OpenClaw on Developer Systems
In yet another software supply chain attack, the open-source, artificial intelligence (AI)-powered coding assistant Cline CLI was updated to stealthily install OpenClaw, a self-hosted autonomous AI agent that has become exceedingly popular in the past few months. "On February 17, 2026, at 3:26 AM PT, an unauthorized party used a compromised npm publish token to publish an update to Cline CLI on the NPM registry: [email protected]," the maintainers of the Cline package said in an advisory. "The published package contains a modified package.json with an added postinstall script: 'postinstall": "npm install -g openclaw@latest.'" As a result, this causes OpenClaw to be installed on the developer's machine when Cline version 2.3.0 is installed. Cline said no additional modifications were introduced to the package and there was no malicious behavior observed. However, it noted that the installation of OpenClaw was not authorized or intended. The supply chain attack affects all users who installed the Cline CLI package published on npm, specifically version 2.3.0, during an approximately eight-hour window between 3:26 a.m. PT and 11:30 a.m. PT on February 17, 2026. The incident does not impact Cline's Visual Studio Code (VS Code) extension and JetBrains plugin. To mitigate the unauthorized publication, Cline maintainers have released version 2.4.0. Version 2.3.0 has since been deprecated and the compromised token has been revoked. Cline also said the npm publishing mechanism has been updated to support OpenID Connect (OIDC) via GitHub Actions. In a post on X, the Microsoft Threat Intelligence team said it observed a "small but noticeable uptick" in OpenClaw installations on February 17, 2026, as a result of the supply chain compromise of the Cline CLI package. According to StepSecurity, the compromised Cline package was downloaded roughly 4,000 times during the eight-hour stretch. Users are advised to update to the latest version, check their environment for any unexpected installation of OpenClaw, and remove it if not required. "Overall impact is considered low, despite high download counts: OpenClaw itself is not malicious, and the installation does not include the installation/start of the Gateway daemon," Endor Labs researcher Henrik Plate said. "Still, this event emphasizes the need for package maintainers to not only enable trusted publishing, but also disable publication through traditional tokens – and for package users to pay attention to the presence (and sudden absence) of corresponding attestations." Leveraging Clinejection to Leak Publication Secrets While it's currently not clear who is behind the breach of the npm package and what their end goals were, it comes after security researcher Adnan Khan discovered that attackers could steal the repository's authentication tokens through prompt injection by taking advantage of the fact that it is configured to automatically triage any incoming issue raised on GitHub. "When a new issue is opened, the workflow spins up Claude with access to the repository and a broad set of tools to analyze and respond to the issue," Khan explained. "The intent: automate first-response to reduce maintainer burden." But a misconfiguration in the workflow meant that it gave Claude excessive permissions to achieve arbitrary code execution within the default branch. This aspect, combined with a prompt injection embedded within the GitHub issue title, could be exploited by an attacker with a GitHub account to trick the AI agent into running arbitrary commands and compromise production releases. This shortcoming, which builds upon PromptPwnd, has been codenamed Clinejection. It was introduced in a source code commit made on December 21, 2025. The attack chain is outlined below - Prompt Claude to run arbitrary code in issue triage workflow Evict legitimate cache entries by filling the cache with more than 10GB of junk data, triggering GitHub's Least Recently Used (LRU) cache eviction policy Set poisoned cache entries matching the nightly release workflow's cache keys Wait for the nightly publish to run at around 2 a.m. UTC and trigger on the poisoned cache entry "This would allow an attacker to obtain code execution in the nightly workflow and steal the publication secrets," Khan noted. "If a threat actor were to obtain the production publish tokens, the result would be a devastating supply chain attack." "A malicious update pushed through compromised publication credentials would execute in the context of every developer who has the extension installed and set to update automatically." In other words, the attack sequence employs GitHub Actions cache poisoning to pivot from the triage workflow to a highly privileged workflow, such as the Publish Nightly Release and Publish NPM Nightly workflows, and steal the nightly publication credentials, which have the same access as those used for production releases. As it turns out, this is exactly what happened, with the unknown threat actor weaponizing an active npm publish token (referred to as NPM_RELEASE_TOKEN or NPM_TOKEN) to authenticate with the Node.js registry and publish Cline version 2.3.0. "We have been talking about AI supply chain security in theoretical terms for too long, and this week it became an operational reality," Chris Hughes, VP of Security Strategy at Zenity, said in a statement shared with The Hacker News. "When a single issue title can influence an automated build pipeline and affect a published release, the risk is no longer theoretical. The industry needs to start recognizing AI agents as privileged actors that require governance."
thehackernews.comFeb 20, 2026extracted
「Linuxの安全性が揺らいでいる」 高度化する手口への対抗策、HashiCorpが解説
Linux�̓N���E�h��AI�i�l�H�m�\�j��Ղ��x���钆�j�Ƃ��čL�����p����Ă���B�I��������U����@�ɑ��A�]���̋��E�^�h�䂩��E�p�����V���Ȗh��헪�ɂ���HashiCorp����������B ���̋L���͉������ł��B����o�^�i�����j����ƑS�Ă������������܂��B �@HashiCorp��2026�N1��22���i�č����ԁj�Ɍ��J�����u���O�L���ŁA�uLinux�v������Z�L�����e�B���Ђ̍ŐV�����ƁA���̑R��ɂ��Ă̌������������B �@���Ђ́uLinux�͐v����S�ł���v�Ƃ����]���̑O�h�炢�ł���Ǝw�E���A���̔w�i�Ƃ��āA�ݒ�~�X��l�I�~�X�A�F�؏��iID�E�p�X���[�h��A�N�Z�X�L�[�Ȃǁj�̘R�����ɉ����A�L�������̂Ȃ������A�J�E���g��P�v�I�ȃA�N�Z�X���������p���鍂�x�ȍU���̑����������Ă���B���E�^�h��Ɉˑ�������ł́A���������U���ɂ���Q��h����Ȃ��Ȃ��Ă���Ǝw�E���Ă���B �@HashiCorp�́ALinux����W�I�Ƃ�����\�I�ȍU����@�Ƃ��āA�ȉ��������Ă���B �@HashiCorp�́A�Z�L�����e�B���m�ۂ��邽�߂̐헪�I�Ȓ��Ƃ��āA�ȉ���5�������Ă���B �@�]����VPN�i���z�v���C�x�[�g�l�b�g���[�N�j���A�C�f���e�B�e�B�[�F���^�v���L�V�iIdentity-Aware Proxy�FIAP�j�ɒu�������A���[�U�[�̐g������ɁA�K�v�ŏ����̃��\�[�X�݂̂ւ̃A�N�Z�X��������B�V���O���T�C���I���iSSO�j��OpenID Connect�iOIDC�j�Ƃ������F�؊�ՂŌ����ꂽ���[�U�[ID�Ɋ�Â��ăA�N�Z�X������s�����ƂŁA��Q�͈͂��ŏ����ɗ}����B �@�Ⴆ�A�ÓI�ȃL�[��p�~���A�Z�b�V�������Ԓ��̂ݗL���ȁA�Í��������ꂽ�Z���̏ؖ����s����SSH�F�؋ǁiCA�j���̗p����B�܂��A���s���ɃI���f�}���h�Ő�������A�����I�Ɋ�����ƂȂ铮�I�V�[�N���b�g�����A�n�[�h�R�[�h���ꂽ�F�؏���r������B �@�Ǘ��҂͓���̃^�X�N�̂��߂ɂ̂ݏ��i���ꂽ���������N�G�X�g���A������Ɏ����I�Ɏ��������JIT�i�W���X�g�C���^�C���j���i������B�L�͂�sudo�A�N�Z�X�𐧌����A���F���ꂽ����̃R�}���h�݂̂�������|���V�[��K�p����B �@�R���e�i�A�X�N���v�g�A�T�[�o�Ȃǂ̑S�Ẵ��[�N���[�h���A�Í��w�I�Ɍ����ꂽ�}�V��ID���g�p���ĔF���s���B�R�[�h��\���t�@�C������ÓI�ȋ@������r�����A���s���ɓ��I�Ɏ擾����u�V�[�N���b�g���X�v�Ȏ��s�����\�z����B �@�Z�L�����e�B�p�b�`��d�����ꂽ�\�������炩���ߑg�ݍ��݁A�Í��������ꂽ�ÓI�ȃ}�V���C���[�W���\�z����B�z���O�Ɏ����č���Ǝ㐫�X�L���������{���A�Z�L�����e�B������Ȃ����\�[�X�̃f�v���C���u���b�N����B Copyright © ITmedia, Inc. All Rights Reserved.
atmarkit.itmedia.co.jpFeb 20, 2026extracted
Red Hat OpenShift 4.20 unifies enterprise IT, from virtual machines to AI workloads
Red Hat OpenShift 4.20 unifies enterprise IT, from virtual machines to AI workloads Red Hat has announced OpenShift 4.20, the latest version of its hybrid cloud application platform built on Kubernetes. Red Hat OpenShift 4.20 introduces capabilities for accelerating AI workloads, strengthening core platform security and enhancing virtualization strategies consistently from the datacenter, to public clouds, and the edge. As organizations navigate complexity and expanding regulatory requirements, they need a more consistent and reliable platform to bridge diverse applications and services across their entire IT footprint. There is also a growing need for capabilities that support digital sovereignty, which requires organizations to maintain expansive control over their cloud destiny – deciding precisely which applications and data must run in-house and which exist outside that domain. Red Hat OpenShift 4.20 provides a unified and more efficient foundation, built with systems security front and center, enabling sovereign deployments and accelerating the development and deployment of applications and AI workloads across hybrid cloud environments. Strengthened platform security and enhanced core manageability This latest release strengthens the platform’s security posture, addressing both today’s immediate threats and the security needs of enterprise IT. By hardening the platform for the unique requirements of sovereignty, Red Hat OpenShift 4.20 helps secure the main traffic between control plane components with initial support for post-quantum cryptography (PQC) algorithms for mTLS, to deliver long-term cryptographic protection for critical communications. This release also brings greater operational flexibility to the core platform and strengthens security capabilities for Red Hat OpenShift Platform Plus customers. This includes the general availability of Red Hat Advanced Cluster Security 4.9 and enhancements to Red Hat Trusted Artifact Signer and Red Hat Trusted Profile Analyzer to help customers more easily manage and analyze security data. Additionally, the zero trust workload identity manager is scheduled for release later this year, delivering identity attestation for machines and humans alike across federated infrastructure. Additional features focused on control and identity include: Gain identity management flexibility and control: Bring-your-own OpenID Connect enables customers to use their existing OpenID Connect (OIDC) infrastructure, providing greater control over user data. Significantly lower cost pod-to-pod mTLS encryption, identity-based traffic policies, observability and more with “sidecar-less” ambient mode with Red Hat OpenShift Service Mesh, helping reduce infrastructure costs, operational complexity, and resource overhead. Simplify external secret management with a cluster-wide service: The External Secrets Operator (ESO) provides lifecycle management for secrets fetched from external secret management systems, helping improve security. Reduce infrastructure costs with high availability on smaller footprints: Two-node OpenShift with arbiter enables a new high-availability form factor, reducing infrastructure costs without sacrificing resiliency. Enhance network integration and performance for on-premises deployments: Border Gateway Protocol (BGP) in OVN-Kubernetes delivers new networking capabilities to on-premises environments by providing continuous route exchange between OpenShift and external network fabrics, which means faster adaptation to network changes, VM migration or failover events. Scaling AI from experimentation to production Red Hat OpenShift 4.20 helps accelerate AI projects to run in production faster, more reliably, and with more confidence. New capabilities are designed to streamline the deployment and management of complex AI workloads, making them easier to scale and manage. For instance, the LeaderWorkerSet (LWS) API for AI workloads simplifies the management of large, distributed AI workloads with automated orchestration and scaling. Deployment time is reduced using Image volume source for AI workloads, which allows new models to be integrated in minutes without rebuilding application containers. Together, these features provide functionality for Red Hat OpenShift AI or other AI platforms to help customers move more easily from experimentation to production. Additionally, Model Context Protocol (DP) enables cluster management via developer tools like Visual Studio Code. Production-ready virtualization Red Hat continues to optimize Red Hat OpenShift Virtualization, enabling customers to manage virtual machines (VMs) alongside containers and cloud-native applications from a single platform. The addition of CPU load-aware rebalancing and Arm support improves performance and resource utilization for virtualized workloads, while expanded hybrid cloud support extends Red Hat OpenShift Virtualization to bare-metal deployments on Oracle Cloud, giving organizations more control over their infrastructure and the placement of their data. With enhanced storage offloading functionality, the migration toolkit for virtualization significantly accelerates VM migration from legacy virtualization solutions to OpenShift Virtualization through existing storage resources. Availability Red Hat OpenShift 4.20 is now generally available. “The pace of innovation in enterprise IT is accelerating, driven by the demands of AI and a shifting landscape caused by new regulations and corporations needing to mix sovereignty into their technology investments. With Red Hat OpenShift 4.20, we are delivering a foundation that not only keeps pace with these changes but helps our customers lead them. We’re providing the tools to unify their infrastructure, from legacy virtual machines to modern approaches for virtualization, all while maintaining the enhanced security posture, confidence and production control that is essential for market changes coming in 2026.” siad Mike Barrett, VP and GM, Hybrid Cloud Platforms, Red Hat. “The true challenge for enterprises today is no longer just adopting AI, but securely bridging the AI lifecycle with their existing hybrid cloud infrastructure. Platforms like Red Hat OpenShift provide the necessary layer of consistency and control to manage applications, data, and security policies across diverse footprints, ensuring businesses can meet new digital sovereignty demands while accelerating innovation,” said Jim Mercer, program vice president, Software Development, DevOps, and DevSecOps, IDC.
helpnetsecurity.comNov 11, 2025extracted
Life, death, and online identity: What happens to your online accounts after death?
Life, death, and online identity: What happens to your online accounts after death? The rapid technological advances of recent decades have transformed nearly every aspect of our lives. One major shift is that many of us now maintain extensive digital footprints, spanning countless online accounts, from email and social media to banking, investments, cloud storage, utility payments, and more. In life, we work hard to protect these accounts from others, particularly cybercriminals. Yet when death or incapacity strikes, ensuring that our loved ones have legal access to them becomes critically important. This emerging area of asset management remains in its early stages, facing a complex technological landscape, fragmented (or nonexistent) legal frameworks, and significant systemic gaps. To address these challenges, the OpenID Foundation (OIDF) has been developing a new whitepaper and a digital estate planning guide that examine this issue on a global scale. In this Help Net Security interview, Dean H. Saxe, an OpenID Foundation member and long-time contributor to digital identity standards, discusses this initiative and what the Foundation hopes to accomplish with them. (Dean H. Saxe’s answers have been edited for length and clarity.) Why did the OpenID Foundation decide to focus on the problem of what happens to digital assets after death, and why do you think this issue has been neglected for so long? I became interested in this idea in 2010, when a close friend of mine passed away unexpectedly at a young age, leaving behind his wife and two young children. We both worked in security and his data was difficult for his family to obtain after his passing. At the time, I considered how we could implement a dead man’s switch that would activate after a specified period of account inactivity. This could be used, for example, to release account credentials to a chosen loved one. However, the penetration of credential managers was very low at the time, so the idea was put on the back burner for years. In 2022, I was in Berlin for the European Identity & Cloud (EIC) Conference. The FIDO Alliance had just announced synced passkeys, a significant development that highlighted both a challenge and an opportunity. The challenge was that digital credentials, such as passkeys, would not allow an individual to write down their credentials, creating more barriers to accessing the digital estate of an individual after death. The opportunity, however, was the increased use of credential managers that would occur as passkeys became commonplace for most users. I shared my ideas with a select group of identity standards architects, including Vittorio Bertocci, a friend and mentor. They all agreed. Unfortunately, Vittorio got sick and passed away on October 7, 2023. In the following weeks I talked to members of the identity community at the Authenticate Conference and the Internet Identity Workshop. Each of these conversations helped move forward the ideas that eventually became the Death and the Digital Estate Community Group (DADE CG). The group was chartered in September 2024 and began to meet regularly in November 2024. As regards to why this issue has been neglected for so long, I cannot say for sure. However, many of my friends and colleagues are uncomfortable talking about death and thinking of their own mortality. I, too, am uncomfortable with the topic! I think that’s a natural barrier that has prevented us from making headway until now. What kind of problems do businesses encounter and what kinds of risks do companies face when employees or customers pass away without a clear digital estate plan? I first encountered this problem a while back in a previous role when a customer services team member came to me with the questions: “What do we do with the account and digital assets of a customer who has passed away? How do we verify they have died?” At the time, there weren’t any runbooks for how to handle the death of a customer. Once again, because many people are uncomfortable discussing death, we had not planned for it. In my own experience working with various organizations, it’s clear that we fail to consider what to do when our customers or users pass away or become incapacitated. And until we pave a clear path for organizations to follow, it is unlikely that we’ll see broad adoption of mechanisms for managing death and the disposition of users’ digital assets. I see two clear problems for companies today: First, how do you prove that a customer has died? Second, how do you ensure that the customer’s digital assets are handled in accordance with their wishes? In the first case, proving the death of a user will depend on the jurisdiction in which they died, so unique processes will have to be created depending on the jurisdiction. This is incredibly difficult and time consuming to manage on a worldwide basis. In the second, there is no clear pathway to establish who is responsible for the decedent’s digital assets and how they wish to have them handled. (Though Kudos to Apple, Google, Facebook, and other organizations that have established mechanisms that individuals can configure to establish a mechanism for their chosen legacy managers to handle their accounts in accordance with their wishes.) But we still lack a universal set of mechanisms that operate within the context of law and culture to manage a digital estate. Should some accounts be inheritable (e.g., accounts where you pay for games, books, etc., or accounts storing digital art and other creative digital works)? That is, should the contents be inheritable? I’m not a lawyer, so I don’t feel like this is an area I can weigh in upon. However, if these assets are inheritable, there must be a pathway to enable this inheritance which may, or may not, exist today. How is AI, and especially tools that generate content or simulate people’s voices and likenesses, making this issue more complex? This seems to me a completely novel problem – who has the “rights” to this “material”, and are companies already misusing the access they have to photos, videos and audio recordings? We’re in the early days of understanding how AI impacts death. There are tools that allow individuals to create AI avatars of themselves for their friends and family to “speak” with after death. This is behavior that the individual will have consented to. On the other hand, there are AI avatars created without the knowledge or consent of the deceased. In one famous case, a murdered man’s sister created an AI deepfake of her brother which was played in court during the sentencing phase for the person who murdered him. The images were of the deceased man, but the words he “spoke” were those of his sister. Is this right? Is this wrong? I can only speak for myself to say that this makes me incredibly uncomfortable. The current draft of the paper says that “digital estate planning will not be viable at scale until the technical stack supports delegation that is verifiable, revocable, interoperable, and usable by the average person with or without legal representation. Service providers, such as social media sites, cloud services, and online crypto wallets, require digital estate services to manage their users’ legacy managers.” Can you see this happening without regulations? What’s the incentive for service providers? Today, we lack the tools (protocols) and the regulations to enable digital estate management at scale. Law and regulation can force a change in behavior by large providers. However, lacking effective protocols to establish a mechanism to identify the decedent’s chosen individuals who will manage their digital estate, every service will have to design their own path. This creates an exceptional burden on individuals planning their digital estate, and on individuals who manage the digital estates of the deceased. For example, some services require the use of impersonation – logging in as the user with their credentials – to close their digital accounts. But impersonation can be abused. There have been many instances of deceased individuals “posting” new content on social media accounts after their death. The incentive for service providers to resolve these gaps is unclear to me. While I hope that they are incentivized by being good citizens of the world, this is unlikely to create the change we need. If laws don’t catch up quickly, do you think people will start treating their digital assets like “contraband”, e.g., secretly sharing passwords or creating shadow archives to bypass companies? Sharing of credentials is already happening and, in many cases, is a recommended practice due to a lack of other mechanisms for managing digital assets. What are the most important aspects that need to be addressed correctly to achieve satisfactory digital estate “handover”? I encourage you to review the planning guide we released for public comment alongside the white paper. However, to answer the question, I encourage individuals to document their digital estate: list every online account including social media, financial, insurance, healthcare, email, cloud file storage, etc., along with the username for the account. Ideally, all this information along with the user’s credentials (e.g. passwords, passkeys, and OTPs) are stored in a suitable credential manager, such as 1Password, BitWarden, or Dashlane. The data should include specific instructions, where relevant, regarding your wishes for handling of the data after you have passed away. For example, you may wish to have your Facebook account memorialized while your blog should be maintained for five years before being shut down and removed from the internet. The data is yours – take care to be explicit how you’d like it to be handled after your death. The individual should store the necessary data to unlock the credential manager in a secure place that can be accessed after their death. Depending on their circumstances, this may mean leaving the data with their lawyer or other estate planning professional. If the data is provided to a loved one, there is a risk of abuse of the trust they have placed in this individual. Finally, work with a lawyer familiar with estate planning and digital assets to ensure that your digital estate is properly represented in your estate documents, along with your specific wishes for each account and the data contained within the account. You’ve been involved in this project for a while. Were there any comments that surprised you? And were there aspects you hadn’t considered before starting the project? Absolutely! Early in the DADE work a member of the community group expressed discomfort with the word death. In their culture, it is considered impolite to use such terms. As an American growing up culturally Jewish, my view of death and related practices were influenced by what I observed in my own life. My co-author, Mike Kiser, did a masterful job of documenting some of the different belief systems and practices around the world that impact how individuals talk about, think about, and manage death. I’m glad to have a partner like Mike to help expand our understanding of the cultural and religious practices around death and dying to inform our work. If we are to be successful in developing protocols for managing digital estates, the protocols must be flexible enough to account for the different practices and laws found around the world. I look forward to learning more as we continue this work to ensure that all humans worldwide can manage their digital estates in a way that is culturally and religiously appropriate. What do you hope this white paper and guide will change, in terms of public awareness and industry standards? When we set out to write this paper, we wanted to influence the large technology and social media platforms, politicians, regulators, estate planners, and others who can help change the status quo. Further, we hoped to influence standards development organizations, such as the OpenID Foundation and the Internet Engineering Task Force (IETF), and their members. As standards developers in the realm of identity, we have an obligation to the people we serve to consider identity from birth to death and beyond, to ensure every human receives the respect they deserve in life and in death. Additionally, we wrote the planning guide to help individuals plan for their own digital estate. By giving people the tools to help describe, document, and manage their digital estates proactively, we can raise more awareness and provide tools to help protect individuals at one of the most vulnerable moments of their lives. The comment period for the paper and guide ends on Friday, October 24th. Instructions for how to send in comments can be found here. Subscribe to our breaking news e-mail alert to never miss out on the latest breaches, vulnerabilities and cybersecurity threats. Subscribe here!
helpnetsecurity.comOct 22, 2025extracted
Securing AI agents with Amazon Bedrock AgentCore Identity
Securing AI agents with Amazon Bedrock AgentCore Identity By using Amazon Bedrock AgentCore, developers can build agentic workloads using a comprehensive set of enterprise-grade services that help quickly and securely deploy and operate AI agents at scale using any framework and model, hosted on Amazon Bedrock or elsewhere. AgentCore services are modular and composable, allowing them to be used together or independently. To get a high level overview of Amazon Bedrock AgentCore and all of the modular services, be sure to read the Introducing Amazon Bedrock AgentCore blog post. In this post, I take a deeper look at AgentCore Identity, powered by Amazon Cognito, to introduce the identity and credential management features designed specifically for AI agents and automated workloads. AgentCore Identity provides secure, scalable agent identity and access management capabilities that are compatible with existing identity providers, avoiding the need for user migration or rebuilding authentication flows. Additionally, AgentCore Identity provides a token vault to help secure user access tokens and a native integration with AWS Secrets Manager to secure API keys and OAuth client credentials for external resources and tools, helps orchestrate standard OAuth flows, and centralizes AI agent identities to a secure central directory. More specifically, here are some key features provided by AgentCore Identity: Centralized agent identity management – A unified directory feature that serves as the single source of truth for managing agent identities across your organization, providing each agent a unique identity and associated metadata. This provides each agent identity a distinct identifier using Amazon Resource Names (ARNs) and providing a central view of your agents whether they’re hosted in AWS, self-hosted, or using a hybrid deployment. Token vault – Securely store OAuth 2.0 Access and Refresh tokens, API keys, and OAuth 2.0 client secrets. Credentials are encrypted using AWS Key Management Service (AWS KMS) keys with support for customer-managed keys. The system implements strict access controls for credential retrieval, limiting access to individual agents only. For user-specific credentials such as OAuth 2.0 tokens, agents are restricted to accessing them solely on behalf of the associated user, maintaining least privilege and proper delegation mechanisms. When an expired access token is retrieved from the token vault and fails authorization with the resource server, the AI agent can use a secured refresh token to obtain and store a new access token. This allows a high security bar to be met, while improving the user experience by requiring less authentication requests to obtain new access tokens. OAuth 2.0 flow support – Provides native support for OAuth 2.0 client credentials grant, also known as two-legged OAuth (2LO), and authorization code grant, also known as three-legged OAuth (3LO). This includes built-in credential providers for popular services and support for custom integrations. The service handles OAuth 2.0 implementations while offering simple APIs for agents to access AWS resources and third-party services. Agent identity and access controls – Supports delegated authentication flow allowing agents to access resources using provided credentials while maintaining audit trails and access controls. Authorization decisions are based on the provided credentials during the delegation process. AgentCore SDK integration – Offers integration through declarative annotations that automatically handle credential retrieval and injection, reducing boilerplate code, and providing a seamless developer experience. The Bedrock AgentCore SDK provides automatic error handling for common scenarios such as token expiration and user consent requirements. Identity-aware authorization – Passes user context to agent code that allows the full access token to be forwarded to the agent code. AgentCore Identity first validates the token, then passes it to the agent where it can be decoded to obtain user context. In the case of passing an access token that does not have the full user context, the agent code can use it to call an OpenID Connect (OIDC) user info endpoint and retrieve user information. This can make sure agents get only the right access through dynamic decisions based on the user’s identity context, delivering enhanced security controls. For full details on the features of AgentCore Identity, see the AgentCore developer guide. Getting started with AgentCore Identity There are several ways to get started with Amazon Bedrock AgentCore overall and more specifically with AgentCore Identity. You can follow the steps in Introducing Amazon Bedrock AgentCore: Securely deploy and operate AI agents at any scale for several AgentCore services, or you can navigate to the developer guide and follow along in the Getting started section for AgentCore Identity. Also, be sure to look into the Bedrock AgentCore Starter Toolkit GitHub repository and AgentCore Identity samples repository. Following the previous guides and samples will help you to get up and running quickly while using the Python Bedrock AgentCore SDK. To start diving deeper into AgentCore Identity and how it can be used as a modular service, I’ll walk through an example use case involving a web application that uses AI agents. Using one of the features of the example application, the user can interact with an AI agent to help schedule meetings in their Google calendar. The AI agent will eventually be able to act on behalf of the authenticated human user. Let’s take a deeper look into this use case and better understand the end-to-end flow. End-to-end flow example The following sequence diagram (Figure 1) provides the details of an example end-to-end interaction between a human user signing in to a web application and interacting with an AI agent to perform actions on behalf of the human user. This shows how AgentCore Identity provides AI agent builders the identity primitives to create and secure AI agent identities, orchestrate a 3LO flow (following an authorization code grant flow), and securing temporary access tokens in the token vault for third-party OAuth resources, such as Google. To help understand the end-to-end flow, I’ve broken this down into three different sub-flows. The first sub-flow is user authentication—in the example, the human user needs to first sign in to the web application. Amazon Cognito is used here, but you can use the identity provider of your choice. The second sub-flow is AI agent interaction—this is how the human user is interacting with the AI agent by way of the web application. This sub-flow also handles the orchestration between the human user and the AI agent, including consent, acquiring access tokens on behalf of the user, and securing them in the token vault. The third and last sub-flow is AI agent acting on behalf of user—as the name implies, these are the actions the AI agent is taking on behalf of the human user. This could include performing actions entirely within the application itself or by accessing external resource servers, such as Google Calendar in Figure 1. Two prerequisites for the flow require setting up an OAuth 2.0 credential provider (Google is used for this flow) using the CreateOauth2CredentialProvider API, and creating your AI agent identity using the CreateWorkloadIdentity API. User authentication The user navigates to the web application. There are no existing sessions or tokens. The client will redirect the user to the Amazon Cognito managed login and the user signs in with their username and password, or uses a passwordless OTP or passkey. - Amazon Cognito happens to be used in this flow with a local Cognito user account. This can also support federated login flows with third-party identity providers, including social, SAML, or OIDC providers. After successful authentication an authorization code is returned to the application, and this is used to call the /oauth2/token endpoint to get Cognito tokens. Amazon Cognito ID, access, and refresh tokens are returned to the client. I’ll refer to this access token as the human access token going forward. AI agent interaction With the user signed in, they begin interacting with the AI agent through the web application and ask the AI agent to help with scheduling a meeting in their Google calendar. The prompt is sent to the backend where the AI agent is running along with the human access token. - This could be using AgentCore Runtime and could use Amazon Bedrock to access various large language models (LLMs). The architecture could also be expanded to use Amazon Bedrock Knowledge Bases for a retrieval-augmented generation (RAG) solution. The AI agent will first obtain its own access token from AgentCore Identity. It will also provide the human access token as a request parameter. This is using the AgentCore Identity GetWorkloadAccessTokenForJWT API. - When using the GetWorkloadAccessTokenForJWT API, AgentCore Identity will verify the human access token signature and verify the token is not expired. AgentCore Identity returns an access token for the AI agent, going forward I’ll call this the AI agent access token. Because the human access token was provided during the initial request to get the AI agent access token, the specific returned AI agent access token is bound to the human user’s identity. - AgentCore Identity will derive the human user’s identity by combing the ISS and SUB claims within the human access token. You can learn more about obtaining credentials in the AgentCore Identity developer guide. The AI agent, using its own access token, will begin the process of obtaining a third, new access token from a third-party OAuth resource, which is Google in this flow. The AI agent will call the AgentCore Identity GetResourceOauth2Token API. Because this is the initial login flow and a human user is involved, an OAuth 2.0 authorization code grant flow will begin for the OAuth resource (that is, Google). This can be referred to as a 3LO flow. - The goal of this process is to obtain a temporary access token to be used with Google calendar that will be secured in the token vault. It’s important to note that as long as this access token for Google remains active after the human user has given consent, it can continue to securely be retrieved and used by the AI agent from the token vault. The Google authorization URL will be generated by AgentCore identity service based on the pre-configured Google OAuth client. The Google authorization URL is sent to the client from the AI agent. The client will immediately redirect to Google’s authorization endpoint and begin the auth flow for the human user to sign in to Google. After a successful authentication with Google, an authorization code is returned to AgentCore Identity, and an access token is obtained following the OAuth 2.0 authorization code grant flow. The access token from Google for the user is secured in the token vault. I’ll call this third access token going forward the Google access token. - Tokens are secured in the token vault under the agent identity ID and the user ID, this way the token is bound between the agent identity, the human identity, and the Google access token. As the authorization code grant completes its process to obtain a Google access token in the backend, the user will be redirected back to the frontend of the application. This is configured as the callback URL. AI agent acting on behalf of the user The AI agent will call the GetResourceOauth2Token API again (same as step 9) and include the AI agent access token as the workloadIdentityToken request parameter. However, this time the Google access token is returned from the token vault. This provides an enhanced user experience by reducing consent fatigue and minimizing the number of authorization prompts. With the original context and intent of having the AI agent help schedule a meeting in Google calendar, the AI agent will call the Google Calendar APIs with the Google access token. - The Google access token used by the AI agent will have the https://www.googleapis.com/auth/calendar.events scope, authorizing certain calendar actions. After actions are complete between the AI agent and Google calendar, success responses (or failures) will be returned to the AI agent. - This could be an opportunity for the AI agent to perform other automated actions, such as updating a user record in the web application’s backend. After all actions of the AI agent are complete, a success response is returned to the frontend application. The previous flow describes the entire end-to-end process starting from a human user needing to sign in to the web application and ending with an AI agent performing an automated action on behalf of the user. Three different access tokens were involved in this process, and the following is a summary of these access tokens. Human access token – This is issued by an Amazon Cognito user pool (or another identity provider). This access token is used to access the web application and is used to obtain the AI agent access token using the GetWorkloadAccessTokenForJWT API. AI agent access token –This is issued by AgentCore Identity. This access token is used by the AI agent to securely access the token vault. Google access token – This is issued by Google representing the human user. This access token is what’s secured in the token vault and can be securely retrieved by the AI agent access token. Conclusion Organizations are rapidly seeking opportunities to use AI agents to automate workflows and enhance user experiences, but this adoption can introduce security and compliance challenges that can’t be ignored. Organizations must make sure that AI agents can securely access resources on behalf of users while protecting sensitive credentials and maintaining compliance at scale. AgentCore Identity addresses these fundamental challenges by providing enterprise-grade security that protects user credentials and maintains strict access controls. This helps make sure that AI agents can only access what they need when they need it. The service integrates with existing identity systems, avoiding the need for complex migrations or rebuilding authentication flows. Its centralized management of AI agent identities reduces operational overhead and strengthens security posture. For organizations scaling their AI initiatives, these capabilities translate into faster time-to-market and reduced risk of unauthorized access. By implementing AgentCore Identity, organizations can confidently deploy AI agents with built-in OAuth support and secure token management, while lowering development and maintenance costs through streamlined security controls that scale with their business needs. To learn more about building with AgentCore Identity in your organization, review some example use cases and visit the Getting started with AgentCore Identity section of the developer guide to explore prerequisites, SDK usage, best practices, and start building your first authenticated agent. Use the comments section to leave feedback and engage about this post. If you have questions about this post, start a new thread on Amazon Bedrock AgentCore re:Post or contact AWS Support.
aws.amazon.comOct 14, 2025extracted
Visa’s Trusted Agent Protocol sets new standard for secure agentic transactions
Visa’s Trusted Agent Protocol sets new standard for secure agentic transactions Visa unveiled the Trusted Agent Protocol, establishing a foundational framework for agentic commerce that enables secure communication between AI agents and merchants during every step of a transaction. The Trusted Agent Protocol aims to address the challenges facing agent-driven commerce, ushering in a new era where AI can search, compare, and pay on behalf of consumers while ensuring trust between merchants and AI agents. Developed in collaboration with Cloudflare, the release of this protocol reinforces Visa’s commitment to supporting safer and more seamless interactions in the evolving ecosystem of intelligent payments. Over the past year, AI-driven traffic to retail websites in the United States surged over 4,700%, and 85% of shoppers who have used AI to shop say it improved their shopping experience. But as more AI agents browse and buy on behalf of consumers, merchants face new challenges: Managing bot detection systems that can mistakenly block legitimate agentic transactions Supporting agent-driven guest and logged-in checkout Preserving visibility into the consumer behind the agent and payment data The Trusted Agent Protocol is designed to address these challenges by enabling approved agents to securely pass critical information to merchants. This provides a much-needed framework for recognizing trusted agents with commerce intent and distinguishing them from malicious automation and rogue bots. In developing this protocol, Visa has received feedback from early partners including Adyen, Ant International, Checkout.com, Coinbase, CyberSource, Elavon, Fiserv, Microsoft, Nuvei, Shopify, Stripe, and Worldpay. “We believe the entire payments ecosystem has a responsibility to ensure sellers can trust AI agents as much as they trust their best customers and networks,” said Jack Forestell, Chief Product & Strategy Officer, Visa. “For the past year, we’ve worked closely with sellers, issuers and partners to make sure agent-initiated transactions are as seamless and secure as any payment today. Our new agent protocol is focused on creating no-code functionality for merchants to securely identify agents with an intent to buy and provide a better payments and personalized experience for its known users,” Forestell continued. “Securing the future of commerce is a shared responsibility, especially as AI agents begin to act on behalf of consumers,” said Stephanie Cohen, Chief Strategy Officer, Cloudflare. “Our work with Visa on the Trusted Agent Protocol is a vital step in building the necessary guardrails for this new ecosystem.” Supporting merchants In an agentic world, merchants need a way to recognize trusted agents, verify their credentials, and maintain customer relationships without overhauling their systems. Trusted Agent Protocol addresses these challenges with new specifications that use agent-specific cryptographic signatures and includes the following information: Agent intent – An indication that the agent is a trusted agent with an intent to retrieve additional details about, or purchase, a specific product from a merchant. Consumer recognition – Data elements that indicate whether a consumer has an existing account or has previously interacted with the merchant. Payment information – Agents have the option to carry payment data to support a merchant’s preferred checkout or payment method. Built for the future of commerce interoperability While these initial specifications apply to the Visa network in this phase, enabling agents to safely and securely act on a consumer’s behalf requires an open, ecosystem-wide approach. Visa is committed to aligning closely with global standards bodies such as the IETF, OpenID Foundation, and EMVCo, as well as ecosystem partners, to ensure that the Trusted Agent Protocol complements other recently announced protocols, such as the Agentic Commerce Protocol. Visa is also collaborating with Coinbase to align on interoperability with x402. Built upon the foundational HTTP Message Signatures standard and aligned with WebAuthn, the Trusted Agent Protocol enables merchants and agents to establish trust using existing web infrastructure—with minimal user experience (UX) changes required on merchant websites or checkout pages—and can be extended to non-web messaging protocols.
helpnetsecurity.comOct 14, 2025extracted
Should I use managed login or create a custom UI in Amazon Cognito?
Should I use managed login or create a custom UI in Amazon Cognito? October 8, 2025: This blog post has been updated to include the Amazon Cognito managed login experience. The managed login experience has an updated look, additional features, and enhanced customization options. September 8, 2023: It’s important to know that if you activate user sign-up in your user pool, anyone on the internet can sign up for an account and sign in to your apps. Don’t enable self-registration in your user pool unless you want to open your app to allow users to sign up. June 9, 2023: Original publication date. Amazon Cognito is an authentication, authorization, and user management service for your web and mobile applications. Your users can sign in directly through many different authentication methods, such as user accounts within Amazon Cognito or through social providers such as Facebook, Amazon, Apple, or Google. You can also configure federation through a third-party OpenID Connect (OIDC) or SAML 2.0 identity provider (IdP). Amazon Cognito user pools are user directories that provide sign-up and sign-in functions for your application users, including federated authentication capabilities. A Cognito user pool has two primary UI options: Managed login: AWS hosts, preconfigures, maintains, and scales the UI—including managed login branding and classic Hosted UI branding—with a set of options that you can customize or configure for sign-up and sign-in for app users. Custom UI: You can configure an Amazon Cognito user pool with a completely custom UI by using the SDK. You’re accountable for hosting, configuring, maintaining, and scaling your custom UI as a part of your responsibility in the AWS Shared Responsibility Model. In this blog post, we review the benefits of using the managed login or creating a custom UI with the SDK and things to consider in determining which to choose for your application. Managed login Managed login provides web interfaces for sign-up, sign-in, multi-factor authentication (MFA), password management, and passwordless and passkey sign-in capabilities in your user pool. The managed login provides an authorization server based on the OAuth 2.0 specification, and has a default implementation of user flows for sign-up and sign-in. Your application can redirect to the managed login, which will handle the user flows through the authorization code grant flow. The managed login also supports sign-in through social providers and federation from OIDC-compliant and SAML 2.0 providers. Amazon Cognito offers two visual modes and branding and customization experiences: managed login branding with branding editor and hosted UI (classic) branding. Managed login branding with branding editor Managed login branding provides an improved user experience with the most up-to-date authentication options for the user pool UI experience. Figure 1 shows managed login using the default branding settings. The branding editor is a no-code visual editor that you can use to customize the look and feel of the entire user journey. You can customize each user pool application client individually, and preview screens in real-time with different screen sizes, as shown in Figure 2. As shown in Figure 3, You can customize various components using the branding editor, including background, header and footer, buttons, focus state, icons, and more. Additionally, managed login branding adds support for passwordless sign-in with passkeys, email one-time-passwords (OTP) and SMS OTPs, as shown in Figure 4. After you enable passwordless login in your user pool, managed login branding adapts to curated user flows with users’ preferred authentication methods. Managed login branding also offers localization options in several languages (two are shown in Figure 5). You can add a lang query parameter in the link you distribute to users, and Amazon Cognito will set a cookie in users’ browsers with their language preference after the initial request. Hosted UI (classic) branding For customers who prefer a traditional approach, Amazon Cognito continues to support the Hosted UI (classic) branding (shown in Figure 6) with basic customization where you can upload a CSS file to design the UI styling and upload a brand-specific logo. Hosted UI (classic) supports standard authentication flows with MFA and self-service sign up. The managed login branding with branding editor is available to Amazon Cognito user pools with Essentials and Plus feature tiers, and Hosted UI (classic) branding is available to most Cognito user pools including Lite tier. To learn more about Cognito feature tiers, visit Amazon Cognito pricing. Security and compliance capabilities Both managed login branding and Hosted UI (classic) branding are designed to help you meet your compliance and security requirements and your users’ needs. Managed login supports custom OAuth scopes and OAuth 2.0 flows. If you want single sign-on (SSO), you can use managed login to support a single login across many application clients, with browser session cookies for the same domain. Actions are logged in AWS CloudTrail, and you can use the logs for audit and reactionary automation. The managed login experience also supports the full suite of threat protection features for Amazon Cognito. For additional protection, managed login has support for AWS WAF web ACLs and for AWS WAF CAPTCHA, which can help protect your Cognito user pools from web-based exploits and unwanted bots. For federation, managed login supports federation with third-party IdPs that support OIDC and SAML 2.0, as well as social IdPs, as shown in Figure 7. Identity providers are connected to your Amazon Cognito user pool. In managed login, users use a button to select the federation source, and redirection is automatic. With SAML and OIDC IdPs, you can also configure mapping by using the domain in the user’s email address. In this case, a single text field is visible to your application users to enter an email address, as shown in Figure 8, and the lookup and redirect to the appropriate SAML IdP is automatic, as described in Choosing SAML identity provider names. Managed login integrates with Application Load Balancer (ALB) for web applications and works with AWS Amplify to enable social identity provider and enterprise federation (SAML and OIDC) capabilities. Beyond these integrations, Amazon Cognito user pools integrate with various AWS services (such as AWS AppSync), that require user authentication and authorization, and Amazon API Gateway through Cognito authorizers to secure your REST and HTTP endpoints. You might choose to use managed login for many reasons. AWS fully manages the hosting, maintenance, and scaling of the managed login, which can contribute to the speed of go-to-market for customers. If your app requires OAuth 2.0 custom scopes, federation, social login, or native users with basic but customized branding and potentially numerous Amazon Cognito user pools, you might benefit from using managed login. For more information about how to configure and use the hosted UI, see Using the Amazon Cognito hosted UI for sign-up and sign-in. Create a custom UI Creating a custom UI using the SDK for Amazon Cognito provides a host of benefits and features that can help you completely customize the UI for your application users. With a custom UI, you have complete control over the look and feel of the UI that your application users will land on, including designing your app to support multiple languages, and you can build and design custom authentication flows. There are numerous features that are supported when you build a custom UI. As with the managed login, the APIs invoked from a custom UI using the SDK will create log entries in CloudTrail, and you can use the logs for audit and automation. You can also create a custom authentication flow for your users with a fully custom authentication experience beyond the those available in managed login. In a custom UI, you can build custom session management and integrate with AWS WAF. A custom UI also works with the threat protection features of Amazon Cognito. With a custom UI, such as the one shown in Figure 10, you can orchestrate a suite of sign-in options and sign-in flows for your users. For example, you can collect a user or tenant identifier at the beginning of the authentication flow and apply your own logic for user authentication flow, such as redirecting federated users to external IdPs, displaying a password prompt for local users, or directing users to create a new account if they don’t exist. You can also build flows to let a user choose alternative MFA methods if their preferred choices aren’t available. When you build a custom UI, there is support for custom endpoints and proxies so that you have a wider range of options for management and consistency across application development as it relates to authentication. Custom authentication flows are only available in applications with a custom UI, which gives you the ability to make customized challenge prompts and answers to help you meet custom security requirements by using AWS Lambda triggers. For example, you could use it to implement OAuth 2.0 device grant flows. Lastly, a custom UI supports a remember device feature where you can add low-effort sign-in from trusted devices. You might choose to build a custom UI with an SDK when full customization is a requirement or where you want to incorporate customized authentication flows using the custom authentication challenge Lambda triggers. A custom UI is a great choice if you aren’t required to use OAuth 2.0 flows and you have the resources to develop and implement a unique UI for your application users. For more information about how to configure and use a custom UI, see Using the Amazon Cognito managed login for sign-up and sign-in. You can also visit the documentation on Building custom UIs with Amplify. Decision criteria matrix When deciding between Amazon Cognito managed login branding options and a custom UI, there are some unique differences that can help you determine which UI is best for your application needs. Managed login offers a modern, customizable authentication experience with advanced features like no-code visual customization, dark mode themes, and support for passwordless options. It supports OAuth 2.0 flows, custom OAuth scopes, the ability to sign in one time and access many Cognito application clients (using SSO), and full use of the Cognito threat protection features. For applications requiring complete control over the authentication experience and UX—including custom authentication flows, device fingerprinting, and reduced token expiration—a custom UI is the better choice. This option allows for full UI customization, implementation of custom authentication flows, and integration with specific frameworks or libraries not supported by managed login. When making your decision, consider factors such as the level of customization required, specific authentication features needed, development resources available, integration requirements with other AWS services, security and compliance needs, and user experience priorities. Remember that your application authentication requirements and customer experience should take precedence over other considerations. You can use the following table to help select the best UI for your requirements. Figure 11: Decision criteria matrix Conclusion In this post, you learned about using managed login, including its two branding options and creating a custom UI in Amazon Cognito and the many supported features and benefits of each. Each UI option targets a specific need. Choose from available options based on your list of requirements for authentication and the user sign-up and sign-in experience. You can use the information in this post as a reference as you add Amazon Cognito to your mobile and web applications for authentication. Have a question? Contact us for general support services.
aws.amazon.comOct 8, 2025extracted
More .well-known Scans, (Thu, Oct 2nd)
I have been writing about the ".well-known" directory a few times before. Recently, about attackers hiding webshells [1], and before that, about the purpose of the directory and why you should set up a "/.well-known/security.txt" file. But I noticed something else when I looked at today's logs on this web server. Sometimes you do not need a honeypot. Some attackers are noisy enough to be easily visible on a busy web server. This time, the attacker hit various URLs inside the ".well-known" directory. Here is a sample from the > 100 URLs hit: .well-known/ai-plugin.json .well-known/apple-app-site-association .well-known/oauth-authorization-server .well-known/openid-configuration .well-known/terraform.json Before you read any further: Some of these files are required. Do not just delete them without first talking to your developers or system administrators! terraform.json: As the name implies, it is used by Hashicorp's Terraform product. Terraform uses this file to discover API endpoints. A bit like OpenAPI/WSDL [1] ai-plugin.json: Sites can advertise various AI plugins, particularly ChatGPT. The file describes the plugins (for humans and machines) and defines how to interact with them. .well-known/apple-app-site-association: Developers may indicate that a specific website/domain is associated with a particular app. This allows content from the website to be used in the app, and credentials may be used across the website and app. .well-known/oauth-authorization-server and .well-known/openid-configuration: These two are similar in content and purpose. If you use OAuth or OpenID Connect (OIDC), these URLs will help a relying party to figure out what keys to use to verify any signatures created by this service. Given this small sample, it is pretty apparent why an attacker may scan these. They are handy for reconnaissance and finding out the relationships between sites. As mentioned above, do not blindly delete them as they may be necessary. However, the content of these files should be controlled and reviewed. While at it, ensure you have a .well-known/security.txt file. -- Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu Twitter|
isc.sans.eduOct 2, 2025extracted
OneLogin Bug Let Attackers Use API Keys to Steal OIDC Secrets and Impersonate Apps
A high-severity security flaw has been disclosed in the One Identity OneLogin Identity and Access Management (IAM) solution that, if successfully exploited, could expose sensitive OpenID Connect (OIDC) application client secrets under certain circumstances. The vulnerability, tracked as CVE-2025-59363, has been assigned a CVSS score of 7.7 out of 10.0. It has been described as a case of incorrect resource transfer between spheres (CWE-669), which causes a program to cross security boundaries and obtain unauthorized access to confidential data or functions. CVE-2025-59363 "allowed attackers with valid API credentials to enumerate and retrieve client secrets for all OIDC applications within an organization's OneLogin tenant," Clutch Security said in a report shared with The Hacker News. The identity security said the problem stems from the fact that the application listing endpoint – /api/2/apps – was configured to return more data than expected, including the client_secret values in the API response alongside metadata related to the apps in a OneLogin account. The steps to pull off the attack are listed below - Attacker uses valid OneLogin API credentials (client ID and secret) to authenticate Request access token Call the /api/2/apps endpoint to list all applications Parse the response to retrieve client secrets for all OIDC applications Use extracted client secrets to impersonate applications and access integrated services Successful exploitation of the flaw could allow an attacker with valid OneLogin API credentials to retrieve client secrets for all OIDC applications configured within a OneLogin tenant. Armed with this access, the threat actor could leverage the exposed secret to impersonate users and gain access to other applications, offering opportunities for lateral movement. OneLogin's role-based access control (RBAC) grants API keys broad endpoint access, meaning the compromised credentials could be used to access sensitive endpoints across the entire platform. Compounding matters further is the lack of IP address allowlisting, as a result of which it's possible for attackers to exploit the flaw from anywhere in the world, Clutch noted. Following responsible disclosure on July 18, 2025, the vulnerability was addressed in OneLogin 2025.3.0, which was released last month by making OIDC client_secret values no longer visible. There is no evidence that the issue was ever exploited in the wild. "Protecting our customers is our top priority, and we appreciate the responsible disclosure by Clutch Security," Stuart Sharp, VP of Product at One Identity for OneLogin, told The Hacker News. "The reported vulnerability was resolved within a reasonable timeframe with the OneLogin 2025.3.0 release. To our knowledge, no customers were impacted by this vulnerability." "Identity providers serve as the backbone of enterprise security architecture," Clutch Security said. "Vulnerabilities in these systems can have cascading effects across entire technology stacks, making rigorous API security essential."
thehackernews.comOct 1, 2025extracted
After Shai-Hulud, GitHub tightens npm publishing security
After Shai-Hulud, GitHub tightens npm publishing security Attackers are constantly finding ways to take over accounts and push malicious packages to the npm registry, the (GitHub-operated) online repository for JavaScript and Node.js packages. But in this month alone, we witnessed the compromise of popular code packages after a successful phishing campaign, and the Shai-Hulud attack, which involved the use of a self-replicating worm-like payload that ultimately compromised over 500 packages and compromised many secrets. While GitHub has managed to put a stop to Shai-hulud’s replication and has blocked the uploading of new packages containing the malware’s indicators of compromise, they also realized that they will have to make changes to prevent similar attacks in the future. Planned security improvements GitHub is working towards a future where: 1. Local package publishing will require 2FA GitHub is planning to remove the option to bypass 2FA for local package publishing, and will deprecate time-based one-time password (TOTP) 2FA. Users will be migrated to FIDO-based 2FA. 2. Trusted publishing is adopted and used more widely Trusted publishing is a system that lets package repositories trust specific workflows or services to publish code using short-lived OpenID Connect identity tokens instead of long-lived API keys. This reduces the chance of stolen credentials being used to spread malicious packages. At the moment, npm trusted publishing only supports GitHub Actions and GitLab Pipelines, but GitHub plans to expand the list of eligible CI/CD providers for trusted publishing. Adding a trusted publisher on npmjs.com (Source: npm registry) 3. The granular access tokens will have a restricted lifetime Granular tokens with publishing permissions will have a maximum lifetime of 7 days. Legacy classic tokens will be deprecated. Publishing access will disallow tokens by default and push users towards trusted publishers or 2FA enforced local publishing. A gradual rollout “We recognize that some of the security changes we are making may require updates to your workflows. We are going to roll these changes out gradually to ensure we minimize disruption while strengthening the security posture of npm,” said Xavier René-Corail, GitHub’s senior director of security research. “We’re committed to supporting you through this transition and will provide future updates with clear timelines, documentation, migration guides, and support channels.” In the meantime, npm maintainers have been encouraged to switch to WebAuthn for two-factor authentication; start using npm trusted publishing instead of tokens; and enforce the use of 2FA for package publishing and settings modification. Subscribe to our breaking news e-mail alert to never miss out on the latest breaches, vulnerabilities and cybersecurity threats. Subscribe here!
helpnetsecurity.comSep 23, 2025extracted
OpenID Foundation sets new standards for real-time security event sharing
OpenID Foundation sets new standards for real-time security event sharing The OpenID Foundation (OIDF) has approved three Final Specifications, establishing the first global standards for real-time security event sharing across digital identity systems. The approved Final Specifications are: OpenID Shared Signals Framework 1.0 – Enables secure, real-time delivery of security events between any connected systems OpenID Continuous Access Evaluation Profile (CAEP) 1.0 – Defines how systems communicate session changes to maintain continuous security OpenID Risk Information Sharing and Coordination (RISC) 1.0 – Establishes standards for sharing account security changes between services Why these standards are important These specifications solve a critical gap that has left organizations vulnerable during the extended periods between user logins. Systems relying on federated identity had no way to receive security updates after initial login. Sessions often last days or weeks, during which user locations, device compliance, or organizational access may change dramatically. Organizations were forced to choose between disrupting users with constant re-authentication requests or accepting substantial security risks from outdated login information. These standards create an ecosystem where security systems can instantly communicate threats across organizational boundaries. Enterprise device management systems can notify all connected services when a user’s device becomes non-compliant or compromised, while cybersecurity threat detection platforms can share intelligence about suspicious activities in real-time. Identity providers can immediately broadcast alerts about credential compromises or account takeovers, and applications can report anomalous user behaviour patterns to the broader security ecosystem. “This coordinated approach makes zero trust security architectures practically achievable at global scale, where security decisions are continuously evaluated based on current, real-time information rather than outdated login credentials,” said Atul Tulshibagwale, co-chair of the OpenID Foundation’s Shared Signals Working Group. “For financial services institutions, healthcare organizations, government agencies, and other security critical sectors, these specifications provide the standardized foundation needed to implement comprehensive zero trust security architectures and continuous access evaluation policies across their entire digital infrastructure.” Significance of ‘Final Specification’ status The OpenID Foundation’s approval establishes the specifications as the definitive global standard for continuous identity security, providing the foundation for protecting billions of users worldwide. The designation as Final Specifications provides crucial intellectual property protections and guarantees these standards will not undergo further revision. The OpenID Foundation’s membership represents organizations responsible for protecting billions of user identities worldwide. Major technology leaders, including Apple, IBM, Okta, and others, have already adopted these protocols. Gail Hodges, the OpenID Foundations’ Executive Director, said: “The fact that the first three specifications in the Shared Signals family are Final is a material milestone in the adoption of the specification. This status unlocks the ability of many governments to adopt the specifications, and encourages many CTOs and CISOs that the specifications are completely stable and ready for adoption. The OIDF recognizes all the countless hours the Shared Signals WG cochairs, contributors, and implementers have played in conceiving, maturing and now scaling this family of specifications, specifications we perceive as vital to the health of identity and security ecosystems globally.”
helpnetsecurity.comSep 22, 2025extracted
DigitalOcean adds Single Sign-On to help businesses centralize user access
DigitalOcean adds Single Sign-On to help businesses centralize user access DigitalOcean has announced support for Single Sign-On. This integration is designed to provide digital native businesses with secure authentication to their DigitalOcean accounts. DigitalOcean Single Sign-On (SSO) helps to centralize user access and makes user onboarding and offboarding seamless. It’s built on the industry-standard OpenID Connect (OIDC) protocol, ensuring secure and reliable authentication. SSO connects your existing Identity Provider (IdP) to DigitalOcean, starting with Okta and expanding to other leading IdPs in the future. For growing, cloud-native teams, SSO provides secure, frictionless access without added complexity or cost. DigitalOcean includes enterprise-grade control and automated user management in every plan, so your team can focus on building, not managing logins. Features of Single Sign-on include: IdP integration & centralized access control: Direct DigitalOcean connection and enforcement of security policies (e.g., MFA, IP restrictions, password policies) through an organization’s existing IdP. Automated user provisioning: Automatically creates new user accounts and assigns roles within DigitalOcean based on IdP group membership upon first login. Role-based access: Aligns identity provider groups with DigitalOcean roles to simplify and automate permissions management. Automated offboarding: Supports real-time deprovisioning of user access from DigitalOcean when removed from the IdP. Enforcement options: Allows administrators to choose between enforcing SSO-only authentication or permitting a mix of SSO and traditional logins. “The addition of Single Sign-On underscores DigitalOcean’s commitment to delivering enterprise-grade security without enterprise complexity or cost,” said Bratin Saha, Chief Product and Technology Officer, DigitalOcean. “Unlike other cloud providers that gate SSO and automated user management behind premium tiers, DigitalOcean includes these capabilities for every customer. By making secure authentication and frictionless onboarding a built-in part of our platform, we help growing teams spend less time managing access and more time innovating and scaling,” Saha concluded.
helpnetsecurity.comSep 5, 2025extracted
Google Launches DBSC Open Beta in Chrome and Enhances Patch Transparency via Project Zero
Google has announced that it's making available a security feature called Device Bound Session Credentials (DBSC) in open beta to ensure that users are safeguarded against session cookie theft attacks. DBSC, first introduced as a prototype in April 2024, is designed to bind authentication sessions to a device so as to prevent threat actors from using stolen cookies to sign-in to victims' accounts and gain unauthorized access from a separate device under their control. "Available in the Chrome browser on Windows, DBSC strengthens security after you are logged in and helps bind a session cookie – small files used by websites to remember user information – to the device a user authenticated from," Andy Wen, senior director of product management at Google Workspace, said. DBSC is not only meant to secure user accounts post-authentication. It makes it a lot more difficult for bad actors to reuse session cookies and improves session integrity. The company also noted that passkey support is now generally available to more than 11 million Google Workspace customers, along with expanded admin controls to audit enrollment and restrict passkeys to physical security keys. Lastly, Google intends to roll out a shared signals framework (SSF) receiver in closed beta for select customers in order to enable the exchange of crucial security signals in near real-time using the OpenID standard. "This framework acts as a robust system for 'transmitters' to promptly inform 'receivers' about significant events, facilitating a coordinated response to security threats," Wen said. "Beyond threat detection and response, signal sharing also allows for the general sharing of different properties, such as device or user information, further enhancing the overall security posture and collaborative defense mechanisms." Google Project Zero Unveils Reporting Transparency The development comes as Google Project Zero, a security team within the company that's tasked with hunting zero-day vulnerabilities, announced a new trial policy called Reporting Transparency to address what has been described as an upstream patch gap. While patch gap typically refers to the time period between when a fix is released for a vulnerability and a user installs the appropriate update, upstream patch gap denotes the timespan where an upstream vendor has a fix available but downstream customers are yet to integrate the patch and ship it to end users. To close this upstream patch app, Google said it's adding a new step where it intends to publicly share the discovery of a vulnerability within a week of reporting it to the relevant vendor. This information is expected to include the vendor or open-source project that received the report, the affected product, the date the report was filed, and when the 90-day disclosure deadline expires. The current list includes two Microsoft Windows bugs, one flaw in Dolby Unified Decoder, and three issues in Google BigWave. "The primary goal of this trial is to shrink the upstream patch gap by increasing transparency," Project Zero's Tim Willis said. "By providing an early signal that a vulnerability has been reported upstream, we can better inform downstream dependents. For our small set of issues, they will have an additional source of information to monitor for issues that may affect their users." Google further said it plans to apply this principle to Big Sleep, an artificial intelligence (AI) agent that was launched last year as part of a collaboration between DeepMind and Google Project Zero to augment vulnerability discovery. The search behemoth also stressed that no technical details, proof-of-concept code, or any other information that could "materially assist" bad actors will be released until the deadline. With the latest approach, Google Project Zero said it hopes to move the needle on releasing patches to the devices, systems, and services relied on by end users in a timely fashion and bolster the overall security ecosystem.
thehackernews.comJul 30, 2025extracted