Fact-Checking at Scale: Building a More Accurate and Efficient Synopsis Factuality System

Post Syndicated from Netflix Technology Blog original https://netflixtechblog.com/fact-checking-at-scale-building-a-more-accurate-and-efficient-synopsis-factuality-system-d7d85859d808

By Shreya S Ramanujam, Yongce Li, Afshine Amidi, Sina Ghiassian, Benjamin Klein.

Introduction

Picture this — you’re home after a long day at work and can’t wait to catch up on Bridgerton. You log on to Netflix, search for “Bridgerton” and land on this screen:

If this sounds familiar, you already know what a synopsis is — it’s a short glimpse into what a viewer can expect to see in a show. We see two types of synopses here: a series-level synopsis describing the overarching plot, and multiple episode-level synopses describing each episode.

A synopsis plays a very important role for us — it helps viewers decide whether a title is worth watching or not. Every synopsis needs to strike a balance: sharing just enough to give viewers a sense of what to expect, while leaving enough intrigue to draw them in. But of course, we can’t just write anything.

“In the fog-drenched streets of Victorian London, Detective Daphne Bridgerton races to unmask a serial killer known only as the elusive Lady Whistledown.”

Intriguing? Definitely. But it is most certainly not the premise of Bridgerton. Which leads us to the first (and most important) rule of writing a good synopsis: it must be factual. At Netflix’s scale, with thousands of titles, multiple episodes per season and multiple languages, fact-checking all of these by hand simply doesn’t scale. This is where our factuality service comes in: an automated way to judge whether a synopsis is factual or not.

Our current factuality checker feeds a reasoning model everything we know about a title (like metadata and text assets) and asks it to judge synopsis factuality according to a rigorous rubric. There are two main limitations of this approach that we want to optimize:

  1. High cost of long-context reasoning calls: Each decision requires expensive, long-context model calls to reasoning models, which doesn’t scale well when we want to check multiple titles, episodes, languages, and style variants.
  2. Misaligned rationales: The model’s explanations often diverge from our annotators’ reasoning, which makes its factuality verdicts less reliable. We want these rationales to be better aligned so that (1) the model can consistently flag nuanced errors, and (2) its explanations can be used downstream to automatically correct issues in the synopsis.

Our new approach tackles both problems at once. On the cost side, it delivers a 52.4% reduction per synopsis. On the quality side, it significantly improves both verdict accuracy and reasoning alignment: Recall–Fail (“Of all truly non-factual synopses, how many does the system correctly reject?”) rises from 0.77 to 0.86, and the new factuality service’s explanations now show ~82% overlap with human rationales (up from ~69%). In other words, it’s not just cheaper and more accurate — it’s also much better aligned with how our expert annotators actually judge synopses.

So, what exactly does factuality mean?

Let’s go back to the Bridgerton example. Say you see this synopsis about Bridgerton Season 1:

Synopsis A: “Bridgerton follows Daphne Bridgerton, the eldest daughter of the powerful Bridgerton family as she makes her debut onto Regency London’s competitive marriage market.”

It’s easy to judge that this synopsis is factually correct — no wrong facts, and it gives the reader a clear, accurate glimpse of what to expect from the show.

Let’s take another example:

Synopsis B: “Set in modern-day London, this gritty crime drama follows Detective Daphne Bridgerton as she hunts a serial killer while hiding her own criminal past.”

Another easy one — the plot is so blatantly off the mark that it is definitely not factual.

But what about this?

Synopsis C: “Bridgerton follows the mysterious, sharp-tongued Lady Whistledown as she exposes the secrets of London’s high society through her scandalous gossip sheet.”

Technically, every statement here is true — Lady Whistledown does indeed publish a gossip sheet, and if there’s one thing she is known for, it’s her scathing exposés. So then, is this a factual synopsis?

Not quite! While technically true, it paints a misleading picture of the show. A new viewer might reasonably expect it to revolve around Lady Whistledown, rather than Daphne navigating the marriage market. This, too, is a type of non-factuality we want to catch.

Lastly, here’s the trickiest of all:

Synopsis D: “When Daphne Bridgerton makes her society debut, she catches the eye of the aloof Duke of Hastings, and the two begin a passionate love affair that sets the whole ton abuzz.”

Again, every statement is true, but the phrasing is misleading. A new viewer might assume they fall in love immediately, missing the fact that their relationship begins as a fake, mutually beneficial arrangement. This is another type of nuanced error our system should flag.

So now that we have an idea of the kinds of errors we care about, the real question is: how do we build a system that is able to catch both glaring as well as subtle factuality violations?

Current Service and Its Limitations

Our current factuality pipeline is a straightforward, holistic LLM call. We feed a reasoning model everything we know about a title (text assets, metadata, and a detailed factuality rubric) and ask it to judge the factuality of a synopsis. We repeat the call several times to reduce output randomness, and if any run flags the synopsis as non-factual, it fails. This approach has two main limitations:

  1. High cost: Each judgment requires multiple (five, to be exact) calls to a large reasoning model over extremely long contexts (100k+ tokens), which does not scale well.
  2. Misaligned reasoning: The model can fail synopses for nitpicky reasons (e.g., “This is a show about wonderful magic” gets failed because the characters never literally call the magic “wonderful”) while overlooking nuanced errors by convincing itself they “don’t really make the synopsis false.” This misalignment makes verdicts less reliable and rationales less useful for downstream correction.

Optimizing the Holistic Pipeline

To understand exactly where we should optimize the current holistic pipeline, we study the current pipeline both qualitatively and quantitatively on a custom factuality benchmark that we built. This benchmark comprises synopses hand-labeled by human annotators as factual or non-factual, along with their rationales. This analysis reveals several key insights:

Insight 1: Do we really need five holistic calls?

Let’s think back to why we added multiple holistic calls in the first place: to reduce sampling noise. In practice, though, we see an interesting dichotomy:

  • Blatantly true / false synopses (Bridgerton A, B): All runs agree on the verdict with near-identical reasoning.
  • Nuanced errors (Bridgerton C, D): The model is much more likely to disagree with itself — some runs catch the error, some don’t. This is exactly where additional sampling helps.

This suggests a simple optimization: A and B don’t really need all 5 calls. If we can somehow identify these “easy” synopses upfront, we can cut down on the number of calls for them, while still giving harder cases like C and D the extra calls they need.

The easiest way to do this is to ask the model to output its confidence alongside its verdict and rationale. We can then separate “easy” (high confidence) synopses from “hard” (low confidence) ones and only send the hard cases through additional checks. Think of it like airport security: most bags go straight through, but those that trigger the alarm (low confidence) get extra screening.

Implementing this easy fix makes our pipeline go from the current holistic model to a new “confidence gated” holistic model:

Insight 2: Five identical judges calls give us no new information

With confidence gating, our pipeline only escalates harder synopses to the full five holistic calls. But extra calls only help with sampling noise, not systematic reasoning errors: if every run follows the same flawed rationale, they’ll all reach the same wrong verdict, rendering the extra calls useless. How can we ensure that each call counts?

Idea: Diversify the judges and make them specialized

