Re: [OAUTH-WG] Mix-up mitigation is not so easy...

Daniel Fett <fett@danielfett.de> Wed, 28 October 2020 11:58 UTC

Return-Path: <fett@danielfett.de>
X-Original-To: oauth@ietfa.amsl.com
Delivered-To: oauth@ietfa.amsl.com
Received: from localhost (localhost [127.0.0.1]) by ietfa.amsl.com (Postfix) with ESMTP id 211793A0EDE for <oauth@ietfa.amsl.com>; Wed, 28 Oct 2020 04:58:52 -0700 (PDT)
X-Virus-Scanned: amavisd-new at amsl.com
X-Spam-Flag: NO
X-Spam-Score: -2.096
X-Spam-Level:
X-Spam-Status: No, score=-2.096 tagged_above=-999 required=5 tests=[BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, HTML_MESSAGE=0.001, SPF_NONE=0.001, UNPARSEABLE_RELAY=0.001, URIBL_BLOCKED=0.001] autolearn=ham autolearn_force=no
Authentication-Results: ietfa.amsl.com (amavisd-new); dkim=pass (1024-bit key) header.d=danielfett.de
Received: from mail.ietf.org ([4.31.198.44]) by localhost (ietfa.amsl.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 5-qDNIpW3njL for <oauth@ietfa.amsl.com>; Wed, 28 Oct 2020 04:58:50 -0700 (PDT)
Received: from d3f.me (redstone.d3f.me [5.9.29.41]) (using TLSv1.2 with cipher ADH-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ietfa.amsl.com (Postfix) with ESMTPS id D91653A0EDB for <oauth@ietf.org>; Wed, 28 Oct 2020 04:58:49 -0700 (PDT)
Received: from authenticated-user (PRIMARY_HOSTNAME [PUBLIC_IP]) by d3f.me (Postfix) with ESMTPA id CD1F5145CC; Wed, 28 Oct 2020 11:58:46 +0000 (UTC)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=danielfett.de; s=dkim; t=1603886326; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=j72Rny2Z6kGQgiSWmweUi3r/btouqF1QH82nnWmv7q8=; b=N8OgzkF1stGqUnK4dhAF6Wo7OdTNIllX+Or9k4bShwnRb+nAhdYNZd/MYujiBueJJXOPJF Fn4+Pdj3XW1ain8ik93Q8kggfnnzN6fYJcXMIOt7HPG48I9sKuclfytKTJDJ2UNsiphkj/ 3SrjAmQ/gel+1eoBLOqrwmgQvOhxKdc=
To: Warren Parad <wparad@rhosys.ch>
Cc: oauth <oauth@ietf.org>
References: <cd853162-c784-2910-ac1d-d57d8dd0fdf1@danielfett.de> <CAJot-L1_37tUbW=KxAMqDDS7eu+PTQF0c=ePU9jL-=U-O66ing@mail.gmail.com>
From: Daniel Fett <fett@danielfett.de>
Message-ID: <9209bd4b-1f9e-6b8e-c395-68da53b14517@danielfett.de>
Date: Wed, 28 Oct 2020 12:58:46 +0100
MIME-Version: 1.0
In-Reply-To: <CAJot-L1_37tUbW=KxAMqDDS7eu+PTQF0c=ePU9jL-=U-O66ing@mail.gmail.com>
Content-Type: multipart/alternative; boundary="------------7230DEED32813171162EA3F8"
Content-Language: de-DE
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=danielfett.de; s=dkim; t=1603886327; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=j72Rny2Z6kGQgiSWmweUi3r/btouqF1QH82nnWmv7q8=; b=i2Fwyclq9KQt2tKNK0kjkO55x10cj/7qREu3dAyJyCIRUiXvR/NOkJh1vO2iEljqkmuskY ka4X80UL/MtcanfWAGwhyyzwi5oD0NqavZNw6iDabf7UBRxfcP81mnFxQZcheUK4SW0dEI txeyFIjdiOtim5Xw5gQndXlg6z5af7g=
ARC-Seal: i=1; s=dkim; d=danielfett.de; t=1603886327; a=rsa-sha256; cv=none; b=oJ5c4M25fVA8rQvP1LLdYv49Fh6uOlnCQ+/mtXHO05uC6GDSX3f76/wi33izHBBJza4J2u RZyKGe3PebBxw0O39v7FwxUsiF+PlWnEpYER1Lmwwj9tpd7VzqnmPYIy8GUlzJqQRjcGV1 vwm3CzwnwEZoorNKLIBQ7NhmlEFfHbY=
ARC-Authentication-Results: i=1; d3f.me; auth=pass smtp.auth=fett@danielfett.de smtp.mailfrom=fett@danielfett.de
Authentication-Results: d3f.me; auth=pass smtp.auth=fett@danielfett.de smtp.mailfrom=fett@danielfett.de
X-Spamd-Bar: /
Archived-At: <https://mailarchive.ietf.org/arch/msg/oauth/FcYlhFCq8NL4cy7Gs6SbYjC4tK8>
Subject: Re: [OAUTH-WG] Mix-up mitigation is not so easy...
X-BeenThere: oauth@ietf.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: OAUTH WG <oauth.ietf.org>
List-Unsubscribe: <https://www.ietf.org/mailman/options/oauth>, <mailto:oauth-request@ietf.org?subject=unsubscribe>
List-Archive: <https://mailarchive.ietf.org/arch/browse/oauth/>
List-Post: <mailto:oauth@ietf.org>
List-Help: <mailto:oauth-request@ietf.org?subject=help>
List-Subscribe: <https://www.ietf.org/mailman/listinfo/oauth>, <mailto:oauth-request@ietf.org?subject=subscribe>
X-List-Received-Date: Wed, 28 Oct 2020 11:58:52 -0000

Am 28.10.20 um 12:00 schrieb Warren Parad:
> I would likewise assume that issuer validation is always required. But
> maybe I hadn't been thinking about this enough. Is there an
> alternative to validating it, and implicitly trusting it? Because as
> you pointed out either demonstrated control over valid redirect URIs
> or really any other secondary mechanism would be required. Perhaps I'm
> missing something though.

When using "iss" to mitigate mix-up attacks, we're essentially telling
the client where submitting the auth code is okay. Since this chain of
pointers starts at the AS (→ issuer ID → metadata document → token
endpoint URL), there's no further validation needed: In this direction,
we can assume that every pointer points to an uncompromised component.

A malicious issuer could mix and match PAR/authorization/token/userinfo
endpoint URLs and thereby build a different chain, but I think there's
really not that much that can go wrong there that wouldn't be covered by
the "iss" defense: https://danielfett.de/2020/05/04/mix-up-revisited/

-Daniel


> On Wed, Oct 28, 2020 at 11:08 AM Daniel Fett <fett@danielfett.de
> <mailto:fett@danielfett.de>> wrote:
>
>     Hi all,
>
>     during my work to update the Security BCP, I stumbled upon a
>     problem in our current recommendations against mix-up attacks.
>
>     Until now, our understanding was that adding an "iss" parameter in
>     the authorization response and using a distinct redirect URI for
>     each configured issuer provided the same level of security. This
>     is unfortunately not the case when mix-up is combined with a
>     client impersonation attack.
>
>     Let's start with the "iss" parameter: The assumption is, that an
>     AS "knows" which issuer it belongs to. Therefore, an uncompromised
>     AS will always send the identifier for this (correct) issuer in
>     the "iss" parameter in the authorization response. The client will
>     see that it started the process with the attacker's issuer, but
>     receives the identifier for another issuer in the authorization
>     response, and will abort the interaction.
>
>     With the distinct redirect URIs, the situation is similar. Let's
>     look at how the client would defend against mix-up:
>
>       * For the attacker's AS configuration (attacker Authorization
>         Endpoint, attacker Token Endpoint), the client would register
>         https://client.com/redir/attacker as the redirection URI at
>         the attacker's AS.
>       * For the honest AS configuration (honest Authorization
>         Endpoint, honest Token Endpoint), the client would register
>         https://client.com/redir/honest as the redirection URI at the
>         honest AS.
>
>     In the normal mix-up attack, the following would happen:
>
>       * The user selects "attacker" as AS.
>       * The user is being redirected to the attacker's authorization
>         endpoint.
>       * The attacker redirects the user to the honest AS's
>         authorization endpoint, replacing the client ID in the
>         original authorization request with the client ID of the
>         client at the honest AS.
>       * The user authorizes the client at honest AS.
>       * Honest AS redirects the user back to the client, using
>         https://client.com/redir/honest as the redirect URI.
>       * The client notices a mismatch between the redirection URI and
>         the expected redirect URI (which would be .../attacker).
>
>     Therefore, the mix-up attack is mitigated. The problem is,
>     however, that the attacker can circumvent the protection by
>     *registering a new client with the honest AS, giving
>     https://client.com/redir/attacker as the redirection URI* and
>     using this new client ID in step 3 of the attack.
>
>     This would mean that the client would see the attacker's redirect
>     URI as the incoming URI for the authorization response and would
>     not detect the attack. It would forward the authorization code to
>     the token endpoint of the attacker, who would be able to redeem it.
>
>     Note that the user would not grant access to the honest client,
>     but to the attacker's client. The attacker's client would need to
>     "impersonate" the honest client, i.e., using the same name, icon,
>     etc.; This approach is similar to existing OAuth phishing attacks
>     with counterfeit clients, however, in this case, a *redirect URI
>     of the honest client* is used. Therefore, the usual mitigation
>     whereby the AS shows the redirect URI to the user would not
>     provide any protection (see also
>     https://tools.ietf.org/html/rfc6819#section-3.5).
>
>     What can we do against this attack?
>
>       * PKCE does not protect against this attack, as the attacker
>         would be able to change the code_challenge parameter.
>       * I think that PAR and JAR probably won't help either, since the
>         honest client "legitimately" speaks to the attacker's AS, who
>         in turn speaks "legitimately" to the honest AS (as the
>         attacker's client). All sides would use the correct endpoints
>         and keys, and the attacker would be able to receive and modify
>         the authorization request, forwarding it to the honest AS
>         under his own client ID.
>       * For the same reason, a DPoP-like sender-constraining of the
>         authorization code is unlikely to help.
>       * What would help is if client registrations would depend on an
>         ACME-like demonstration of control over the origin of the
>         redirect URI. This not something mandated for OAuth today and
>         is unlikely to be seen in broad use.
>       * The "iss" parameter solution is robust against this attack as
>         long as an authorization server never returns an issuer
>         controlled by the attacker. In essence, by declaring the
>         issuer, the AS is providing a pointer to a metadata file which
>         points to the "correct" token endpoint - this is why this
>         solution is robust. We have shown the robustness of the "iss"
>         solution in our formal analysis, but never analyzed the
>         redirect uri solution formally.
>
>     For the security BCP, this means that we depend on the "iss"
>     parameter solution even more. (It also means that OAuth 2.1 should
>     probably include this parameter.)
>
>     We need to think about how we can proceed with the security BCP
>     without too much delay. 
>
>     Sorry for poking another hole into the spec,
>     Daniel
>
>     -- 
>     https://danielfett.de
>
>     _______________________________________________
>     OAuth mailing list
>     OAuth@ietf.org <mailto:OAuth@ietf.org>
>     https://www.ietf.org/mailman/listinfo/oauth
>

-- 
https://danielfett.de