One document matched: draft-wilkinson-afs3-rxgk-afs-02.xml
<?xml version="1.0"?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd" [
<!ENTITY I-D.draft-wilkinson-afs3-rxgk SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.draft-wilkinson-afs3-rxgk-00.xml">
<!ENTITY I-D.draft-brashear-afs3-pts-extended-names SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.brashear-afs3-pts-extended-names.xml">
<!ENTITY I-D.draft-benjamin-extendedcallbackinfo SYSTEM "http://xml.resource.org/public/rfc/bibxml3/reference.I-D.benjamin-extendedcallbackinfo.xml">
<!ENTITY RFC2119 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.2119.xml">
<!ENTITY RFC2743 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.2743.xml">
<!ENTITY RFC3961 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.3961.xml">
<!ENTITY RFC4402 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4402.xml">
<!ENTITY RFC4506 SYSTEM "http://xml.resource.org/public/rfc/bibxml/reference.RFC.4506.xml">
]>
<?rfc symrefs='yes'?>
<?rfc toc='yes'?>
<?rfc compact='yes'?>
<?rfc subcompact='no'?>
<rfc category="info" ipr="trust200902" docName="draft-wilkinson-afs3-rxgk-afs-02" submissionType="independent">
<front>
<title>Integrating rxgk with AFS</title>
<author surname="Wilkinson" fullname="Simon Wilkinson">
<organization abbrev="YFS">Your File System Inc</organization>
<address>
<email>simon@sxw.org.uk</email>
</address>
</author>
<date month="March" year="2013"/>
<abstract>
<t>
This document describes how the new GSSAPI-based rxgk security class
for RX is integrated with the AFS application protocol. It describes a
number of extensions to the basic rxgk protocol, clarifies a number
of implementation issues, and provides values for the
application-specific elements of rxgk.
</t>
</abstract>
</front>
<middle>
<section title="Introduction">
<t><xref target="I-D.wilkinson-afs3-rxgk">rxgk</xref> is a new
<xref target="RFC2743">GSSAPI-based</xref> security layer for the
<xref target="RX">RX</xref> remote procedure call system. The rxgk
specification details how it may be used with a generic RX application.
This document provides additional detail specific to integrating
rxgk with the AFS-3 distributed file system.
</t>
<section title="The AFS-3 Distributed File System">
<t>
AFS-3 is a global distributed network file system. The system is
split into a number of cells, with a cell being the administrative
boundary. Typically an organisation will have one (or more) cells, but
a cell will not span organisations. Each cell contains a number of
fileservers which contain collections of files ("volumes") which they
make available to clients using the AFS-3 protocol. Clients access
these files using a service known as the cache manager.
</t>
<t>
In order to determine which server a particular file is located upon,
the cache manager looks up the location in the
volume location database (vldb) by contacting the vlserver.
Each cell has one or more vlservers, which are synchronised using
an out-of-band mechanism.
</t>
</section>
<section title="rxgk and AFS">
<t>
This document describes special integration steps needed to use
rxgk with AFS-3 database servers (the PR and VL rx services)
and file servers (the RXAFS, RXAFSCB, and AFSVol rx services),
as well as specifying application-specific portions of the rxgk
specification for use by these services. Other AFS-3 services
are not covered by this document; the generic rxgk document
applies to them.
AFS-3 differs from the standard rxgk implementation in that it
does not require GSSAPI negotiation with each server. Instead,
a client performs GSSAPI negotiation just once (with the vlserver),
receiving a token usable with any server in the cell that has the
cell-wide key. Traditional AFS rxkad authentication required that
the cell-wide key be distributed to all servers in the cell, both
database servers and file servers. rxgk can operate in such a
fashion, with the cell-wide key shared amongst all servers.
</t>
<t>
For more complex cell topologies, rxgk also supports configurations
where (some) file servers do not have the cell-wide key, by means
of an extended version of the CombineTokens RPC.
This new RPC, AFSCombineTokens, takes a server identifier,
and will return a token encrypted with a key for a specific server.
AFSCombineTokens also provides support for indicating whether
a specific server is rxgk capable, allowing cells to securely migrate
to rxgk from other security mechanisms.
</t>
<t>
We also define mechanisms for securing the callback channel that
is created between fileserver and client.
</t>
</section>
<section title="Requirements Language">
<t>
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in
<xref target="RFC2119">RFC 2119</xref>.
</t>
</section>
</section>
<section title="Security Index">
<t>
When used within the AFS protocol, rxgk has an RX securityIndex value
of 4.
</t>
</section>
<section title="Key Negotiation">
<t>
An AFS cell wishing to support rxgk MUST run an rxgk key negotiation
service, as specified in <xref target="I-D.wilkinson-afs3-rxgk"/>,
on each of its vlservers. The service MUST listen on the same port as
the vlserver.
</t>
<t>
The GSS identity afs-rxgk@_afs.<cellname> of nametype
GSS_C_NT_HOSTBASED_SERVICE
is the acceptor identity for this service. Where multiple
vlservers exist for a single cell, all of these servers must
have access to the key material for this identity, which MUST be
identical across the cell. Clients MAY use the presence of this
identity as an indicator of rxgk support for a particular cell. Clients
that wish to support cells using other rx security objects MAY downgrade
if this identity is not available.
</t>
<t>
Tokens returned from the GSSNegotiate call MUST only be used with
database servers. Tokens for fileservers MUST be obtained by
calling AFSCombineTokens before each server is contacted.</t>
<section title="The AFSCombineTokens Operation">
<t>
AFS extends the existing CombineTokens operation to provide a general
token manipulation service. This operation takes a user
token, an optional cache manager token, options for enctype and
security level negotiation with the server,
and a destination identifier. It
returns a token specific to the specified destination, and a structure
containing some cleartext information describing the returned token.
</t>
<artwork>
AFSCombineTokens(IN RXGK_Data *token0,
IN RXGK_Data *token1,
IN RXGK_CombineOptions *options,
IN afsUUID destination,
OUT RXGK_Data *new_token,
OUT RXGK_TokenInfo *token_info) = 3;
</artwork>
<list style="hanging" hangIndent="6">
<t hangText="token0:">An rxgk token obtained using the
GSSNegotiate RPC.</t>
<t hangText="token1:">Either an rxgk token obtained using the
GSSNegotiate RPC, or empty (zero-length).</t>
<t hangText="options:">An RXGK_CombineOpeions structure containing
a list of enctypes acceptable to the client and a list of
security levels acceptable to the client.</t>
<t hangText="destination:">The UUID of the server new_token is
intended for. Fileserver UUIDs may be obtained from the VLDB
in the same call that returns their addresses.</t>
<t hangText="new_token:">The output rxgk token, or empty
(zero-length).</t>
<t hangText="token_info:">Information describing the returned token.</t>
</list>
<t>The AFSCombineTokens call MUST only be performed over a secured rxgk
connection. AFSCombineTokens MUST NOT be offered over an
RXGK_LEVEL_CLEAR connection.
Servers MUST reject all attempts to perform this operation
over channels that do not offer integrity protection.</t>
<t>Clients which are caching the results of RPCs on behalf of
multiple users (such as a traditional AFS Cache Manager), SHOULD
provide both the user's token (as token0) and a token generated
from an identity that is private to the cache manager (as token1).
This prevents a user from poisoning the cache for other users.
Recommendations on keying cache managers are contained in
<xref target="cm-keying"/>.</t>
<t>Clients which are working on behalf of a single user can provide
an empty token1, but MUST use AFSCombineTokens to obtain a
destination specific token for each fileserver they contact.</t>
<t>Clients using a printed token (see <xref target="printing"/>) MUST
provide that token as token0. token1 MUST be empty. Printed tokens
cannot be combined with any other token, and servers MUST reject
attempts to do so.</t>
<t>If the server is unable to perform the AFSCombineTokens operation
with the given arguments, a nonzero value is returned in the
errorcode field of token_info; errorcode is zero for a successful
AFSCombineTokens operation. If errorcode is nonzero, the values
of the other fields in token_info and the value of new_token
are undefined.</t>
<t>If the returned token is zero-length, then the destination does not
support rxgk, and the client MAY fall back to using a different
authentication mechanism for that server. An rxgk capable client
operating within an rxgk enabled cell MUST NOT downgrade its
choice of security layer in any other situation.</t>
<t>Other aspects of the operation of AFSCombineTokens, including the
values for the errorcode field of token_info and the combination
of keys and tokens, are the same as the CombineTokens RPC, documented in
CombineTokens call, documented in
<xref target="I-D.wilkinson-afs3-rxgk"/>.</t>
</section>
</section>
<section title="Tokens">
<section title="Container" anchor="container">
<t>rxgk tokens for AFS take the form of some key management data,
followed by an encrypted data blob. The key management data (a
version number, followed by an <xref target="RFC3961"/>
encryption type) allows the server receiving a token to identify which
pre-shared key has been used to encrypt the core token data.
</t>
<artwork>
struct RXGK_TokenContainer {
afs_int32 kvno;
afs_int32 enctype;
opaque encrypted_token<>;
};
</artwork>
<t>The RXGK_TokenContainer structure is XDR encoded and transported
within the 'token' field of the RXGK_ClientInfo structure specified
in <xref target="I-D.wilkinson-afs3-rxgk"/>.</t>
</section>
<section title="Token Encryption">
<t>Token contents are encrypted using a pre-shared key. rxgk supports
both the use of a single cell-wide key and the use of per-server
keys. The cell-wide key must be installed on all servers which are
capable of accepting cell-wide tokens. Cell-wide keys should be for
a selected RFC3961 encryption mechanism that is supported by all
servers within the cell that will accept cell-wide tokens.
Per-server keys should be for an
encryption mechanism that is supported by both the destination
server and the negotiation service. The management of per-server
keys is discussed in more detail in <xref target="per-server-keys"/>.</t>
<t>Key rollover is permitted by means of a key version number. When the
key is changed, a different key version number MUST be selected. Servers
SHOULD accept tokens using old keys until the lifetime of all
existing tokens has elapsed.</t>
<t>Encryption is performed over the XDR encoded RXGK_Token structure,
using the RFC3961 encrypt operation, with a key usage value of
RXGK_SERVER_ENC_TOKEN (defined in
<xref target="I-D.wilkinson-afs3-rxgk" />).
The enrypted data is stored in the
encryted_token field of the TokenContainer structure described in
<xref target="container"/>.</t>
</section>
<section title="Token Contents">
<t>The token itself contains the information expressed by the following
RPC-L:</t>
<artwork>
struct RXGK_Token {
afs_int32 enctype;
opaque K0<>;
RXGK_Level level;
rxgkTime start_time;
afs_int32 lifetime;
afs_int32 bytelife;
rxgkTime expirationtime;
struct PrAuthName identities<>;
};
</artwork>
<list style="hanging" hangIndent="6">
<t hangText="enctype:">The RFC3961 encryption type of the session key
contained within this ticket.</t>
<t hangText="K0:">The session key (see <xref target="I-D.wilkinson-afs3-rxgk"/>
for details of how this key is negotiated between client and negotiation
service).</t>
<t hangText="level:">The security level, as defined in
<xref target="I-D.wilkinson-afs3-rxgk"/>, that MUST be used for this
connection.</t>
<t hangText="start_time:">The time at which the token's validity begins.
Servers MUST reject attempts to
use tokens with a start_time value later than the current time.</t>
<t hangText="lifetime:">The maximum number of seconds that a
key derived from K0 may be used for, before the connection is rekeyed.
If 0, keys have no time-based limit.</t>
<t hangText="bytelife:">The maximum amount of data (expressed as
the log base 2 of the number of bytes) that may be transferred
using a key derived from K0
before the connection is rekeyed. If 0, there is no data-based limit on
key usage.</t>
<t hangText="expirationtime:">The time (expressed as an rxgkTime)
beyond which this token may no longer be used. Servers MUST
reject attempts to use connections secured with this token after
this time. A time of 0 indicates that this token never
expires.</t>
<t hangText="identities:">A list of identities represented by this
token. struct PrAuthName is the identity structure defined in
<xref target="I-D.brashear-afs3-pts-extended-names"/>.</t>
</list>
</section>
</section>
<section title="Authenticator Data">
<t>The appdata opaque within the RXGK_Authenticator structure contains the results
of XDR encoding the RXGK_Authenticator_AFSAppData structure. The uuid field
contains the UUID of the client.</t>
<artwork>
struct RXGK_Authenticator_AFSAppData {
afsUUID uuid;
};
</artwork>
</section>
<section title="Client Tokens" anchor="client-tokens">
<t>In order to protect users of a multi-user cache manager from each
other, it must be impossible for an individual user to determine the
key used to protect operations which affect the cache. This requires
that the cache manager have key material of its own which can be
combined with that of the user. This functionality is provided by
the AFSCombineTokens call specified earlier in this document. However,
this call requires that a cache manager have access to a token for this
purpose.</t>
<section title="Keyed Clients" anchor="cm-keying">
<t>When a host already has key material for a GSSAPI mechanism
supported by rxgk, that material MAY be used to key the client.
The client simply calls the rxgk negotiation service using the
relevant material, and obtains a token. The client SHOULD frequently
regenerate this token, to avoid combined tokens having unnecessarily
close expiration times. The client SHOULD NOT regenerate this token
so often so as to place excessive load on the vlservers.</t>
<t>It is recommended that identities created specifically for use by
a cache manager have the name afs3-callback@<hostname> where
<hostname> is the fully qualified domain name of the cache
manager.</t>
</section>
<section title="Unkeyed Clients">
<t>When a client has no key material, it is possible that an
anonymous GSSAPI connection may succeed. Clients MAY attempt to
negotiate such a connection by calling GSS_Init_sec_context()
with the <xref target="RFC2743">anon_req_flag</xref> and the
default credentials set.</t>
</section>
</section>
<section title="Server to Server Communication">
<t>A number of portions of the AFS protocol require that servers
communicate amongst themselves. To secure this with rxgk we require
both a mechanism of generating tokens for these servers to use, and
a definition of which identities are permitted for authorisation
purposes. We refer to the process of forging tokens for local use,
given access to the cell-wide pre-shared key, as "token printing".
</t>
<section title="Token Printing" anchor="printing">
<t>A server with access to the cell-wide pre-shared key may print its
own tokens for server to server access. To do so, it should construct
a token with suitable values. The list of identities in such a token
MUST be empty. It can then encrypt this token using the pre-shared key,
and use it in the same way as a normal rxgk token. The receiving server
can identify it is a printed token by the empty identity list.</t>
<t>The session key within a printed token MUST use the same encryption
type as the pre-shared key. When connecting to a fileserver, a client
SHOULD use the AFSCombineTokens service as discussed above to ensure that
they are using the correct key for the fileserver.</t>
</section>
</section>
<section title="Declaring rxgk Support for a Fileserver">
<t>The AFSCombineTokens call has specific behaviour when a destination
endpoint does not support rxgk. Implementing this behaviour requires
that the vlserver be aware of whether a fileserver supports rxgk.
</t>
<t>Fileservers currently register with the vlserver using the
VL_RegisterAddrs RPC. Fileservers which support rxgk MUST call this
RPC over a rxgk protected connection. The vlserver then infers rxgk
support from the rx security layer used in registration. To prevent
downgrade attacks, once a fileserver has
registered as being rxgk capable, the vlserver MUST NOT remove that
registration without administrator intervention.
</t>
<t>Once a fileserver has been marked as supporting rxgk, VL_RegisterAddrs
calls for that fileserver MUST only be accepted over an rxgk
protected connection. vlservers MUST only accept calls to
VL_RegisterAddrs from a printed token, an administrator, or the
identity registered for the fileserver using a prior call to
VL_RegisterAddrsandKey.
</t>
<!-- XXX - we need to define a VL_ RPC which can be used to remove
the rxgk capable marking -->
</section>
<section title="Per Server Keys">
<t>The provisioning of servers with their own keys,
rather than the cell-wide
master key, requires the ability to maintain a directory of these keys
on the vlserver, so that the AFSCombineTokens RPC can encrypt the
outgoing token with the correct key. The manner in which this directory
is maintained is left to the implementor, who MAY decide to use a
manual, or out of band, key management system. Otherwise, the automated
keying mechanism described as follows will be used.
</t>
<t>Implementations supporting automatic key management through the AFS-3
protocol MUST provide the VL_RegisterAddrsAndKey RPC (similar to the
VL_RegisterAddrs RPC). This RPC is called by a fileserver to
register itself with the VLDB; it MUST be called over an rxgk-secured
connection. For the purpose of this RPC, the fileserver acts as the
client and the vlserver as the server. Once the RPC completes, the
client can generate a key to be used as the fileserver's server key.</t>
<t>vlservers MUST NOT permit calls to VL_RegisterAddrsAndKey for UUIDs
which already exist within the vldb, unless that UUID already has
a server-specific key registered. When a new fileserver first registers
with the vldb using VL_RegisterAddrsAndKey, the vlserver MUST store the
identity used to make this connection. The vlserver MUST only permit
subsequent calls to VL_RegisterAddrsAndKey for this UUID when they come
from this identity, an administrator, or a printed token.
New fileserver UUIDs register themselves with
the vldb in a "leap of faith", binding a GSSAPI identity to the
fileserver UUID for future authenticated operations.
Fileservers SHOULD use VL_RegisterAddrsAndKey to rekey themselves
periodically, in accordance with key lifetime best practices.</t>
<t>The VL_RegisterAddrsAndKey RPC is described by the following RPC-L:
<artwork>
struct RXGK_ServerKeyDataRequest {
afs_int32 enctypes<>;
opaque nonce1[20];
};
struct RXGK_ServerKeyDataResponse {
afs_int32 enctype;
afs_int32 kvno;
opaque nonce2[20];
};
typedef opaque keyDataRequest<>;
typedef opaque keyDataResponse<>;
VL_RegisterAddrsAndKey(
IN afsUUID *uuidp,
IN afs_int32 spare1,
IN bulkaddrs *ipaddr,
IN afs_int32 secIndex,
IN keyDataRequest *request,
OUT keyDataResponse *response) = XXX;
</artwork>
</t>
<list style="hanging" hangIndent="6">
<t hangText="uuidp:">The fileserver's UUID.</t>
<t hangText="spare1:">Unused. (Clients SHOULD pass zero.)</t>
<t hangText="ipaddr:">The list of addresses to register as belonging
to this fileserver.</t>
<t hangText="secIndex:">The index of the security mechanism for
which a key is being set. For rxgk, this value MUST be 4.</t>
<t hangText="keyDataRequest:">An opaque blob of data, specific to
the security mechanism defined by secIndex. For rxgk, it is
the XDR-encoded representation of an RXGK_ServerKeyDataRequest
structure.</t>
<t hangText="keyDataResponse:">An opaque blob of data, specific to
the security mechanism defined by secIndex. For rxgk, it is
the XDR-encoded representation of an RXGK_ServerDataResponse
structure.</t>
</list>
<t>The client provides, in the RXGK_ServerKeyDataRequest structure, a list
of the RFC3961 encryption types that it will accept as a server key. It
also provides a nonce containing 20 random data bytes.</t>
<t>The server selects an encryption type shared by it and the client, and
returns that, along with 20 bytes of random data that it has generated,
in RXGK_ServerKeyDataResponse. If there is no common encryption type,
then the server MUST fail the request.</t>
<t>The server key can then be derived by both client and server using
<artwork>
random-to-key(PRF+(K0, K, nonce1 || nonce2));
</artwork>
</t>
<t>random-to-key is the function specified by the RFC3961 profile of the
encryption type chosen by the server and returned in enctype.</t>
<t>PRF+ is the function of that name specified by
<xref target="RFC4402"/>.</t>
<t>K0 is the master key of the current rxgk session, as originally
determined by the GSSNegotiate call.</t>
<t>K is the key generation seed length as specified in enctype's RFC3961
profile.</t>
<t>|| is the concatenation operation.</t>
</section>
<section title="Securing the Callback Channel">
<t>AFS has traditionally had an unprotected callback channel. However,
extended callbacks <xref target="I-D.benjamin-extendedcallbackinfo" />
require a mechanism for ensuring that callback
breaks and, critically, data updates, are protected. This requires
that there is a strong connection between the key material used
initially to perform the RPC, and that which is used to protect
any resulting callback. We achieve this using the cache manager
token discussed in <xref target="cm-keying" />,
which is required in order for a client to
accept secure callbacks.
</t>
<t>A cache manager may set a key for secure callbacks by issuing
the following RPC (in the RXAFS service):</t>
<artwork>
RXAFS_SetCallBackKey(afs_int32 securityIndex,
opaque mech_data<>) = XXX;
</artwork>
<list style="hanging" hangIndent="6">
<t hangText="securityIndex:">The securityIndex of the mechanism for
which this key is being set. In the rxgk case, this will be
rxgk's security index, 4.</t>
<t hangText="mech_data:">This contains the security object specific
data. In rxgk's case this is an XDR encoded RXGK_Token structure.</t>
</list>
<t>When used with rxgk, this RPC MUST be performed over an rxgk protected
connection established using solely the cache manager's token.
This connection
MUST have a security level of RXGK_LEVEL_CRYPT.</t>
<t>If a fileserver receives an RXAFS_SetCallBackKey call
protected with a different
cache manager identity than the previous call from that client, it MUST
break all secure callbacks held by that client using the old key before
this RPC completes.</t>
<t>Only RPCs issued over an rxgk protected connection should receive rxgk
protected callbacks.</t>
<t>The fileserver MUST only send rxgk protected callbacks when one of the
identities performing the RPC establishing that callback matches the
identity associated with that clients callback channel.</t>
</section>
<section anchor="IANA" title="IANA Considerations">
<t>This memo includes no request to IANA.</t>
</section>
<section anchor="AFSReg" title="AFS-3 Registry Considerations">
<t>This document requrests that the AFS-3 registry allocate code
points for the new RPCs AFSCombineTokens (for the RXGK service),
RegisterAddrsAndKey (for the VL service), and SetCallBackKey (for the
RXAFS service).</t>
</section>
<section title="Security Considerations">
<section title="Downgrade attacks">
<t>Using the presence of a GSSAPI key to determine a cell's ability to
perform rxgk is vulnerable to a downgrade attack, as an attacker may
forge error responses. Cells which no longer support rxkad
should remove their afs@REALM and afs/cell@REALM Kerberos keys.
</t>
</section>
<section title="Per Server Keys" anchor="per-server-keys">
<t>The mechanism for automatically registering per-server keys is
potentially vulnerable, as it trades a short-lived key (the rxgk
session key, which protects the key exchange) for a long-lived one
(the server key). There is precedent for this sort of key exchange,
such as when using kadmin to extract a new kerberos keytab.
</t>
</section>
<section title="Combined Key Materials">
<t>As described in <xref target="client-tokens" />, combined tokens
are used to prevent cache
poisoning attacks on multi-user systems. In order for this protection
to be effective, cache managers MUST NOT provide user access to
keys produced through the combine tokens operation, unless those keys
will not be used by the cache manger itself.
</t>
</section>
</section>
</middle>
<back>
<references title="Informational References">
<reference anchor="RX">
<front>
<title>RX protocol specification</title>
<author initials="N." surname="Zeldovich" fullname="Nickolai Zeldovich">
<organization/>
</author>
</front>
<format type="HTML" target="http://web.mit.edu/kolya/afs/rx/rx-spec"/>
</reference>
&I-D.draft-benjamin-extendedcallbackinfo;
</references>
<references title="Normative References">
&I-D.draft-brashear-afs3-pts-extended-names;
&I-D.draft-wilkinson-afs3-rxgk;
&RFC2119;
&RFC2743;
&RFC3961;
&RFC4402;
&RFC4506;
</references>
<section title="Acknowledgements">
<t>
rxgk has been the work of many contributors over the years. A partial
list is contained in the <xref target="I-D.wilkinson-afs3-rxgk" />.
All errors and omissions are, however, mine.
</t>
</section>
<section title="Changes">
<section title="Since 00">
<t>Add references to RX and XDR specifications.</t>
<t>Add introductory material on AFS.</t>
<t>Change expirationTime to be expressed using the rxgkTime type.</t>
<t>Document how encryption types are chosen for printed tokens,
and how they are used against fileservers.</t>
<t>Expand security considerations section to cover combined tokens.</t>
<t>Rename AFS_SetCallbackKey as RXAFS_SetCallbackKey.</t>
</section>
<section title="Since 01">
<t>Rename RXAFS_SetCallbackKey to RXAFS_SetCallBackKey.</t>
<t>Add an AFS-3 Registry Considerations section.</t>
<t>Clarify the vlserver/dbserver/fileserver relationship.</t>
<t>AFSCombineTokens prototype changes.</t>
<t>Clarify the scope of the document.</t>
<t>Use a leap of faith for RegisterAddrsAndKey.</t>
<t>Specify the nametype of the acceptor identity.</t>
</section>
</section>
</back>
</rfc>
| PAFTECH AB 2003-2026 | 2026-04-21 00:30:38 |