Instead of running five holistic judges with the same generic factuality prompt, we introduce two specialized judges that individually target the two aspects of factuality we care about:

  • Literal Judge: Is the synopsis literally true?
  • Implicature Judge: Does this synopsis give a false picture to a new reader who has not watched this show?

Explicitly searching for specific types of errors helps us better flag both literal and subtler implicature errors. In practice, we observe that this works better than repeatedly querying a single holistic judge, hoping that sampling stochasticity will surface nuanced errors.

Insight 3: The rationale reveals mistakes the verdict hid

At this point, we have a pretty good pipeline, but we’re still underusing one of the richest signals available to us: the model’s rationale behind its verdict. For nuanced errors, we often see the model identify a point of contention, then brush it aside based on a faulty assumption or because it deems the issue too minor to affect the verdict. Can we use these shaky spots in the rationale to catch (and correct) errors the verdict misses?

Idea: Secondary atomic-claim checking via a router:

Since our literal and implicature judges are already strong reasoning models, we ask them to additionally critically analyse their own reasoning and surface shaky spots — any doubts, concessions, or assumptions that might need rechecking. These include cases where the model:

  • Makes an assumption.
  • Raises a doubt that the available evidence can’t resolve (e.g., an external critic quote).
  • Notices a contradiction but dismisses it as insufficient to change the verdict.

We pass all concessions from both judges to a router model, which:

  1. Reframes them as self-contained, verifiable atomic claims, each with a materiality field specifying the evidence needed to support or refute it.
  2. Routes each claim to the appropriate secondary Stage-2 judge: a web judge for external facts (e.g., citations, media quotes, or prior work), or a source-material recheck focused on the reframed atomic claim. By pinpointing the exact point of contention, the recheck is more targeted, making it easier to mark the claim as true or false.

Putting It All Together: Proposed Cascade Factuality Service

Our findings lead to three key improvements: specialized judges, confidence-gated escalation, and targeted rechecking of shaky reasoning using a secondary stage when escalated.

We implement these improvements as a tiered system shown in the figure below: every synopsis first passes through both the literal and the implicature judges. High-confidence verdicts are retained, while low-confidence cases escalate to the router and Stage-2 judges for further checking. Stage 2 can overturn the initial verdict in two cases:

  • FAIL → PASS: All concessions, including the original failure reasons, are supported by the secondary check.
  • PASS → FAIL: At least one concession is contradicted.

Results

Based on our discussions from above, we evaluate three different pipelines:

Evaluation: Datasets and Metrics

We evaluate these systems on two datasets: show-level and episode-level synopses. Each datapoint includes a synopsis, a human gold label (factual / not factual), and the annotator’s rationale. For episode-level synopses, we additionally require that the synopsis be specific to that particular episode, not just a generic synopsis of the overall show.

We focus on two main axes: Quality and Cost. The quality metrics are listed below:

Recall-FAIL is our primary metric: higher recall means fewer Gold FAILs are missed. We also track Precision-PASS, which measures how reliably PASS verdicts identify Gold PASSes, and alignment with human rationales.

On the cost side, we want to reduce both the average number of LLM calls per synopsis and the end-to-end cost of producing a final verdict. Latency is not our primary optimization target, but we do want to ensure the median (P50) latency does not blow up to impractical judgement times.

Evaluation Results

The best numbers per metric per dataset are shown in bold.

Note: We compared the cascade against two holistic ablations — increased reasoning effort and a smaller, cheaper model — to test if simple ablations could achieve better performance. For episode-level synopses, we also added a full-show summary to the prompt to provide context from previous episodes; we observe summaries substantially improve performance when compared to non-summary context variants, so we report only summary-based variants.

Our takeaways from this experiment are:

  • Cascade improves quality. Our primary metric, Recall-FAIL improves on both show and episode level synopses, with a limited impact on Recall-PASS. In other words, we now catch more Gold FAIL synopses without sacrificing the reliability of our PASS verdicts.
  • Cascade is cheaper. Cascade cuts total cost by 52.4% on the show-level dataset. Cascade (with summary) is also 15% cheaper than the current (no summary) holistic pipeline on episodic dataset.
  • Cascade’s P50 latency increases with respect to the holistic baseline. Even so, this remains within what we consider a reasonable range for factuality judgment.
  • Simple tweaks aren’t enough. Increasing reasoning effort makes the factuality checker too lenient, while using a smaller model makes it too strict — neither addresses the underlying problems of the holistic baseline.
  • Summary context matters for episodic tasks. Without a full-show summary, the model tends to over-fail because it lacks the context to determine whether a detail from the episode summary fits the broader storyline.

Alignment with Human Rationale

So far, we’ve established that the cascade produces better verdicts: it catches more non-factual synopses and produces more reliable PASS decisions. But are these verdicts correct for the right reasons?

To measure this, we use an LLM-as-a-Judge to compare each pipeline’s reasoning against the human rationale on Gold-FAIL (GF) synopses. The judge assigns a Reasoning Similarity Score (RSS) of 0 (dissimilar), 0.5 (partially similar), or 1 (very similar) based on rationale overlap.

We observe that cascade is significantly better aligned with human rationale in all cases. This is a big gain — not only is the cascade giving us more accurate factuality verdicts, but it also identifies the same points of contention in the synopsis as a specialized human annotator.

Conclusion + Future Work

Overall, our proposed cascade pipeline improves both cost and quality of the existing factuality service:

  • On the cost side, confidence gating lets us avoid unnecessary calls, reducing the average cost of factuality evaluation.
  • On the quality side, two diverse judges allow us to collect complementary informative verdicts, while the Stage-2 judges recheck and correct the assumptions behind uncertain decisions. This results in higher verdict accuracy and substantially better alignment between model and expert annotator reasoning.

The cascade gives us a path toward a factuality system that is not just more accurate, but also more interpretable and self-correcting. Some future directions to consider would be:

  • Adding multimodal inputs to help verify claims that text assets alone cannot confirm.
  • Use the rationale from factuality checking to correct the faulty synopsis.


Fact-Checking at Scale: Building a More Accurate and Efficient Synopsis Factuality System was originally published in Netflix TechBlog on Medium, where people are continuing the conversation by highlighting and responding to this story.

Simplify cross-partition access with AWS IAM outbound identity federation

Post Syndicated from Bill Wells original https://aws.amazon.com/blogs/security/simplify-cross-partition-access-with-aws-iam-outbound-identity-federation/

You can now use tokens from AWS Identity and Access Management (IAM) outbound federation to assume roles in other Amazon Web Services (AWS) partitions.

When your workloads run across AWS partitions such as Commercial, China, GovCloud (US), and European Sovereign Cloud, a workload in one partition might need to access resources or communicate with AWS services in another partition. AWS partitions are hard isolation boundaries with independent instances of AWS Identity and Access Management (IAM), so a credential issued in one partition isn’t valid in another. As a result, direct role assumption with sts:AssumeRole doesn’t work across partition boundaries and resource policies can’t reference principals that exist in another partition.

