Re: [Ace] ACE Framework Review

Ludwig Seitz <> Mon, 22 October 2018 13:07 UTC

Return-Path: <>
Received: from localhost (localhost []) by (Postfix) with ESMTP id 9EC54130E2A for <>; Mon, 22 Oct 2018 06:07:45 -0700 (PDT)
X-Virus-Scanned: amavisd-new at
X-Spam-Flag: NO
X-Spam-Score: -2.601
X-Spam-Status: No, score=-2.601 tagged_above=-999 required=5 tests=[BAYES_00=-1.9, RCVD_IN_DNSWL_LOW=-0.7, SPF_PASS=-0.001] autolearn=ham autolearn_force=no
Received: from ([]) by localhost ( []) (amavisd-new, port 10024) with ESMTP id hmiX_YAWYT7p for <>; Mon, 22 Oct 2018 06:07:41 -0700 (PDT)
Received: from ( []) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by (Postfix) with ESMTPS id AB3E5130E1A for <>; Mon, 22 Oct 2018 06:07:41 -0700 (PDT)
Received: from 1gEZvn-000CQR-UG by with emc1-ok (Exim 4.90_1) (envelope-from <>) id 1gEZvn-000CRc-Uz for; Mon, 22 Oct 2018 06:07:39 -0700
Received: by emcmailer; Mon, 22 Oct 2018 06:07:39 -0700
Received: from [] ( by with esmtps (TLSv1.2:ECDHE-RSA-AES128-SHA256:128) (Exim 4.90_1) (envelope-from <>) id 1gEZvn-000CQR-UG for; Mon, 22 Oct 2018 06:07:39 -0700
Received: from [] ( by ( with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1531.3; Mon, 22 Oct 2018 15:07:39 +0200
To: <>
References: <>
From: Ludwig Seitz <>
Message-ID: <>
Date: Mon, 22 Oct 2018 15:07:38 +0200
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.2.1
MIME-Version: 1.0
In-Reply-To: <>
Content-Type: text/plain; charset="utf-8"; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
X-Originating-IP: []
X-ClientProxiedBy: ( To (
X-Proto: esmtps
X-TLS: TLSv1.2:ECDHE-RSA-AES128-SHA256:128
X-Virus-Status: Scanned by VirusSMART (c)
X-Virus-Status: Scanned by VirusSMART (s)
X-PolicySMART: 14510320
Archived-At: <>
Subject: Re: [Ace] ACE Framework Review
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: "Authentication and Authorization for Constrained Environments \(ace\)" <>
List-Unsubscribe: <>, <>
List-Archive: <>
List-Post: <>
List-Help: <>
List-Subscribe: <>, <>
X-List-Received-Date: Mon, 22 Oct 2018 13:07:46 -0000

On 10/10/2018 16:24, Stefanie Gerdes wrote:
> Hi,
> I looked through the ACE framework document. I think there are some open
> issues that need to be addressed. I will try to summarize the main
> issues below. We provided a rough analysis of the DTLS profile in [1],
> which may also be interesting (many of the issues mentioned there were
> already fixed in the meantime).

Thank you for your review. Sorry for the long response time. Answers 
inline. I also tried to add issues in the issue tracker, but github 
seems to be experiencing trouble at the moment.


> The protocol elements of the framework assume that responses are bound
> to requests in the sense that the receiver of a response can be certain
> that response actually belongs to a certain request. This requirement
> should be mentioned, e.g., in the security considerations.
Agree. I will add a paragraph.

> The minimal security requirements for the communication between two
> communication partners should be listed (C-AS, RS-AS, C-RS,
> respectively). Which pieces of information do they require prior to the
> communication? How must the communication be secured? Which keying
> material do they need to use? 

The first one I agree with. However the other questions seem more 
specific to the commSec solution to me, which would put them into the 

> The framework should point out that all
> claims that influence the security must stem from claimants that were
> approved by the respective human being that is responsible for the
> device, i.e., the requesting party for the client and the resource owner
> for the AS and RS. Otherwise the solution is not secure.

Are there claims that do not influence security?

The specification says (section 4):

    The consent of the resource owner, for giving a client access to a
    protected resource, can be provided dynamically as in the traditional
    OAuth flows, or it could be pre-configured by the resource owner as
    authorization policies at the AS, which the AS evaluates when a token
    request arrives.  The resource owner and the requesting party (i.e.,
    client owner) are not shown in Figure 1.

I believe this is what you were looking for, if not please explain what 
is missing.

> Validity of the access token (Token Expiration, Section 5.8.3): There
> seem to be additional requirements here that are currently not
> mentioned. It is not clear how RS determines the freshness of
> introspection messages (and how fresh they are).

That would be up to the commSec protocol, also it is covered in the 
security considerations of RFC 7662. I will add a reference to those 
considerations in our security considerations section.

> Also, the token
> introspection approach is particularly vulnerable to DoS attacks since
> introspection messages must be exchanged to validate every token. 

This problem applies to regular OAuth introspection as well and is 
covered in the security considerations of RFC 7662.

> The sequence number approach has the problem that an attacker may
> withhold new tokens from RS. In this case, old tokens are infinitely
> valid. This is particularly damaging because C may have a strong
> interest to withhold new tokens and can easily do so by not relaying
> them to RS. This approach therefore must not be used unless there is an
> additional communication channel between RS and AS that regularly
> informs RS which the most recent sequence number is.
This is a best effort approach when the RS has no internal sense of 
time. Also the idea was that several client could submit tokens with an 
ever increasing unique serial number maintained by the AS. Thus even if 
one client would withhold it's newer tokens to keep the old ones from 
expiring, the other clients would eventually submit enough new tokens 
(with higher sequence numbers) so that the token expires.

AFAIK the RS with no internal clock at all is a very rare occurrence, 
thus you can usually expect some form of wallclock time, and thus 
implement an expiration based on "time-since-you-received-this-token".

> Authorization of the AS on the RS side: in the ACE framework, RS checks
> the integrity of the access token (e.g., section 4, section 6, Appendix
> B: Resource Server). RS must also check that the access token stems from
> an AS that is authorized by RO to provide the token. If RS accepts
> tokens from authorization servers that are not approved by RO, the
> solution is not secure. Introspection messages must also stem from an AS
> that is approved by RO.

This is implicit, if the RS has the key that allows it to verify the 
integrity of the token that means that it is an AS approved by its RO.
I will try to add a sentence to make that more explicit.

> Access token validation: Section 5.8.1 should point out that RS must
> check the integrity of the token and validate that it stems from AS that
> is authorized by RO. 

We can expand on this phrase I think: "The RS receiving the token MUST 
verify the validity of the token."

> Also, it would be helpful if the section also
> contained information how a server must react to missing fields, e.g.,
> missing authenticity of the token or tokens from unknown authorization
> servers.
This would be the following sentence in 5.8.1:
"If the token is not valid, the RS MUST respond with a response code 
equivalent to the CoAP code 4.01 (Unauthorized)."

> Confidentiality of access tokens:
> In the access token, confidentiality is only demanded for symmetric
> keys. The security considerations should point out that other data in
> the access token may be confidential and then require protection as well.
This should be covered in RFC 6749  and RFC 6819 which are referenced in 
the security considerations.

> Authorization Rules in Access Token: The framework should mention in
> section 5.6.2 that the authorization rules that are presented to RS in
> the scope of the access token must reflect RO's decisions.

That is already covered by the text in section 4 (see comment above).

> Management of the authz-info resource:
> * The authz-info resource is vulnerable to DoS attacks: clients may
> (with or without intention) send large numbers of access tokens to RS. A
> constrained RS may soon run out of memory/storage space if it needs to
> store large numbers of tokens.

A RS is not expected to store large numbers of tokens. Section 5.8.1 

"The RS MUST be prepared to store at least one access token for future

Thus the RS can adapt the number of tokens it stores to its constrained 
storage resources.

> If introspection messages are used to
> check the validity of access tokens, the use of the authz-info resource
> amplifies the risk of DoS attacks since RS must send a message to its AS
> for every received token. These problems should be mentioned in the
> security considerations.

I will add a section describing the problem.

> The preferred mitigation should be that the
> authz-info resource is only used for protected communication. This does
> obviously not work for the RPK mode. In the PSK mode, RS should be able
> to decide that it uses the authz-info resource only for protected updates.

I don't think that will help, since somehow the initial access token 
must get to the RS. So even when passing it through the DTLS handshake 
(as with PSK in the DTLS profile) the same DoS risk exists.

> * How must the authz-info resource be protected? E.g., an attacker that
> is able to modify the resource may change or delete access tokens. The
> framework leaves the protection of the resource to the profiles, but I
> think some general advice can be offered by the framework.

I can add a paragraph on this in section 5.

> Validity of the access information:
> It seems that the people who wrote the framework did not consider that
> the keying material is not only provided to RS but also to C.
> How does C determine if the keying material it receives from AS is still
> valid?

It is valid as long as you don't get a 4.01 (Unauthorized) from the RS.

> The access token response may comprise an expires_in
> field that contains the validity period of the access token in seconds
> (RFC 6749), but does not specify the validity period of the keying
> material. But even if the validity periods are equal, C does not know
> when the access token was generated. Also, the use of the expires_in
> field is optional. Without protection, the access information is
> infinitely valid. C may use outdated and maybe compromised keying
> material to communicate with RS. The framework should provide
> information how C determines if the keying material is still valid.
> Also, C must check if the keying material it has for a communication
> partner is still valid before sending a request.

I would think that in most cases it is acceptable that the client just 
optimistically sends its request with the existing keying material and 
renews it if it gets back a 4.01.

Use cases where the security policy is such that this is unacceptable 
should use a specific profile that defines additional mechanisms for the 
client to check its tokens and associated keying material (e.g. by using 
client introspection).

> The framework should also mention that C must determine if AS is
> authorized by its owner to provide keying material concerning RS to C.

If C is configured to communicate with RS, this implies that the owner 
of C accepts the AS in charge of RS. Otherwise the owner of C shouldn't 
have configured C to communicate with RS in the first place.

> It is not clear how C makes plain to AS with which RS it wants to
> communicate. C may specify the intended audience in the token request
> using the req_aud parameter. How is RS represented in this case?
> C and AS must have a common understanding how RS is identified,
> otherwise C may communicate with the wrong RS!
> IP addresses may change and therefore are not suitable. If AS specifies
> identifiers for RS, C must securely obtain this knowledge.

Identifying the RS (using the audience claim and the req_aud parameter) 
is application specific. Some applications may want to use public keys, 
others will want to use fixed identifiers that are manually assigned or 
otherwise generated.

The framework does not suggest IP addresses as a way to identify an RS.

> The framework must point out that AS must check if the keying material
> that it provides to C in the access token response actually refers to
> the RS that C wants to communicate with. The problem of mixups
> concerning the RS must be mentioned in the security considerations.
> Also, the framework should give advice how this problem may be addressed.

I will add a paragraph describing the problem and giving some basic 
suggestions (such as public keys as identifiers).

> Confidentiality of unauthorized requests:
> The data that the client sends to the RS in an unauthorized resource
> request may be confidential (e.g., because others must not know the
> requested resources). The framework should mention in the security
> considerations that the client must not send confidential data in the
> unauthorized resource request.

I can add a sentence about this, although it seems very obvious.


Ludwig Seitz, PhD
Security Lab, RISE
Phone +46(0)70-349 92 51