(strong) AuCPace, an augmented composable PAKE
draft-haase-aucpace-00
The information below is for an old version of the document.
| Document | Type |
This is an older version of an Internet-Draft whose latest revision state is "Active".
|
|
|---|---|---|---|
| Author | Björn Haase | ||
| Last updated | 2020-01-13 | ||
| RFC stream | (None) | ||
| Formats | |||
| Stream | Stream state | (No stream defined) | |
| Consensus boilerplate | Unknown | ||
| RFC Editor Note | (None) | ||
| IESG | IESG state | I-D Exists | |
| Telechat date | (None) | ||
| Responsible AD | (None) | ||
| Send notices to | (None) |
draft-haase-aucpace-00
Network Working Group B. Haase
Internet-Draft Endress + Hauser Liquid Analysis
Intended status: Informational January 13, 2020
Expires: July 16, 2020
(strong) AuCPace, an augmented composable PAKE
draft-haase-aucpace-00
Abstract
This document describes AuCPace which is an augmented PAKE protocol
for two parties. The protocol was tailored for constrained devices
and smooth migration for compatibility with legacy user credential
databases. It is designed to be compatible with any group of both
prime- and non-prime order and comes with a security proof providing
composability guarantees.
Status of This Memo
This Internet-Draft is submitted in full conformance with the
provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. The list of current Internet-
Drafts is at https://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress."
This Internet-Draft will expire on July 16, 2020.
Copyright Notice
Copyright (c) 2020 IETF Trust and the persons identified as the
document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents
(https://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of
Haase Expires July 16, 2020 [Page 1]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 2
2. Requirements Notation . . . . . . . . . . . . . . . . . . . . 3
3. Definitions for AuCPace . . . . . . . . . . . . . . . . . . . 3
3.1. Setup . . . . . . . . . . . . . . . . . . . . . . . . . . 3
4. Access to server-side password verifiers databases . . . . . 6
4.1. User credential database and password verifier types . . 7
4.2. Encoding of passwords and user names . . . . . . . . . . 7
4.3. AuCPace database interface for retrieving password
verifiers . . . . . . . . . . . . . . . . . . . . . . . . 8
4.4. Derivation of the salt value for strong AuCPace . . . . . 9
4.5. Specification of the workload parameter sigma . . . . . . 10
4.6. Result of the database parameter lookup . . . . . . . . . 10
5. Authentication session . . . . . . . . . . . . . . . . . . . 11
5.1. Authentication Protocol Flow . . . . . . . . . . . . . . 11
5.2. AuCPace . . . . . . . . . . . . . . . . . . . . . . . . . 12
6. Ciphersuites . . . . . . . . . . . . . . . . . . . . . . . . 14
6.1. CPACE-X25519-ELLIGATOR2_SHA512-SHA512 . . . . . . . . . . 15
7. Security Considerations . . . . . . . . . . . . . . . . . . . 18
8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 20
9. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 20
10. References . . . . . . . . . . . . . . . . . . . . . . . . . 20
10.1. Normative References . . . . . . . . . . . . . . . . . . 20
10.2. Informative References . . . . . . . . . . . . . . . . . 21
Appendix A. AuCPace25519 Test Vectors . . . . . . . . . . . . . 21
A.1. Inverse X25519 test vectors . . . . . . . . . . . . . . . 21
A.2. Strong AuCPace25519 salt test vectors . . . . . . . . . . 22
A.3. Test vectors for AuCPace password verifier . . . . . . . 23
Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 24
1. Introduction
This document describes AuCPace which is an augmented password-
authenticated key-establishment (PAKE) protocol for two parties.
Both sides the client B and the server A establish a high-entropy
session key SK, based on a secret (password) which may be of low
entropy for the client B and a password-verifier stored on the
server. The protocol is designed such that disclosing the secret to
offline dictionary attacks is prevented. Upon server compromise
(stealing A's database), the adversary must first succeed with a
dictionary search for the clear-text password before being able to
impersonate the client.
Haase Expires July 16, 2020 [Page 2]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
The protocol was tailored for constrained server devices.
Specifically, the computationally complex password hash operation is
refered to the clients. AuCPace is also designed for enabling a
smooth migration of legacy user credential databases.
AuCPace is designed to be compatible with any group of both prime-
and non-prime order and comes with a security proof providing
composability guarantees. AuCPace uses CPace as a building block
which is described in a separate internet draft document.
2. Requirements Notation
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
"OPTIONAL" in this document are to be interpreted as described in BCP
14 [RFC2119] [RFC8174] when, and only when, they appear in all
capitals, as shown here.
3. Definitions for AuCPace
3.1. Setup
Let C be a group in which there exists a subgroup of prime order p
where the computational Diffie-Hellman (CDH) problem is hard. C has
order p*c where p is a large prime; c will be called the cofactor.
Let I be the unit element in C, e.g., the point at infinity in if C
is an elliptic curve group. We denote the operations in the group
using addition and multiplication operators, e.g. P + (P + P) = P +
2 * P = 3 * P. We refer to a sequence of n additions of an element
in P as scalar multiplication by n. With B we denote a generator of
the prime-order subgroup in C that we call the base point.
With F we denote a field that may be associated with C, e.g. the
prime base field used for representing the coordinates of points on
an elliptic curve.
We assume that for any element P in C there is a representation
modulo negation, encode_group_element_mod_neg(P) as a byte string
such that for any Q in C with Q != P and Q != -P,
encode_group_element_mod_neg(P) != encode_group_element_mod_neg(Q).
It is recommended that encodings of the elements P and -P share the
same result string. Common choices would be a fixed (per-group)
length encoding of the x-coordinate of points on an elliptic curve C
or its twist C' in Weierstrass form, e.g. according to [IEEE1363] in
case of short Weierstrass form curves. For curves in Montgomery form
correspondingly the u-coordinate would be encoded, as specified,
e.g., by the encodeUCoordinate function from [RFC7748].
Haase Expires July 16, 2020 [Page 3]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
With J we denote the group modulo negation associated to C. Note
that in J the scalar multiplication operation is well defined since
scalar_multiply(P,s) == -scalar_multiply(-P,s) while arbitrary
additions of group elements are no longer available.
With J' be denote a second group modulo negation that might share the
byte-string encoding function encode_group_element_mod_neg with J
such for a given byte string either an element in J or J' is encoded.
If the x-coordinate of an elliptic curve point group is used for the
encoding, J' would commonly be corresponding to the group of points
on the elliptic curve's quadratic twist. Correspondingly, with p' we
denote the largest prime factor of the order of J' and its cofactor
with c'.
Let scalar_cofactor_clearing(s) be a cofactor clearing function
taking an integer input argument and returning an integer as result.
For any s, scalar_cofactor_clearing(s) is REQUIRED to be of the form
c * s1. I.e. it MUST return a multiple of the cofactor. An example
of such a function may be the cofactor clearing and clamping
functions decodeScalar25519 and decodeScalar448 as used in the X25519
and X448 protocols definitions of [RFC7748]. In case of prime-order
groups with c == 1, it is RECOMMENDED to use the identity function
with scalar_cofactor_clearing(s) = s.
Let scalar_mult_cc(P,s) be a joint "scalar multiplication and
cofactor clearing" function of an integer s and an string-encoded
value P, where P could represent an element either on J or J'. If P
is an element in J or J', the scalar_mult_cc function returns a
string encoding of an element in J or J' respectively, such that the
result of scalar_mult_cc(P,s) encodes (scalar_cofactor_clearing(s) *
P).
Let si = invert_scalar_mult_cc(P,s) be a function such that for any
point Z in the prime-order subgroup of J,
invert_scalar_mult_cc(scalar_mult_cc(Q,s),s) == Q. A typical
implemention will involve calculating the inverse in the prime field
mod p on the scalar generated by scalar_cofactor_clearing(s).
Let scalar_mult_ccv(P,s) be a "scalar multiplication cofactor
clearing and verify" function of an integer s and an encoding of a
group element P. Unlike scalar_mult_cc, scalar_mult_ccv additionally
carries out a verification that checks that the computational Diffie-
Hellman problem (CDH) is hard in the subgroup (in J or J') generated
by the encoded element SP = scalar_mult_cc(P,s). In case that the
verification fails (SP might be of low order or on the wrong curve),
scalar_mult_ccv is REQUIRED to return the encoding of the identity
element I. Otherwise scalar_mult_ccv(P,S) is REQUIRED to return the
result of scalar_mult_cc(P,s). A common choice for scalar_mult_ccv
Haase Expires July 16, 2020 [Page 4]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
for Montgomery curves with twist security would be the X25519 and
X448 Diffie-Hellman functions as specified in [RFC7748]. For curves
in short Weierstrass form, scalar_mult_ccv could be implemented by
the combination of a point verification of the input point with a
scalar multiplication. Here scalar_mult_ccv SHALL return the
encoding of the neutral element I if the input point P was not on the
curve C.
Let P=map_to_group_mod_neg(r) be a mapping operation that maps a
string r to an encoding of an element P in J. Common choices would
be the combination of map_to_base and map_to_curve methods as defined
in the hash2curve draft [HASH2CURVE]. Note that we don't require and
RECOMMEND cofactor clearing here since this complexity is already
included in the definition of the scalar multiplication operation
calar_mult_cc above. Additionally requiring cofactor clearing also
in map_to_group_mod_neg() would result in efficiency loss.
|| denotes concatenation of strings. We also let len(S) denote the
length of a string in bytes. Finally, let nil represent an empty
string, i.e., len(nil) = 0.
[f,g,h] denotes alternatives where exactly one of the comma-separated
options is to be chosen.
Let H(m) be a hash function from arbitrary strings m to bit strings
of a fixed length. Common choices for H are SHA256 or SHA512
[RFC6234]. H is assumed to segment messages m into blocks m_i of
byte length H_block. E.g. the blocks used in SHA512 have a size of
128 bytes.
Let strip_sign_information(P) be function that takes a string
encoding of an element P in J and strips any information regarding
the sign of P, such that strip_sign_information(P) =
strip_sign_information(-P). For short Weierstrass (Montgomery)
curves this function will return a string encoding the x-coordinate.
The purpose of defining this function is for allowing for
x-coordinate only scalar multiplication algorithms. The sign is to
be stripped before generating the intermediate session key ISK.
With ISK we denote the intermediate session key output string
provided by CPace that is generated by a hash operation on the
Diffie-Hellman result.
MAC(msg,key) is a message authentication code. A common examples
would be HMAC_SHA512, a block cipher based MAC or a hash-function
based tag.
Haase Expires July 16, 2020 [Page 5]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
KDF(Q) is a key-derivation function that takes a string and derives
key of length L. Common choices for KDF are HMAC_SHA512.
With DSI we denote domain-separation identifier strings that may be
prepended to the inputs of Hash and KDF functions.
Let IHF(salt, username, pw, sigma) be an iterated hash function that
takes a salt value, a user name and a password as input. IHF is
designed to slow down brute-force attackers as controlled by a
workload parameter set sigma. State of the art iterated hash
functions are designed for requiring a large amount of memory for its
operation and will be referred to as memory-hard hash functions
(MHF). Scrypt [RFC7914] or Argon2 are common examples of a MHF
primitive.
With PRS we denote a string that is a required input of the CPace
subprotocol and generated by the AuCPace protocol.
Let A and B be two parties. A and B may also have digital
representations of the parties' identities such as Media Access
Control addresses or other names (hostnames, usernames, etc). We
denote the parties' representation and the parties themselves both by
using the identifiers A and B.
With CI we denote a string that is a required input of the CPace
subprotocol. CI is generated together with PRS by the AuCPace
augmentation layer. CI SHALL be formed by the concatenation of the
identifiers A and B and an associated data string AD, CI = A || B ||
AD;
With uad we denote an optional string that is specifying user-
associated data in a password file entry, such as authorization
rights or permissions or account expiration dates. Specification of
this string is outside of the scope of the AuCPace protocol.
Let sid be a session id byte string chosen for each protocol session
before protocol execution; The length len(sid) SHOULD be larger or
equal to 16 bytes.
4. Access to server-side password verifiers databases
AuCPace is an asymmetric PAKE protocol. I.e. while one party, the
client B, is in possession of a clear-text password pw, the other
party, the server A, is not given access to the cleartext password
but only to a password verifier. The way how such a password
verifier is maintained by a server party is essential for the AuCPace
protocol construction.
Haase Expires July 16, 2020 [Page 6]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
4.1. User credential database and password verifier types
With respect to the use of user credantial databases, AuCPace is
flexible and supports three different database types.
Firstly, the conventional approach as used for logins without a PAKE
protocol is supported (as used e.g. for the password over https:/
approach). Here the server stores a tuple of four elements in his
password database file, (username, uad, salt, w) with w =
IHF(username,pw,salt)). With uad, we denote user-accociated data
such as permissions. The salt value is a nonce used for the IHF
function. Upon a login request, the user transmits the username and
the clear-text password pw to the server. The server looks up the
database, retrieves the salt value, calculates the IHF function with
the given inputs and compares the result with the registered password
verifier w. We refer to this setting as "legacy password verifier
database" (LPVD) setting.
Secondly, AuCPace supports an AuCPace password verifier database
setting (APVD) setting. Here the database is already adapted for use
in conjunction with AuCPace. This setting differs from LPVD by the
fact that instead of the direct output of the IHF, w =
IHF(username,pw,salt), an AuCPace password verifier W is maintained
in the database. W is calculated from the legacy-style value w by W
= scalar_mult_cc(B,w). It is possible to calculate W from a LPVD
entry on the fly and without knowledge of the clear-text password
upon a remote login request. It is also easily possible to migrate
the format of a LPVD database to an APVD database by calling the
scalar multiplication function for each entry.
Thirdly, AuCPace supports the *strong* AuCPace password verifier
database setting (sAPVD) setting, which differs from APVD and LPVD by
the fact that the salt entry in the database, as used for the IHF, is
replaced by a salt-derivation parameter q, as will be detailed below.
With this strong AuCPace verifier type, the AuCPace protocol provides
the additional security guarantee of pre-computation attack
resistance. Note that migrating LPVD or APVD database records to
sAPVD entries is *not* possible, because calculating the strong sAPVD
password verifiers requires the clear-text passwords.
4.2. Encoding of passwords and user names
For AuCPace usernames and passwords are encoded as strings according
to the definitions of [RFC8265], i.e. case-preserving unicode
encoding SHALL be employed.
Haase Expires July 16, 2020 [Page 7]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
4.3. AuCPace database interface for retrieving password verifiers
In the course of the authentication protocoll, the AuCPace server
implementation will need to interface to an user credential database
for retrieving password verifiers.
Database lookup is implemented by use of string-encoded user names.
AuCPace needs an interface equivalent to a function pvr =
lookup_pw_verifier_record(username). I.e. a lookup returns a
password verfier record pvr, based on a username string. It is
REQUIRED that for the purpose of pvr record lookup in databases and
for the database contents, the "case preservation" according to
[RFC8265] is employed, both for the string encoding of the username
and the password.
The content in the pvr records will depend on the application
scenarios, LPVD, APVD and sAPVD as defined above. Password verifier
records pvr as returned from the database are REQUIRED to be composed
of the following components.
A password verifier from either one of the following two options
(w or W).
LPVD case: A binary encoding of the actual password verifier
that has been calculated as a function of the username, the
password, a salt value by use of an iterated hash function pv =
w = IHF(username,password,salt, sigma).
APVD and sAPVD cases: An encoding of an element in J, W =
scalarmult_cc(B,w), which has been calculated by a scalar
multiplication using the base point B. The secret scalar, w,
has been calculated by an iterated hash function just as in the
case above, w = IHF(username,password,salt, sigma).
sigma, a binary encoding specifying the type and the workload
parametrization of the iterated hash function IHF that has been
used for calculating w or W.
A salt derivation entry which is either
LPVD and APVD cases: a binary string encoding of the salt value
itself or,
sAPVD case: an encoding of a secret scalar q for a group scalar
multiplication such that the salt value used for calculating w
or W could be calculated from the tuple salt =
strong_AuCPace_salt_derivation(q,username,password).
Haase Expires July 16, 2020 [Page 8]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
In case that a database lookup on a server yields a legacy password
database record (LPVD case that includes an entry w), the AuCPace
implementation SHALL convert this record into a AuCPace database
record (APVD case) by replacing w with W=scalarmult_cc(B,w).
The AuCPace application protocol, thus, only needs to consider the
two different APVD and sAPVD scenarios. In case of the APVD
scenario, the salt value used for the IHF execution is returned by
the database lookup, while in the sAPVD case the salt value is
replaced by the secret scalar.
4.4. Derivation of the salt value for strong AuCPace
For strong AuCPace the salt value used for the IHF is not explicitly
included in the password verifier record pvr. Instead only the
parameter q is stored. q serves for deriving the salt value. In
order to determine the salt value, strong AuCPace uses a function
salt = strong_AuCPace_salt_derivation(q,username,password). This
function implements the following sequence of operations.
First Z, an element in J, is calculated by use of a Z =
map_username_password_to_J(username || password). function, e.g.
by use of a hash function such as SHA512 and a mapping such as
Elligator2.
The salt value is then determined by applying the scalar q and the
group element Z to the scalar multiplication function, salt =
strip_sign_information(scalarmult_cc(Z,q)).
Deriving the salt value, thus, requires access to all of, username,
clear text password and secret key q. If the database is stolen, an
adversary is not able to derive the salt value without having access
to the clear-text password.
Note that the method above which derives the salt directly from Z and
q will typically only be used when creating a new password database
entry. The AuCPace protocol uses a secret scalar r for, masking the
value of Z. The approach exploits the relation q * Z == ((Z * r) *
q) * (1/r). More explicitly the sequence is as follows:
The client, B, having access to the username and the clear-text
password calculates Z. It aims at deriving the salt value.
B samples a fresh scalar r and calculates U = scalarmult_cc(Z,r).
B sends U to A.
A fetches q from the database and calculates UQ =
scalarmult_cc(U,q). A sends UQ back to A.
Haase Expires July 16, 2020 [Page 9]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
B retrieves the salt by inverting the blinding with the scalar r
using salt =
strip_sign_information(invert_cofactor_cleared_scalar(UQ,r)).
4.5. Specification of the workload parameter sigma
AuCPace does not require the use of a specific iterated hash function
IHF. Still it is strongly RECOMMENDED to use AuCPace in conjunction
with state-of-the art memory-hard hash functions MHF with a secure
workload parametrization. The workload parameter sigma shall encode
all of the following.
The algorithm family, such as Argon2i, scrypt or PBKDF2-HMAC-
SHA256.
The workload parameter specification, e.g. the iteration count for
PBKDF2 or the parameters N,r and p of the scrypt algorithm.
4.6. Result of the database parameter lookup
Summing up, the lookup process for user credential data for AuCPace
SHALL provide all of the following information in the course of the
session establishment protocol.
The iterated hash function specification sigma.
A salt-derivation parameter and its type. The salt derivationn
parameter is either a salt scalar q or the salt value itself.
Correspondingly the type of the salt-derivation parameter is
either "AuCPace" or "strong AuCPace".
An AuCPace password verifier W =
scalarmult_cc(B,IHF(pwd,username,salt)).
For handling the case of failed lookups, if a given user name does
not have an entry, the database shall define a default parameter set
sigma_default and a default salt-derivation parameter for password
hashing. Moreover and a secret string database_seed shall be chosen
specifically for each distinct server A. In case of failed lookups
the following procedure SHALL be used. A random value w shall be
sampled. The password verifier W shall be calculated as W =
map_to_group(w). The parameters q or salt shall be respectively
calculated as [q,salt] = H(name || database_seed).
Haase Expires July 16, 2020 [Page 10]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
5. Authentication session
5.1. Authentication Protocol Flow
AuCPace is a protocol run between two parties, A and B, for
establishing a shared secret key with explicit mutual authentication.
AuCPace is implemented by four messages as indicated by the numbers
in the figure below. The roles of the two parties are different.
Party B, the client, is provided a user name and a password as input.
Party A, the server, has access to a user credentials database that
stores password verifiers. Both parties share a channel identifier
string CI characterizing the communication channel (e.g. information
on IP addresses and port numbers of both sides).
The channel identifier, CI, SHOULD include an encoding of the
identities of both parties A and B if these are available prior to
starting the communication protocol.
Both sides also share a common subsession ID (ssid) string. ssid
could be pre-established by a higher-level protocol invocing AuCPace.
If no such ssid is available from a higher-level protocol, a suitable
approach is including ssid in the first message from B to A as shown
in the figure below.
Haase Expires July 16, 2020 [Page 11]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
A B
| ssid |
|<1----------------| (sample ssid)
---------- AuCPace protocol -----------
In: ssid | | In: name, passw.
| name,U | ssid
|<1----------------|
DB lookup | |
| sid2 |
|[UQ,salt],X,sigma |
det. CI,PRS |----------------2>| det. CI,PRS
sid_cpace | | sid_cpace
---------------------------------------
In: CI, PRS, || (CPace substep) || In: CI, PRS,
sid_cpace || || sid_cpace
|| Ya ||
||----------------2>||
|| Yb ||
Output: ISK ||<3----------------|| Output: ISK
---------------------------------------
expl.auth. | Tb | expl.auth.
|<3----------------|
| Ta |
|----------------4>|
Output: SK | | Output: SK
5.2. AuCPace
Both parties start with agreed values on the ssid string. The server
side has access to a user credentials database. The client side
holds a user name, a clear-text password to be used for the
authentication session. Both sides share an encoding CI specifying
the communication channel, such as IP addresses and port numbers.
To begin, B calculates an element Z =
map_username_password_to_J(username || password) in J.
B then picks r randomly and uniformly according to the requirements
for group J scalars and calculates U = scalar_mult_cc(Z,r).
B then sends (name,U) to A.
A then queries its database for the user name and retrieves the
information as specified in section Section 4.6 , i.e. the set
(W,sigma,salt-derivation parameter [q,salt]). (Note that according
Haase Expires July 16, 2020 [Page 12]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
to the specification of the database lookup, such a set is provided,
even if there is no database entry for the given user name.)
A picks x randomly and uniformly according to the requirements for
group J scalaras and calculates X = scalarmult_cc(B,x) and WX =
scalarmult_ccv(W,x). A MUST abort if WX is the neutral element (this
indicates an error in the database contents). A then calculates
sid_cpace = (ssid || X).
A strips the sign information from WX to obtain WXs. A picks ya
randomly and uniformly. A then calculates G =
map_to_group_mod_neg(DSI1 || WXs || ZPAD || sid_cpace || CI) and Ya =
scalar_mult_cc(G,ya). I.e. WXs takes over the role of CPace's PRS
string.
The following operations will variate, depending on the type of salt-
derivation entry in the database.
If the salt derivation parameter is for strong AuCPace, A
calculates UQ = scalarmult_cc(U,q) and sends (UQ,X,sigma,Ya) to B.
B then calculates salt as salt =
strip_sign_information(inverse_scalarmult_cc(UQ,r)).
If the salt derivation parameter is for AuCPace, A sends
(salt,X,sigma,Ya) to B.
B then calculates w = IHF(sigma,username,password, salt) and XW =
scalarmult_ccv(X,w). B MUST abort, if XW is the neutral element I.
B strips the sign information from XW to obtain XWs. B picks yb
randomly and uniformly. B calculates sid_cpace=(ssid || X). B then
calculates G = map_to_group_mod_neg(DSI1 || XWs || ZPAD ||
sid_cpace || CI) and Yb = scalar_mult_cc(G,yb). B then calculates K
= scalar_mult_ccv(Ya,yb). B MUST abort if K is the encoding of the
neutral element I. Otherwise B sends Yb to A and proceeds as
follows. B strips the sign information from K, Ya and Yb to obtain
the strings Ks, Yas and Ybs by using the strip_sign_information()
function. B calculates ISK = H(DSI2 || sid_cpace || Ks || Yas ||
Ybs).
B calculates Tb = MAC(ISK,DSI4) and Ta_v = MAC(ISK,DSI3) and sends
(Yb,Tb) to A.
Upon reception of Yb, A calculates K = scalar_mult_ccv(Yb,ya). A
MUST abort if K is the neutral element I. If K is different from I,
A strips the sign information from K, Ya and Yb and calculates ISK =
H(DSI2 || sid_cpace || Ks || Yas || Ybs).
Haase Expires July 16, 2020 [Page 13]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
A calculates Tb_v = MAC(ISK,DSI4) and Ta = MAC(ISK,DSI3). If the
received authentication tag Tb did not match the verification value
Tb_v A MUST abort. Otherwise A sends Ta to B and returns the session
key SK = KDF(DSI5 || ISK || ssid).
When B receives T_a it compares this to the verification value Ta_v.
B MUST abort if Ta != Ta_v. Otherwise B returns the session key SK =
KDF(DSI5 || ISK || ssid).
Upon completion of this protocol, the session key SK returned by A
and B will be identical by both parties if and only if the supplied
input parameters ssid and CI match on both sides and the password
verifier in the server database for the user was calculated from the
clear-text password used by B.
6. Ciphersuites
This section documents AuCPace ciphersuite configurations. A
ciphersuite is REQUIRED to specify all of,
o a group modulo negation J with an associated
encode_group_element_mod_neg function
o scalar_mult_cc(P,s) and scalar_mult_ccv(P,s) functions operating
on encodings of elements P in J
o a mapping function map_to_group_mod_neg(r) converting byte strings
r into elements in J
o a strip_sign_information(Q) function operating on string
representations of elements Q
o a hash function H for generating the intermediate session key ISK
o A message authentication code MAC for authentication tag
generation.
o A key derivation function KDF for generating the final session key
SK
o and domain separation strings DSI1, DSI2, DSI3, DSI4, DSI5
Currently, detailed specifications are available for CPACE-
X25519-ELLIGATOR2_SHA512-SHA512.
Haase Expires July 16, 2020 [Page 14]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
+--------+----------------------+------------------+
| J | map_to_group_mod_neg | KDF |
+--------+----------------------+------------------+
| X25519 | ELLIGATOR2_SHA512 | SHA512 [RFC6234] |
+--------+----------------------+------------------+
Table 1: CPace Ciphersuites
6.1. CPACE-X25519-ELLIGATOR2_SHA512-SHA512
This cipher suite targets particularly constrained targets and
implements specific optimizations. It uses the group of points on
the Montgomery curve Curve25519 for constructing J. The base field F
is the prime field built upon the prime p = 2^255 - 19. The Diffie-
Hellmann protocol X25519 and the group are specified in [RFC7748].
The encode_group_element_mod_neg(P) is implemented by the
encodeUCoordinate(P) function defined in [RFC7748]. The neutral
element I is encoded as a 32 byte zero-filled string.
The domain separation strings are defined as DSI1 = "CPace25519-1",
DSI2 = "CPace25519-2", DSI3 = "AuCPace25-Ta", DSI4 = "AuCPace25-Tb",
DSI5 = "AuCPace25519". (ASCII encoding without ANSI-C style trailing
zeros).
Both, scalar_mult_cc and scalar_mult_ccv, are implemented by the
X25519 function specified in [RFC7748].
The secret scalars ya and yb used for X25519 shall be sampled as
uniformly distributed 32 byte strings.
The QI = inverse_scalarmult_cc(Q,s) function is implemented as
follows.
cs = scalar_cofactor_clearing(s)
csi = 1 / (8 * cs) % p.
QI = UNCLAMPED_X25519(Q, 8 * si).
Where the unclamped X25519 function ommits the setting of bit #254 in
the scalar from [RFC7748].
The map_to_group_mod_neg function for the CPace substep is
implemented as follows. First the byte length of the ZPAD zero-
padding string is determined such that len(ZPAD) = max(0,
H_block_SHA512 - len(DSI1 || PRS)), with H_block_SHA512 = 128 bytes.
Then a byte string u is calculated by use of u =
SHA512(DSI1||PRS||ZPAD||sid||CI). The resulting string is
Haase Expires July 16, 2020 [Page 15]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
interpreted as 512-bit integer in little-endian format according to
the definition of decodeLittleEndian() from [RFC7748]. The resulting
integer is then reduced to the base field as input to the Elligator2
map specified in [HASH2CURVE] to yield the secret generator G =
Elligator2(u).
The map_to_group_mod_neg function used for the strong AuCPace substep
for calculating the field element Z is implemented accordingly.
First the byte length of the ZPAD zero-padding string is determined
such that len(ZPAD) = max(0, H_block_SHA512 - len(DSI5 || password)),
with H_block_SHA512 = 128 bytes. Then a byte string u is calculated
by use of u = SHA512(DSI5||password||ZPAD||username). The resulting
string is interpreted as 512-bit integer in little-endian format
according to the definition of decodeLittleEndian() from [RFC7748].
The resulting integer is then reduced to the base field as input to
the Elligator2 map specified in [HASH2CURVE] to yield the secret
generator Z = Elligator2(u).
AuCPace25519 calculates an intermediate session key ISK of 64 bytes
length by a single invocation of SHA512(DSI2||ISK). Since the
encoding does not incorporate the sign from the very beginning Qs =
strip_sign_information(Q) == Q for this cipher suite.
AuCPace25519 calculates authentication tags and session key SK from
ISK of 64 bytes length by a single invocation of Ta =
SHA512(DSI3||ISK), Tb = SHA512(DSI4||ISK) and SK = SHA512(DSI5||ISK).
The following sage code could be used as reference implementation for
the mapping and key derivation functions.
<CODE BEGINS>
def littleEndianStringToInteger(k):
bytes = [ord(b) for b in k]
return sum((bytes[i] << (8 * i)) for i in range(len(bytes)))
def map_to_group_mod_neg_CPace25519(sid, PRS, CI):
m = hashlib.sha512()
p = 2^255 - 19
H_block_SHA512 = 128
DSI1 = b"CPace25519-1"
ZPAD_len = max(0,H_block_SHA512 - len(CI) - len(PRS))
ZPAD = ZPAD_len * "\0"
m.update(DSI1)
m.update(PRS)
m.update(ZPAD)
Haase Expires July 16, 2020 [Page 16]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
m.update(sid)
m.update(CI)
u = littleEndianStringToInteger(m.digest())
return map_to_curve_elligator2_curve25519(u % p)
def map_to_group_mod_neg_StrongAuCPace25519(username, password):
# Map username and password to field element Z
DSI = b"AuCPace25519"
F = GF(2^255 - 19)
m = hashlib.sha512()
H_block_SHA512 = 128
ZPAD_len = max(0,H_block_SHA512 - len(DSI) - len(password))
ZPAD = ZPAD_len * "\0"
m.update(DSI)
m.update(password)
m.update(ZPAD)
m.update(username)
u = littleEndianStringToInteger(m.digest())
u = F(u)
Z = map_to_curve_elligator2_curve25519(u)
return Z
def Inverse_X25519(u_string,scalar_string):
OrderSubgroup = 2^252 + 27742317777372353535851937790883648493
SF = GF(OrderSubgroup)
coFactor = SF(8)
scalar = clampScalar25519(scalar_string)
inverse_scalar = 1 / (SF(scalar) * coFactor)
inverse_scalar_shifted = Integer(inverse_scalar) * 8
return X25519(u_string,inverse_scalar_shifted,withClamping=0)
def generate_ISK_CPace25519(sid,K,Ya,Yb):
m = hashlib.sha512(b"CPace25519-2")
m.update(sid)
m.update(K)
m.update(Ya)
m.update(Yb)
return m.digest()
def MAC_SK_AuCPace25519(ISK):
DSI3 = b"AuCPace25-Ta"
DSI4 = b"AuCPace25-Tb"
DSI5 = b"AuCPace25519"
m = hashlib.sha512(DSI3)
m.update(ISK)
Ta = m.digest()
Ta = Ta[:16]
Haase Expires July 16, 2020 [Page 17]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
m = hashlib.sha512(DSI4)
m.update(ISK)
Tb = m.digest()
Tb = Tb[:16]
m = hashlib.sha512(DSI5)
m.update(ISK)
SK = m.digest()
return (Ta,Tb,SK)
<CODE ENDS>
Due to its use in Ed25519 [RFC8032], SHA512 is considered to be the
natural hash choice for Curve25519. The 512 bit output of SHA512
moreover allows for removing any statistical bias stemming from the
non-canonical base field representations, such that the overhead of
the HKDF_extract/HKDF_expand sequences from [HASH2CURVE] are
considered not necessary (in line with the assessments regarding
Curve25519 in [HASH2CURVE]).
7. Security Considerations
A security proof covering AuCPace is found in [HL18].
Elements received from a peer MUST be checked by a proper
implementation of the scalar_mult_ccv method. Failure to properly
validate group elements can lead to attacks. The Curve25519-based
cipher suite employs the twist security feature of the curve for
point validation. As such, it is mandatory to check that all low-
order points on both the curve and the twist are mapped on the
neutral element by the X25519 function. Corresponding test vectors
are provided in the appendix.
The choices of random numbers MUST be uniform. Randomly generated
values (e.g., ya, r, q and yb) MUST NOT be reused.
User credential database lookups for AuCPace might not be executed in
non-constant time. In this case, AuCPace does not provide full
confidentiality with respect to hiding the presence or abscence of a
given user's entry in the database. The fact that in case of
abscence of a record random values are provided instead should be
considered only a mitigation regarding user-enumeration attacks.
If AuCPace is used as a building block of higher-level protocols, it
is RECOMMENDED that ssid is generated by the higher-level protocol
and passed to AuCPace. It is RECOMMENDED that ssid, is generated by
sampling ephemeral random strings.
Haase Expires July 16, 2020 [Page 18]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
AuCPace generates the session key SK by a hash function operation on
the intermediate session key ISK. If SK is possibly to be used for
many different sub-protocols and purposes, such as e.g. in TLS1.3, it
is RECOMMENDED to apply SK to a stronger KDF function, such as HKDF
from [RFC5869].
In case that side-channel attacks are to be considered practical for
a given application, it is RECOMMENDED to focus side-channel
protections such as masking and redundant execution (faults) on the
process of calculating the secret generator G. The most critical
aspect to consider is the processing of the first block of the hash
that includes the PRS string. The CPace protocol construction
considers the fact that side-channel protections of hash functions
might be particularly resource hungry. For this reason, AuCPace aims
at minimizing the number of hash functions invocations in the
specified mapping method.
AuCPace is designed also for compatibility with legacy-style user-
credential databases which directly store the output of iterated hash
functions w = IHF(salt, username, password). If AuCPace is used in
this configuration, AuCPace provides only the security guarantees of
a balanced PAKE. I.e. in this case, user impersonation attacks
become feasible if the user credential database is stolen. It is
RECOMMENDED to migrate legacy-style databases to an AuCPace format,
by replacing w with W = scalarmult_cc(B,w).
It is RECOMMENDED to use password verifiers for "strong AuCPace" on
such a migrated database upon user password changes in order to
obtain pre-computation attack resistance.
AuCPace is proven secure under the hardness of the computational
Diffie-Hellmann (CDH) and the computational Double-Diffie-Hellmann
assumptions in the group J. Still, even for the event that large-
scale quantum computers (LSQC) will become available, AuCPace forces
an active adversary to solve one CDH per password guess. Using the
wording suggested by Steve Tobtu on the CFRG mailing list, AuCPace is
"quantum-annoying". For the event that LSQC become ubiquitous, it is
suggested to consider the replacement of the group operations used in
AuCPace with a corresponding commutative group actions on isogenies,
such as suggested in [IsogenyPAKE]. The fact that CPace does not
require arbitrary group operations but only the operation set
available in a group modulo negation allows for commutative isogeny-
based group actions cryptography as a drop-in replacement.
Strong AuCPace is pre-computation attack resistant under the CDH and
One-More-DH assumption setp. While the rest of the AuCPace protocol
is quantum-annoying, solving a single discrete logarithm problem will
reveal the salt-derivation parameter q to the adversary and allow him
Haase Expires July 16, 2020 [Page 19]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
for pre-computing a rainbow table for a given user name. In order to
provide resistance with respect to LSQC-based attacks, a post-quantum
instance of an olibvious pseudo-random function (OPRF) would have to
be used as replacement of the Diffie-Hellman OPRF construction as
used by strong AuCPace.
8. IANA Considerations
No IANA action is required.
9. Acknowledgments
Thanks to the members of the CFRG for comments and advice.
10. References
10.1. Normative References
[HASH2CURVE]
Faz-Hernandez, A., Scott, S., Sullivan, N., Wahby, R., and
C. Wood, "draft-irtf-cfrg-hash-to-curve-05", 2019.
IRTF draft standard
[IEEE1363]
IEEE, ""Standard Specifications for Public Key
Cryptography", IEEE 1363", 2000.
IEEE 1363
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/RFC2119, March 1997,
<https://www.rfc-editor.org/info/rfc2119>.
[RFC5869] Krawczyk, H. and P. Eronen, "HMAC-based Extract-and-Expand
Key Derivation Function (HKDF)", RFC 5869,
DOI 10.17487/RFC5869, May 2010,
<https://www.rfc-editor.org/info/rfc5869>.
[RFC6234] Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms
(SHA and SHA-based HMAC and HKDF)", RFC 6234,
DOI 10.17487/RFC6234, May 2011,
<https://www.rfc-editor.org/info/rfc6234>.
[RFC7748] Langley, A., Hamburg, M., and S. Turner, "Elliptic Curves
for Security", RFC 7748, DOI 10.17487/RFC7748, January
2016, <https://www.rfc-editor.org/info/rfc7748>.
Haase Expires July 16, 2020 [Page 20]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
[RFC7914] Percival, C. and S. Josefsson, "The scrypt Password-Based
Key Derivation Function", RFC 7914, DOI 10.17487/RFC7914,
August 2016, <https://www.rfc-editor.org/info/rfc7914>.
[RFC8032] Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital
Signature Algorithm (EdDSA)", RFC 8032,
DOI 10.17487/RFC8032, January 2017,
<https://www.rfc-editor.org/info/rfc8032>.
[RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
May 2017, <https://www.rfc-editor.org/info/rfc8174>.
10.2. Informative References
[HL18] Haase, B. and B. Labrique, "AuCPace. PAKE protocol
tailored for the use in the internet of things.", Feb
2018.
eprint.iacr.org/2018/286
[IsogenyPAKE]
Taraskin, O., Soukharev, V., Jao, D., and J. LeGrow, "An
Isogeny-Based Password-Authenticated Key Establishment
Protocol.", Sep. 2018.
eprint.iacr.org/2018/886
[RFC8265] Saint-Andre, P. and A. Melnikov, "Preparation,
Enforcement, and Comparison of Internationalized Strings
Representing Usernames and Passwords", RFC 8265,
DOI 10.17487/RFC8265, October 2017,
<https://www.rfc-editor.org/info/rfc8265>.
Appendix A. AuCPace25519 Test Vectors
A.1. Inverse X25519 test vectors
Haase Expires July 16, 2020 [Page 21]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
######################## /inverse X25519 ##########################
Z :
0x5d7189be6192ffccdb80902ac26c5d38592822a761c7268007200a232a4cd841
r (random scalar input for X25519):
0xe8a70b556490ecdbd52c2927464d4eff557807496af234fc496c9f4221bd4423
U = X25519(Z,r):
0x3e6377b3410a60d0ca65190963ad6dce3aeae178aafad369dc2a59c59acc3ceb
IU = inverse_X25519(U)
0x5d7189be6192ffccdb80902ac26c5d38592822a761c7268007200a232a4cd841
Z :
0x73583bc520f4b9e1245e29b92e6b12dc1c8bc0d9b018a1e2626875db2774974
r (random scalar input for X25519):
0xe22cb510bd45fc6cbcb929353777925d152c2a9a5b924715d7480aad8b64d447
U = X25519(Z,r):
0x545040a9ac1cc13a627dddc0ab4ef0b9128d54476aa98727bd45a86ea2d6de24
IU = inverse_X25519(U)
0x73583bc520f4b9e1245e29b92e6b12dc1c8bc0d9b018a1e2626875db2774974
######################## inverse X25519/ ##########################
A.2. Strong AuCPace25519 salt test vectors
Haase Expires July 16, 2020 [Page 22]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
############ /salt derivation for strong AuCPace ##################
DSI5 = 417543506163653235353139 string ('AuCPace25519') of len(12)
pw = 70617373776f7264 ('password') string of len(8)
ZPAD = 108 zero bytes
name = 757365726e616d65 ('username') string of len(8)
u = SHA512(DSI||password||ZPAD||username) as 512 bit int:
0xfec497749d249426e4895e05d0bb4f565aa4423f33d19e6b20aa3837eb77d16e
<<256
+ 0xb8f5b1b51c1557c088356d7ca09bd78f259f1d5f4041d466f4edd40f041a0bb3
u as reduced base field element coordinate:
0xa242d046f835586749962599c699e609a00f2c0f15f584dce322c5bf7e327be
Z = Elligator2(u) as base field element coordinate:
0x3c01681e4c6d4a43b527c789bcf6046b53ac14c516dfbbbb0f8916826b537f4b
salt-derivation parameter q:
0xf40546b4544bae5fcc564dc917407ee02300312c8fd558a0b37f48322277962e
ZQ = X25519(Z,q):
0x77412819cad958e14d4a4c09c129456b90733fd13f337ffed6c0a30f7c3a9a50
Blinding scalar r:
0x1698d57693a684a957ae0492bade0dfd6a261dfa2bb4a74c6b0b8b84acf082a8
U = X25519(Z,r):
0xaf2a058fbd974a6122f8316323060d808705701971666121477eba97386a977
UQ = X25519(U,q):
0x610270daff540b5b7adec057e0f8fa1bfe7687649d95f65560a77a2be70e6cb5
ZQ = inverse_X25519(Z,r)
0x77412819cad958e14d4a4c09c129456b90733fd13f337ffed6c0a30f7c3a9a50
############ salt derivation for strong AuCPace/ ##################
A.3. Test vectors for AuCPace password verifier
Haase Expires July 16, 2020 [Page 23]
Internet-Draf(strong) AuCPace, an augmented composable PAKE January 2020
###################### /Password verifier #########################
Inputs:
Password: 'password', length 8
User Name: 'username', length 8
Z for username, password:
0x3c01681e4c6d4a43b527c789bcf6046b53ac14c516dfbbbb0f8916826b537f4b
q:
0xf40546b4544bae5fcc564dc917407ee02300312c8fd558a0b37f48322277962e
Salt value salt = X25519(Z,q):
0x77412819cad958e14d4a4c09c129456b90733fd13f337ffed6c0a30f7c3a9a50
####################################################################
Concatenated input to scrypt as password parameter:
'passwordusername', length 16
Password hash w from scrypt with N=1<<15, r=8, p=1
f2b54e7325a1a4fdc88a7899cfe68aee41ebda4145ba93480bc295c84a0832d8
Password verifier W = X25519(w)
0x12511fcfc70fe9c3a8e72b347d7de52927fc253b83edc8271a5e90ecdf958f57
###################### Password verifier/ #########################
Author's Address
Bjoern Haase
Endress + Hauser Liquid Analysis
Email: bjoern.m.haase@web.de
Haase Expires July 16, 2020 [Page 24]