AWS IAM outbound identity federation already lets your workloads obtain a short-lived, AWS signed JSON Web Token (JWT) and use it to authenticate to external services. Today, we’re extending it with cross-partition support. Your workloads can now use that same mechanism to federate into another AWS partition. A workload in one partition obtains a short-lived JWT using sts:GetWebIdentityToken and exchanges it for temporary credentials in another partition using sts:AssumeRoleWithWebIdentity with no long-term credentials to store or rotate.

This post walks through configuring cross-partition identity federation using Amazon Simple Storage Service (Amazon S3) data access as an example, but the same steps apply to any cross-partition API call.

Important: If your workload requires cross-partition access, consult your compliance team to make sure that your implementation aligns with your regulatory or compliance obligations. A non-exhaustive list of examples are FedRAMP, ITAR, DoD CC SRG, GDPR, and others.

Why use IAM outbound identity federation for cross-partition access?

IAM outbound identity federation provides several benefits, including:

  • Carry origin identity into authorization decisions – The destination trust policy can condition on the source identity’s context, its AWS account, organization ID (org_id), source AWS Region, and principal, so you authorize based on who and where the request originated, not only that a token is valid.
  • Cross-partition audit trail – AWS CloudTrail events in the destination Region include the source principal Amazon Resource Name (ARN), source Region, and a token ID that correlates back to the source Region’s GetWebIdentityToken CloudTrail event.
  • Temporary credentials end to end – Your workload authenticates with a short-lived, signed JWT and receives temporary credentials, so every stage of cross-partition access uses credentials that expire automatically.
  • Fully managed token infrastructure – AWS Security Token Service (AWS STS) issues, signs, and publishes verification keys for the JWTs. You don’t need to implement a public key infrastructure (PKI) or host your own OpenID Provider.
  • IAM integration – You control access with the same IAM roles, trust policies, and permissions policies you already use. Destination accounts can condition on subject, audience, source Region, account, organization ID, and principal ID.
  • Session revocation – You can revoke credentials that have already been issued. Scope the revocation by origin or apply a deny on the destination role.

How cross-partition identity federation with IAM outbound identity federation works

Cross-partition identity federation works by obtaining a signed JWT from AWS STS in the source partition and exchanging that JWT for temporary credentials from AWS STS in the destination partition.

For example, a workload running in the AWS Govcloud (US) partition in the us-gov-west-1 Region can obtain a JWT and exchange it for temporary credentials valid in the AWS Commercial partition in the us-east-1 Region.

Architecture overview

The following diagram shows the elements and workflow used to support cross-partition access.

Figure 1: Cross-partition flow diagram

Figure 1: Cross-partition flow diagram

The cross-partition flow works as follows:

  1. Token request – Your workload, running in a Region from the source partition calls sts:GetWebIdentityToken API.
  2. Token issuance – AWS STS returns a short-lived, cryptographically signed JWT. The token contains claims that assert your workload’s AWS identity, including the account ID, the principal ARN, source Region, and more.
  3. Token presentation – Your workload calls sts:AssumeRoleWithWebIdentity on the AWS STS endpoint in a Region in the destination partition, passing the JWT as the web identity token and the ARN of the target role in the destination partition.
  4. Fetch verification keys and metadata – AWS STS in the destination partition retrieves the public verification key from your OpenID Connect (OIDC) Issuer URL’s JWKS endpoint.
  5. Validation: AWS STS in the destination partition verifies the token’s signature and evaluates the target role’s trust policy.
  6. Return temporary credentials: AWS STS in the destination partition returns temporary credentials scoped by the policies attached to the role.
  7. Cross-partition resource access – Your workload uses the temporary credentials to access resources in the destination partition, such as an S3 bucket.

Setting up cross-partition identity federation

In this walkthrough, we use the example of a workload running in the us-gov-west-1 Region that needs to access data in an S3 bucket in the us-east-1 Region.

Prerequisites

For this walkthrough, you need the following:

  • Two AWS accounts: one in the source partition, AWS GovCloud (US), where the workload runs and one in the destination partition, AWS Commercial, that holds the data.
  • In the source account: an IAM principal with permissions to enable outbound web identity federation (iam:EnableOutboundWebIdentityFederation) and to call sts:GetWebIdentityToken to obtain a signed JWT representing its identity.
  • In the destination account: an IAM principal with permissions to register the source account’s issuer as an OIDC identity provider (iam:CreateOpenIDConnectProvider) and create an IAM role whose trust policy allows sts:AssumeRoleWithWebIdentity from that provider, conditioned on the token’s aud and sub claims.
  • An S3 bucket in the destination account that holds the data you want to access from the source partition.
  • A local installation of AWS Command Line Interface (AWS CLI)

So you can run and verify every step from your own command line, this walkthrough has you assume the workload role as the token-creating identity. In production, an Amazon Elastic Compute Cloud (Amazon EC2) instance, AWS Lambda function, or Amazon Elastic Kubernetes Service (AWS EKS) Pod runs as that role automatically through its instance profile or execution role with no assume-role step.

Step 0: Configure credentials for the GovCloud and Commercial AWS CLI profiles

This walkthrough runs commands in two partitions, so configure a named AWS CLI profile for each. For example, GovCloudCredentials for the source account and CommercialCredentials for the destination. Use the --profile parameter matching the partition where you run each command. In this walkthrough we configure our profiles in the ~/.aws/config file:

[profile GovCloudCredentials]
region = us-gov-west-1
# GovCloud account credentials / SSO

[profile CommercialCredentials]
region = us-east-1
# Commercial account credentials / SSO

Step 1: Enable outbound identity federation on the source account

Enable outbound identity federation on your GovCloud account to generate a unique issuer URL that hosts the OIDC discovery endpoint needed for cross-partition trust. This needs to be performed once in the source account.

Using the AWS CLI:

  1. Ensure your IAM principal has permission to call iam:EnableOutboundWebIdentityFederation.
  2. Run the following command.
    aws iam enable-outbound-web-identity-federation --region us-gov-west-1 --profile GovCloudCredentials

  3. Copy the issuer URL from the command output. For GovCloud, it looks like: https://<unique-id>.tokens.sts.us-gov.api.aws

    Note: IAM has a single endpoint per partition. The --region parameter simply targets that partition’s IAM. Enabling outbound web identity federation is an account-wide setting, so you only need to run this once.

Step 2: Allow your IAM principal to generate JWTs in the source partition

Create an IAM policy that grants permission to call the sts:GetWebIdentityToken API and attach it to the IAM principal that will generate tokens. This example uses an IAM role.

Using the AWS CLI:

  1. Ensure your IAM principal has permission to call iam:CreateRole and iam:PutRolePolicy.
  2. Save the following trust policy to a file named workload-trust-policy.json. This policy controls who can assume the workload role; the role’s ARN is what becomes the token’s sub. So that you can run the walkthrough from the AWS CLI, we set the principal to the identity behind your AWS CLI profile. In production, set it to the compute service that runs your workload, for example "Principal": { "Service": "ec2.amazonaws.com" }, which removes the need to assume the role manually.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "AllowCliRoleToAssume",
          "Effect": "Allow",
          "Principal": {
            "AWS": "arn:aws-us-gov:iam::<source-account-id>:role/<your-cli-role>"
          },
          "Action": "sts:AssumeRole"
        }
      ]
    }

  3. Run the following command to create the workload role with the preceding trust policy:
    aws iam create-role \
        --role-name <your-source-partition-iam-role-name> \
        --assume-role-policy-document file://workload-trust-policy.json \
        --region us-gov-west-1 \
        --profile GovCloudCredentials

  4. Save the following policy to a file named get-web-identity-token-policy.json. This policy grants permission to call sts:GetWebIdentityToken, with conditions that restrict the token audience and limit the token lifetime to 300 seconds:
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "AllowTokensForDestination",
          "Effect": "Allow",
          "Action": "sts:GetWebIdentityToken",
          "Resource": "*",
          "Condition": {
            "ForAllValues:StringEquals": {
              "sts:IdentityTokenAudience": "<your-audience-name>"
            },
            "Null": {
              "sts:IdentityTokenAudience": "false"
            },
            "NumericLessThanEquals": {
              "sts:DurationSeconds": 300
            },
            "StringEquals": {
              "sts:SigningAlgorithm": "ES384"
            }
          }
        }
      ]
    }

  5. Run the following command to attach the permissions policy to the role:
    aws iam put-role-policy \
        --role-name <your-source-partition-iam-role-name> \
        --policy-name AllowGetWebIdentityToken \
        --policy-document file://get-web-identity-token-policy.json \
        --region us-gov-west-1 \
        --profile GovCloudCredentials

For the full detailed walkthrough of these steps, see Getting started with outbound identity federation.

Step 3: Configure trust in the destination account

Create an OIDC identity provider and a trust policy in your Commercial account using the issuer URL from Step 1.

Using the AWS CLI:

  1. Ensure your IAM principal has permission to call iam:CreateOpenIDConnectProvider and iam:CreateRole.
  2. Run the following command to register the source account’s issuer URL as an OIDC identity provider in the destination account:
    aws iam create-open-id-connect-provider \
        --url https://<unique-id>.tokens.sts.us-gov.api.aws \
        --client-id-list "<your-audience-name>" \
        --region us-east-1 \
        --profile CommercialCredentials

    Note: --thumbprint-list is optional; IAM retrieves the issuer’s certificate thumbprint automatically. Because the AWS STS issuer endpoint uses a certificate from a trusted certificate authority (CA), AWS validates it against its trusted root CAs.

  3. Save the following trust policy to a file named trust-policy.json. This policy allows the role to be assumed only with tokens matching the expected audience and originating from us-gov-west-1:
    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "AllowTrustedGovCloudSourceRole",
                "Effect": "Allow",
                "Principal": {
                    "Federated": "arn:aws:iam::<destination-account-id>:oidc-provider/<unique-id>.tokens.sts.us-gov.api.aws"
                },
                "Action": "sts:AssumeRoleWithWebIdentity",
                "Condition": {
                    "StringEquals": {
                        "<unique-id>.tokens.sts.us-gov.api.aws:sub": "arn:aws-us-gov:iam::<source-account-id>:role/<your-source-partition-iam-role-name>",
                        "<unique-id>.tokens.sts.us-gov.api.aws:aud": "<your-audience-name>",
                        "<unique-id>.tokens.sts.us-gov.api.aws:source_region": "us-gov-west-1",
                        "<unique-id>.tokens.sts.us-gov.api.aws:org_id": "<your-source-org-id>"
                    }
                }
            }
        ]
    }

  4. Run the following command to create the role with the preceding trust policy:
    aws iam create-role \
        --role-name <your-destination-partition-iam-role-name> \
        --assume-role-policy-document file://trust-policy.json \
        --region us-east-1 \
        --profile CommercialCredentials

  5. Run the following command to attach a permissions policy granting access to the destination S3 bucket:
    aws iam attach-role-policy \
        --role-name <your-destination-partition-iam-role-name> \
        --policy-arn arn:aws:iam::<destination-account-id>:policy/<your-s3-access-policy> \
        --region us-east-1 \
        --profile CommercialCredentials

Step 4: Cross-partition resource access

With the setup complete, your workload requests a JWT from the source partition, exchanges it for temporary credentials in the destination partition, and uses those credentials to access the S3 bucket.

Using the AWS CLI:

  1. Assume the workload role. In production your workload already runs as this role through its instance profile or execution role, so it skips this step. To trace the flow from the AWS CLI, assume the workload role so the token you create carries that role as its sub. This command uses jq to parse the JSON:
    WORKLOAD_CREDS=$(aws sts assume-role \
        --role-arn arn:aws-us-gov:iam::<source-account-id>:role/<your-source-partition-iam-role-name> \
        --role-session-name trace-cross-partition \
        --region us-gov-west-1 --profile GovCloudCredentials)
    export AWS_ACCESS_KEY_ID=$(echo "$WORKLOAD_CREDS" | jq -r '.Credentials.AccessKeyId')
    export AWS_SECRET_ACCESS_KEY=$(echo "$WORKLOAD_CREDS" | jq -r '.Credentials.SecretAccessKey')
    export AWS_SESSION_TOKEN=$(echo "$WORKLOAD_CREDS" | jq -r '.Credentials.SessionToken')
    

  2. Create the signed JWT from AWS STS and capture it as a variable:
    WEB_IDENTITY_TOKEN=$(aws sts get-web-identity-token \
        --audience "<your-audience-name>" \
        --signing-algorithm ES384 \
        --duration-seconds 300 \
        --region us-gov-west-1 \
        --query WebIdentityToken --output text)
    

  3. Run the following command to exchange the JWT for temporary credentials in the destination partition:
    CREDENTIALS=$(aws sts assume-role-with-web-identity \
        --role-arn arn:aws:iam::<destination-account-id>:role/<your-destination-partition-iam-role-name> \
        --role-session-name <your-session-name> \
        --web-identity-token "$WEB_IDENTITY_TOKEN" \
        --region us-east-1)

  4. Export the temporary credentials from the output:
    export AWS_ACCESS_KEY_ID=$(echo "$CREDENTIALS" | jq -r '.Credentials.AccessKeyId')
    export AWS_SECRET_ACCESS_KEY=$(echo "$CREDENTIALS" | jq -r '.Credentials.SecretAccessKey')
    export AWS_SESSION_TOKEN=$(echo "$CREDENTIALS" | jq -r '.Credentials.SessionToken')

  5. Run the following command to transfer data from the destination S3 bucket:
    aws s3 cp s3://<destination(us-east-1)-bucket>/data.csv ./data.csv --region us-east-1

For applications, the following AWS SDK for Python example creates a session that handles the token exchange and refreshes the credentials automatically:

import boto3
import botocore.session
from botocore import UNSIGNED
from botocore.config import Config
from botocore.credentials import DeferredRefreshableCredentials

def cross_partition_session(role_arn, audience, source_region, dest_region,
                            session_name="cross-partition-session",
                            duration_seconds=300, signing_algorithm="ES384",
                            source_session=None):
    '''
    This helper method creates a self-refreshing boto3 session object using IAM outbound federation.
    '''
    source_session = source_session or boto3.Session()
    source_sts = source_session.client("sts", region_name=source_region)

    dest_sts = boto3.client("sts", region_name=dest_region,
                            config=Config(signature_version=UNSIGNED))

    def refresh():
        token = source_sts.get_web_identity_token(
            Audience=[audience],
            SigningAlgorithm=signing_algorithm,
            DurationSeconds=duration_seconds,
        )["WebIdentityToken"]
        creds = dest_sts.assume_role_with_web_identity(
            RoleArn=role_arn,
            RoleSessionName=session_name,
            WebIdentityToken=token,
        )["Credentials"]
        return {
            "access_key": creds["AccessKeyId"],
            "secret_key": creds["SecretAccessKey"],
            "token": creds["SessionToken"],
            "expiry_time": creds["Expiration"].isoformat(),
        }

    botocore_sess = botocore.session.get_session()
    botocore_sess._credentials = DeferredRefreshableCredentials(
        refresh_using=refresh, method="cross-partition-identity-federation")

    return boto3.Session(botocore_session=botocore_sess, region_name=dest_region)

# Build a cross-partition session, then use it like any other boto3 session.
# Credentials refresh automatically as they near expiry, no manual re-minting.
session = cross_partition_session(
    role_arn="arn:aws:iam::<destination-account-id>:role/<destination-role>",
    audience="<your-audience>",
    source_region="us-gov-west-1",
    dest_region="us-east-1",
)

# Confirm which identity we're operating as in the destination partition.
print(session.client("sts").get_caller_identity()["Arn"])

# Use the session for real work, e.g. read an object from the destination bucket.
session.client("s3").download_file("<destination-bucket>", "data.csv", "data.csv")

Security best practices

We recommend the following best practices for cross-partition access using IAM outbound identity federation.

  • Principle of least privilege – Grant only the minimum permissions needed in the destination partition role. Scope to specific resources and actions.
  • Use condition keys – In the source account, restrict token audience and duration through IAM policy conditions. In the destination trust policy, use the aud and sub conditions to control which tokens can assume which roles.
  • Short token lifetimes – Use the shortest practical duration.
  • Monitor with CloudTrail – Enable CloudTrail in both accounts. The source GetWebIdentityToken event records responseElements.webIdentityTokenId, and the destination AssumeRoleWithWebIdentity event records the same value as requestParameters.webIdentityTokenId alongside the source principal ARN and source Region. Matching those two fields correlates access end-to-end across partitions.
  • Verify compliance – Consult your compliance team to ensure cross-partition data movement meets regulatory requirements.
  • Access Path – Access should be initiated from the more restrictive partition to the less restrictive partition.

Controlling cross-partition access by origin

Cross-partition federation is not enabled by default. You enable it at an AWS account level and configure a federation provider. Once enabled, you can control the providers that are allowed to federate in. The condition key aws:FederatedProvider can be used to restrict which federation provider or partitions are allowed, or to deny API calls from credentials federated from a source account or provider. A new condition key introduced with this release, aws:CrossPartitionSourceRegion can be used to deny API calls federated from a source Region.

Allowlist approved origins

To constrain which origins can federate in, apply an RCP on sts:AssumeRoleWithWebIdentity. Because RCPs are deny-only, you express an allowlist as a deny on anything outside your approved set, enforced before any credentials are issued.

Note that sts:AssumeRoleWithWebIdentity is used by all OIDC federation such as GitHub Actions, Amazon EKS, and others, not just cross-partition. Each policy pairs the allowlist with a StringLike that matches any IAM outbound identity federation issuer (*.tokens.sts.*), so the deny applies only to cross-partition federation and leaves your other OIDC providers untouched. The following two examples demonstrate allowing specific issuers or partitions:

  1. Allowlist trusted issuers. Use aws:FederatedProvider with StringNotLike on the OIDC provider ARN to deny federation from any issuer outside your approved set.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "AllowlistApprovedIssuer",
          "Effect": "Deny",
          "Principal": "*",
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Resource": "*",
          "Condition": {
            "StringLike": {
              "aws:FederatedProvider": "arn:*:iam::*:oidc-provider/*.tokens.sts.*"
            },
            "StringNotLike": {
              "aws:FederatedProvider": [
                "arn:*:iam::*:oidc-provider/<issuer-host>"
              ]
            }
          }
        }
      ]
    }

  2. Allowlist a partition. Use aws:FederatedProvider with StringNotLike on the issuer domain to deny federation from any partition you have not approved, without enumerating individual issuer ARNs. Include any cross-partition issuer you want to allow in the policy.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "AllowlistApprovedPartition",
          "Effect": "Deny",
          "Principal": "*",
          "Action": "sts:AssumeRoleWithWebIdentity",
          "Resource": "*",
          "Condition": {
            "StringLike": {
              "aws:FederatedProvider": "arn:*:iam::*:oidc-provider/*.tokens.sts.*"
            },
            "StringNotLike": {
              "aws:FederatedProvider": [
                "arn:*:iam::*:oidc-provider/*.tokens.sts.us-gov.api.aws"
              ]
            }
          }
        }
      ]
    }

Use policy to control or revoke access after role assumption

Because AWS authorizes requests against the policies in effect, a deny on either key stops in-flight sessions on their next API call. The following examples use an SCP and give you three levers, from one issuer up to an entire partition:

  1. Deny one issuer. Use aws:FederatedProvider with StringEquals on the OIDC provider ARN to deny every API call made with credentials federated from a single source account.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "DenySessionsFromSourceIssuer",
          "Effect": "Deny",
          "Action": "*",
          "Resource": "*",
          "Condition": {
            "StringLike": {
              "aws:FederatedProvider": "arn:aws:iam::<destination-account-id>:oidc-provider/<unique-id>.tokens.sts.us-gov.api.aws"
            }
          }
        }
      ]
    }

  2. Deny one Region. Use the new aws:CrossPartitionSourceRegion condition key to deny every API call made with credentials whose originating JWT was created in a specific source Region.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "DenySourceRegion",
          "Effect": "Deny",
          "Action": "*",
          "Resource": "*",
          "Condition": {
            "StringEquals": {
              "aws:CrossPartitionSourceRegion": "us-gov-west-1"
            }
          }
        }
      ]
    }

  3. Deny whole partition. Use aws:FederatedProvider with StringLike on the issuer domain to deny every API call made with credentials federated from an entire source partition, without enumerating OIDC ARNs or Regions.
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "DenySourcePartition",
          "Effect": "Deny",
          "Action": "*",
          "Resource": "*",
          "Condition": {
            "StringLike": {
              "aws:FederatedProvider": "arn:aws:iam::*:oidc-provider/*.tokens.sts.us-gov.api.aws"
            }
          }
        }
      ]
    }

You can also attach a policy directly to the role in the destination partition to revoke access. For more information, see Deny access to all IAM role sessions associated with a role.

Auditing cross-partition access with CloudTrail

The source partition logs a GetWebIdentityToken event when the JWT is issued, and the destination partition logs an AssumeRoleWithWebIdentity event when the token is exchanged for temporary credentials, both carrying the same JWT ID (webIdentityTokenId). Matching that ID lets you trace and audit a single token from issuance in one partition to its exchange for AWS STS credentials in the other. In the following sample pair of CloudTrail log entries, the cross-partition calls were made from an EC2 instance using its instance role.

Source partition:

{
  "eventName": "GetWebIdentityToken",
  "eventSource": "sts.amazonaws.com",
  "eventTime": "2026-09-10T18:33:01Z",
  "awsRegion": "us-gov-west-1",
  "userIdentity": {
    "type": "AssumedRole",
    "arn": "arn:aws-us-gov:sts::<source-account-id>:assumed-role/<your-source-partition-iam-role-name>/<instance-id>"
  },
  "requestParameters": {
    "audience": ["<your-audience-name>"],
    "durationSeconds": 300,
    "signingAlgorithm": "ES384"
  },
  "responseElements": {
    "webIdentityTokenId": "6318f9f3-bccf-4d00-8e77-920e810f395c",
    "expiration": "2026-09-10T18:38:01Z"
  }
}

  • webIdentityTokenId: The unique identifier on the source partition that correlates this event to the destination AssumeRoleWithWebIdentity CloudTrail event.

Destination partition:

{
  "eventName": "AssumeRoleWithWebIdentity",
  "eventSource": "sts.amazonaws.com",
  "eventTime": "2026-09-10T18:33:01Z",
  "awsRegion": "us-east-1",
  "requestParameters": {
    "roleArn": "arn:aws:iam::<destination-account-id>:role/<your-destination-partition-iam-role-name>",
    "roleSessionName": "<your-session-name>",
    "webIdentityTokenId": "6318f9f3-bccf-4d00-8e77-920e810f395c",
  },
  "responseElements": {
    "subjectFromWebIdentityToken": "arn:aws-us-gov:iam::<source-account-id>:role/<your-source-partition-iam-role-name>",
    "audience": "<your-audience-name>",
    "assumedRoleUser": {
      "arn": "arn:aws:sts::<destination-account-id>:assumed-role/<your-destination-partition-iam-role-name>/<your-session-name>"
    }
  },
  "additionalEventData": {
    "crossPartitionData": {
      "sourcePrincipalArn": "arn:aws-us-gov:iam::<source-account-id>:role/<your-source-partition-iam-role-name>",
      "sourceRegion": "us-gov-west-1"
    }
  }
}

  • sourcePrincipalArn: The IAM principal that obtained the JWT in the source Region.
  • sourceRegion: The Region where the JWT was issued.
  • webIdentityTokenData: The unique identifier on the destination partition that correlates this event to the source GetWebIdentityToken CloudTrail event.

Availability and pricing

Cross-partition IAM outbound identity federation is available in all Regions within the AWS Commercial (aws), China (aws-cn), GovCloud (US) (aws-us-gov), and European Sovereign Cloud (aws-eusc) partitions, at no additional cost. Note that same-partition identity federation isn’t supported with IAM outbound identity federation; for cross-account access within a single partition, use sts:AssumeRole.

Alternative option for cross-partition access

Organizations that already operate a public key infrastructure (PKI) can also use IAM Roles Anywhere to give workloads access across partitions. IAM Roles Anywhere can use your existing certificate authority (CA) or AWS Private Certificate Authority to issue and manage x.509 certificates to specific workloads and applications. To learn more about this alternative, see the blog post Transfer data across AWS partitions with IAM Roles Anywhere.

Conclusion

Cross-partition identity federation gives your workloads a way to reach across AWS partition boundaries without storing or rotating long-term credentials. Short-lived JWTs handle authentication at every stage, and standard IAM roles handle authorization, so the security model is consistent with what you already use inside a single partition. Cross-partition identity federation operates exclusively across AWS partition boundaries. Same-partition federation isn’t supported using IAM outbound identity federation. To learn more, see Federating AWS identities across AWS partitions in the IAM User Guide.

Partitions are isolation boundaries by design with independent IAM instances and separate credentialed access between Regions in different partitions. Treat cross-partition access as an exception and before you establish any, confirm it’s permitted under your regulatory, compliance, and security requirements. For more detail on partitions as a fault isolation boundary, see AWS Fault Isolation Boundaries and Meeting data residency requirements on AWS.

Bill Wells

Bill Wells

Bill is a Senior Solutions Architect at AWS with over 20 years of IT experience that began in the U.S. Air Force. Drawing on a diverse background across multiple organizations, Bill specializes in architecting secure, compliance-aligned cloud solutions that help federal partners achieve mission outcomes with AWS.

Nithin Jayakar Padala

Nithin Jayakar Padala

Nithin is a Software Development Engineer on the AWS IAM team. He works on the core identity systems behind the temporary credentials that customers rely on for short-term access to AWS services at massive scale. He enjoys working on hard problems at the intersection of distributed systems, identity, and security. Outside of work, Nithin can be found traveling, value investing, watching anime, or volunteering with local charities.

[$] Git considers voting to determine its LLM policy

Post Syndicated from corbet original https://lwn.net/Articles/1104195/

One of the dominant themes of 2026 has been the debate within development
projects about the terms under which LLM-written contributions should be
accepted — if, indeed, they should be accepted at all. The Git project has not been immune to this
trend; the topic was discussed
at the recent Git Contributor’s Summit. In this case, the path to a
resolution may be somewhat circuitous; the project, which has never been
governed as a democracy, is considering adopting a voting process as a way
of bringing the discussion to an acceptable conclusion.

Kernel prepatch 7.4-rc2

Post Syndicated from jake original https://lwn.net/Articles/1106300/

Linus Torvalds has released the 7.4-rc2
prepatch
and it will come as no surprise that it is a large one (“a
big -rc2 to go with the largest ever -rc1
“). Much of the size was made
up of some automated Coccinelle updates that were spread out all over the
tree; once those are factored out, the rest looks fairly normal:

When masking that noise out from the diffstat, the shape of it changes
– not spread out over thousands of files any more. But it does not
look unusual: a third is drivers (gpu, networking and sound account
for most of it, but there’s a bit of everything), another third is
networking and bpf, and the final third is “the rest” (mostly
filesystems, mm, arch updates).

And yes, much of this was driven by various AI fixes. I think I’ll
stop repeating that, and we can just take it for granted. But this
time around Alexei [Starovoitov] claims that on the bpf side at least the fixes are
now coming in faster than the new reports, and that sounds lovely if
true.

OpenIndiana 2026.10 released

Post Syndicated from jzb original https://lwn.net/Articles/1106285/

Version
2026.10
of the OpenIndiana operating
system has been released. OpenIndiana is based on Illumos, which in turn was
based on OpenSolaris
after Oracle discontinued it.

Notable changes in this release include UEFI framebuffer support for the live
image, updates to many applications and development tools, as well as the
inclusion of new applications such as TeX Live 2026, the Foliate ebook reader,
and more.

Защита на децата от рисковете на социалните мрежи

Post Syndicated from Bozho original https://blog.bozho.net/blog/4638

В цялата Европа се обсъжда решаването на проблема с вредното влияние на социалните мрежи върху децата. За съжаление, подходът, който са избрали от Европейската комисия, не е най-подходящия – проверка на възрастта.

Ние внесохме законопроект с друг подход – използване на приложения за родителски контрол. И вчера говорих на тази тема на OpenFest. Прилагам слайдовете тук:

Също така изпратих писмо на Европейската комисия, с което критикувам подхода с проверка на възрастта и предлагам алтернативния подход:

Материалът Защита на децата от рисковете на социалните мрежи е публикуван за пръв път на БЛОГодаря.

Security updates for Monday

Post Syndicated from jzb original https://lwn.net/Articles/1106282/

Security updates have been issued by Debian (cjose, kernel, libreoffice, rsync, ruby3.3, telegram-desktop, vim, and zlib), Fedora (bind, composer, copyparty, dnf5, elixir, fasterxml-oss-parent, gnome-remote-desktop, goose, jackson-annotations, jackson-bom, jackson-core, jackson-databind, jackson-jaxrs-providers, jackson-modules-base, jackson-parent, java-21-openjdk, java-21-openjdk-portable, jupyterlab, kryoptic, luksmeta, mingw-cfitsio, mingw-expat, mingw-freetype, mingw-glib-networking, mingw-harfbuzz, mingw-qt5-qtbase, mingw-qt5-qtdeclarative, mingw-qt5-qtwebkit, mingw-qt6-qtbase, mtools, NetworkManager-l2tp, nginx, nginx-mod-brotli, nginx-mod-fancyindex, nginx-mod-headers-more, nginx-mod-js-challenge, nginx-mod-modsecurity, nginx-mod-naxsi, nginx-mod-vts, nodejs-pnpm12, pcre2, perl-Spreadsheet-XLSX, pie, python-boto3, python-botocore, python-joserfc, python-jupyter-builder, python-jupyterlab-server, python-jupytext, python-nbdime, python-notebook, python-s3transfer, python3.12, rccl, rsync, rust-blake2b_simd, rust-blake3, rust-constant_time_eq, rust-lzma-rust2, rust-ppmd-rust, rust-regorus, rust-sccache, rust-totp-rs, rust-typed-path, rust-zip, rust-zip0.6, rust-zip2, sofia-sip, suricata, wordpress, and xen), Mageia (gimp, python-gitpython, and suricata), Red Hat (osbuild-composer), Slackware (httpd), SUSE (bind, brotli, ca-certificates-mozilla, chromedriver, containerized-data-importer1.65-api, corepack24, docker-compose, flatpak, fuse-overlayfs, git-lfs, gitoxide, go1.27, google-cloud-sap-agent, google-guest-agent, gotosocial, kubevirt1.8, kubevirt1.8-container-disk, kubevirt1.9-container-disk, libmariadbd-devel, libntpc1, libopenscap33, libsndfile-devel, libspice-server-devel, libtirpc-devel, matomo, mihomo, mozilla-nss, nano, nmap, nodejs22, perl-Mozilla-CA, python-Brotli, python-CairoSVG, python-certifi, python313-Pillow, rsyslog, stgit, and thunderbird), and Ubuntu (python-tornado).

Launching the Vite Ecosystem Fund

Post Syndicated from Michael Dong original https://blog.cloudflare.com/launching-vite-ecosystem-fund/

Cloudflare is distributing the first $301,300 of the Vite Ecosystem Fund to 44 projects and maintainers across the Vite ecosystem.

When VoidZero joined Cloudflare, we committed $1 million to strengthen the open source ecosystem around Vite. This round is just the start.

Sponsoring open source has always mattered, but now AI has made funding urgent.

AI is changing open source

AI has made open source more valuable while triggering more maintainer burnout. Previously, contributing to a project through either an issue or pull request meant you cared about it. In return, maintainers would review and provide feedback. AI changed the social contract of open source. Anyone can now create and submit AI-authored pull requests.

The most visible result is the influx of pull requests. As the number of PRs has gone up, the number of maintainers reviewing them has stayed constant. So each maintainer’s workload has grown.

During reviews, maintainers often find themselves speaking with an agent and not a person like they used to. If that’s the case, then why not cut out the middleman? Maintainers now have their own agents they can prompt to produce better results since they have more knowledge of the codebase.

AI has raised the pressure to produce. It’s made it easier for maintainers to ship features, performance improvements, and bug fixes that would not have been done otherwise. But it’s also made it easy for other projects to do the same. When another project adds overlapping features using AI, maintainers feel a need to keep up using AI. It can become a grinding cycle, where each project pushes the other to move faster. Along the way, some projects have grown in scope and lost sight of their original goals.

Maintainer burnout and sustainability have always been a problem — and now AI has accelerated those issues. That’s why sponsoring open source projects and supporting maintainers is so important in this moment.

One of the Vite Ecosystem Fund’s first recipients is e18e, a community focused on improving performance across the JavaScript ecosystem. Its lead, James Garbutt, has a long history in open source, and his work at e18e has helped make popular tools like Svelte, Storybook, and Nx faster. "Sponsorships make a huge difference and allow maintainers to dedicate more of their time to the things we all rely on," Garbutt says.

Fund distribution

The recipients of the Vite Ecosystem Fund were selected by a panel of core team members from Vite stack projects (Vite, Vitest, Rolldown, Oxc, Vite+), including maintainers not employed by Cloudflare.

The funding is allocated through Cloudflare's Open Collective as a combination of:

  • Contributions to ecosystem recipients
  • Stipends to core maintainers

We’re proud that Cloudflare has committed to making the open source ecosystem we rely on stronger and more sustainable. No project thrives in isolation.

We'll continue to distribute and draw down the committed amount every quarter.

Contributions to ecosystem recipients

This first round of sponsorships prioritized dependencies, ecosystem critical plugins, significant contributors, and projects that moved the ecosystem forward.

Andrew Gallant

Andrey Sitnik

Anthony Fu Fund

Ari Perkkiö

Artem Zakharchenko

Babel

Bart Waardenburg

Benjamin E. Coe

Brandon Roberts

Chai

David Ortner

David Tolnay

Denis Bardadym

Devon Govett

Divyansh Singh

e18e

ESlint

Giorgio Boa

Guy Bedford

Jessica Sachs

Jonas Kruckenberg

Luigi Pinca

Máximo Mussini

Michael Cousins

Mickael Jeanroy

Misha Kaletsky

Mock Service Worker

Mohammad Bagher Abiyat

Nicholas Rayburn

Paul Miller

Pig Fang

pnpm

Polka

PostCSS

Prettier

Ralf Jung

Rollup

Sindre Sorhus

Terser

typescript-eslint

Verite

universal-deploy (Vike)

Younes Jaaidi

Yuki Okushi

Stipends to core maintainers

The core maintainers of the Vite stack are eligible for a stipend of up to $4,000 per calendar month. Each maintainer can invoice at a rate of $50 per hour contributed that month.

Any time spent improving or supporting the project in some way counts towards this stipend: writing code, writing documentation, triaging issues, offering support in our Discord servers, attending meetings or meetups, contributing to our upstream dependencies, and so on.

Maintainers who are already being paid for or employed for this work do not receive stipends — for example, VoidZero employees are ineligible.

Cloudflare supports open source

Cloudflare’s mission is to help build a better Internet. Supporting open source falls squarely within that mission. The Vite Ecosystem Fund is only part of it.

Cloudflare committed an additional $1 million to sponsor open source projects in our Community Engineers Fund. We also provide Cloudflare credits to open source projects via Project Alexandria.

The Vite ecosystem has come this far because of all the maintainers and contributors who came together to build a community. These sponsorships are a small thank-you for all this hard work.

Letter To The European Commission About Age Verification And Social Networks

Post Syndicated from Bozho original https://techblog.bozho.net/letter-to-the-european-commission-about-age-verification-and-social-networks/

My previous post here in August was about the age verification plans of the European Commission. Since then the EC has proposed the EU KIDS Act, which implements the idea of age verification.

Yesterday I presented the alternative approach – heavily relying on parental control apps – on the OpenFest conference. Apart from proposing a local legislation in Bulgarian parliament, I’ve sent a letter the the European Commission. You can find it here. The text is as follows:


Dear President von der Leyen,
Dear Executive Vice-President Virkkunen,

Subject: The right approach to protecting children from the negative effects of social media

I’m writing this letter as a member of parliament from Bulgaria, as a former minister for digital transformation, as a technical expert and as a father.

Protecting children online has become a priority for the European Commission and for many EU governments, and rightly so. The threats online, the negative psychological effects of addictive designs and the algorithms that prioritize virality over quality have significant negative effects on children.

The European Commission has started addressing the addictive design problem, analyzes algorithmic bias and has undertaken an age verification initiative, in addition to long-term measures against CSAM, online crimes against children, etc.

While we all see the good intentions behind these initiatives, they sometimes lack the technical depth and the ambition to achieve swift results. My focus in this letter will be age verification, as the measure that is the most polarizing and may have significant negative side effects if done wrong. And I’m concerned that the currently selected approach by the European Commission is the wrong one.

The idea sounds simple – “social networks are proven to be detrimental to children’s mental health, and so they must not be allowed to use it. The way to do it is to add an age check before registration, so that only adults can use the service”. While simple to formulate, it’s much more difficult to implement, if not impossible.

There is an inherent paradox – if a solution is fully privacy-preserving, it’s ineffective. If it’s effective, it bears significant risks to privacy, as it will require every citizen to prove their identity online in order to use everyday services.

The European Commission has made a well-meaning attempt to design and implement a proper zero-knowledge proof of age. It’s a great tool, with proper cryptography, complex-yet-elegant. It has “just” one problem – it doesn’t account for the actual “threat actor” in this scenario – the user, who would try many things to circumvent the age limitation. As security consultant Paul Moore has brilliantly shown, you don’t have to compromise the age verification app in order to circumvent the flow – by a simple relay attack, where you just present someone else’s verified age credentials in order to use a service. The proof of concept was implemented as a chrome extension which relays age checks to 3rd party service, backed by an over-18 person’s device, which sends the proof to the service. That way a single adult can verify the accounts of all minors, and because of the necessary privacy guarantees, the relying party (the social network) won’t even know.

This is very likely to happen – “age verification as a service” providers will certainly pop-up to help minors get into social networks. What’s worse – some of these providers may collect children’s personal data, including phone number or social network account ID, in order to provide them with the much coveted proof of age. That data, purposefully or after an inevitable data breach, may be used by sex predators to target children. There are completely realistic nightmare scenarios, born from the good intention to limit the negative effects of social networks.

Even in a school context, a single over-18 (or over-16) student can lend their age verification app to help younger children register profiles. What are policy makers going to do then? Issue administrative fines for sharing age tokens/attestations? Criminalize it?

Any attempt to fix that technically, breaks the privacy guarantees; any attempt to fix it legally, is doomed to fail in enforcement.

My advice, in all my capacities listed in the beginning of this letter, is to abandon that approach and focus on a different approach – rely on parental control apps.

Parental control apps remain rudimentary, and perhaps there are reasons for this. They are not widely used and are often unintuitive and unreliable. However, they can be regulated and improved. They can also incorporate government-mandated lists of apps and domains restricted for children according to age. For example, a child protection agency could publish a list that parental control apps would be required to import automatically. Legislators could also require these apps to be pre-installed on every phone sold in their country. Parents would remain in control and could adjust the settings if they considered their children ready to use particular services responsibly.

Certain apps can be banned for under-14, others for under-16 and others – for under-18. Governments would have much better control over the exact services they deem risky for children, without the need for any changes on the service’s side. Or, if an app vendor wants to have it whitelisted, they may have to implement children-friendly versions.

Going further, this may eventually lead to platform-level parental control APIs, so that each app can read parental control settings, and on the other hand export parental control configuration options to be used in the parental control app.

What’s even better about this approach, is that VPNs can’t be used to circumvent it – it’s a device-level limitation, not service-level limitation, which needs to figure out the country of the user, which can only be done by their IP address.

And It’s completely privacy-preserving, as users don’t have to show or prove anything to anyone.
Of course, the harder part is making sure every child and parent has a parental control app installed. Information campaigns and teachers can help with that, and I’m sure it will achieve much better results than what we are seeing in Australia for example.
Even if the right age limitation measures are implemented, the efforts to limit the addictiveness and so-called “brainrot” on online platforms should continue.
We have proposed national legislation to implement the approach above. But in order to avoid fragmentation in the digital single market, and in order to have a working, cross-border model, where the experience of each country improves the model EU-wide, a solution should be discussed on a EU-level.

Yours sincerely,
Bozhidar Bozhanov,
Member of parliament of the Republic of Bulgaria

The post Letter To The European Commission About Age Verification And Social Networks appeared first on Bozho's tech blog.

AI Security

Post Syndicated from Bruce Schneier original https://www.schneier.com/blog/archives/2026/11/ai-security.html

Two weeks ago, I attended the [un]prompted AI security conference in San Francisco. It was an excellent event: three days of very dense talks about all aspects of AI security. (My talk was about integrous AI, and I will post it when it is online.)

AI security can be divided into three broad topics. It’s important for researchers to understand which one they are working on. And it’s important for us as a community to work on them all. They are: security of AI, security with AI, and security from AI. [un]prompted had good talks about all three.

Dell PowerEdge R770AP Review One Fast Intel Xeon 6 Server

Post Syndicated from Patrick Kennedy original https://www.servethehome.com/dell-poweredge-r770ap-review-one-fast-intel-xeon-6-server/

Today we are taking a look at Dell’s PowerEdge R770AP. The 2U server goes all-in on performance with a dual-socket Xeon 6 setup and 24 channels of DDR5 memory

The post Dell PowerEdge R770AP Review One Fast Intel Xeon 6 Server appeared first on ServeTheHome.

The collective thoughts of the interwebz