Allow libtool symbol files in the objdir

Check if a .sym file is present in the build directory; if so, use it.
Otherwise, fall back to the srcdir copy as we always have.

Change-Id: I57056b8b8300cd302212c313a3a618d5c9f81c31
Configure glue for rxgk

Add an --enable-rxgk switch to control whether the feature is used.
For now, just build the code as a dependency of finale, but we will
phase it in to other parts of the tree as appropriate.

We want to always build as much code as we can to benefit from the
automated build testing, so build rxgk if there is an appropriate
GSSAPI library available, but do not install anything unless the
configure argument was given.

Provide a symbol in afsconfig.h so that code using rxgk can be
conditionally compiled.

Change-Id: Iab661d47aac77c1a238e809362015b869752df18
Export a few krb5 routines for rxgk

We need oafs_h_krb5_generate_random_block when generating random
keys and oafs_h_krb5_crypto_fx_cf2 for CombineTokens.
Having oafs_h_krb5_crypto_prf_length proves very convenient for
key derivation of transport keys, so move it to the public header
and export it.
oafs_h_krb5_enctype_keysize is needed so that we can tell whether or not we
need to pass through random_to_key() when making rxgk_keys.
oafs_h_krb5_random_to_key is needed for that random_to_key() operation.

Change-Id: Ia34c8028b07df203b3885157e2d46c6bb512f608
Add rxgk_crypto_rfc3961.c

rxgk wrappers around an external crypto library, in this case, our
in-tree rfc3961 library.  Primitives for encryption/decryption and
MIC/VerifyMIC, ways to generate and free rxgk_key objects, etc..

Change-Id: I7525086043baf54f5c3019b3f5ab3495760c4236
Add RXGK_NOW()

A quick routine to get the current timestamp.

Change-Id: I0051b5c8e5ad61e35431d97454bf2741daba90cb
Export {Get,Set}ServiceSpecific from liboafs_rx.la

rxgk will use service-specific data.

Change-Id: Id9e2d4b9920e771e1583b9362e61de6216c246b4
Add rxgk_util.c

A few helper routines for the security class implementation, and
routines to set and retrieve a getkey function from rx service-specific
data.

Change-Id: I395802b6c3b2436df4b00906544fc797f3e12e9b
Add rxgk_token.c

Routines for constructing tokens (both regular and printed), extracting
and decrypting tokens, and helpers therein.

Provide the ability to print a token using a given session key and
using a random session key; the former is useful for certain variants
of localauth wherein a dummy GSS negotiation is performed with the
same identity acting as initiator and acceptor.

Change-Id: I0cde7fd0cdf9a27777523cd502b21bdccef41dcc
Add rxgk_gss.c

All the routines which deal with GSSAPI types.
This is, in practice, how the client gets a token, and the server
backend for GSSNegotiate().

These routines are split out into a separate file, and their prototypes
hidden behind ifndef KERNEL, because we need to allow rxgk to be usable
in the absence of a gssapi library, which is the case in the kernel.

Provide a compatibility definition of GSS_C_PRF_KEY_FULL, as there
are known implementations in the wild that provide the function but
do not provide the keyusage constants.

Change-Id: Id2966de07853dd6a74cb40225851728d2422421c
Implement SRXGK_GSSNegotiate()

In-kernel we must fail; the userspace implementation is already
in the tree in rxgk_gss.c.

Change-Id: Id715e3287df5921a20aebe4e65259fd2097dc2b4
Add rxgk_packet.c

Routines to apply and verify encryption and MICs to the data in
rx packets.  Backend to the rxgk_crypto framework for the actual
crypto operations.

Change-Id: I724efacf7df1d688c0d61a327fa9ee9c8168d715
Implement the rxgk server routines

Provide non-trivial implementations of the security class routines
used by the server, along with helpers as necessary.

In addition to the normal NewServerSecurityObject routine, provide
wrappers NewServiceSecObj and NewEphemeralService_SecObj that create
the security object, create an rx service for the key negotiation service
needed for clients to negotiate tokens useful with this server security
object, and register the getkey function used for the security object
as service-specific data to be used when encrypting tokens produced by
this rx service.  The Ephemeral variant creates a random token-encrypting
key for use by the service, so no getkey routine needs to be supplied
by the caller.

The identity supplied in a client's token is given as a list of
PrAuthNames; we assume that at most one name is supplied at present,
as the meaning of compound identities (and the use of compound
identities for keyed cache managers) is not fully specified yet.
Convert the PrAuthName to an rx_identity for caching in the server
connection state, as the rx_identity type is more compatible with
superuser checks on the connection.

Also provide an rxgk_GetServerInfo routine which extracts the cached
identity, for use in libauth when making superuser checks.
This moves our dependency on rx_identity from the private data structures
into the public header, so move the nested include accordingly.

Change-Id: I0f48b69d4ab758d8a4d76ebfb1daf3009c4fe060
Implement rxgk client security object routines

Also add rxgk_NegotiateSecurityObject, a routine that creates
an rxnull connection to a target server, obtains a token using
the GSSNegotiate RPC on that connection, and uses the resulting
token to make an rxgk connection to that same server.

Change-Id: Ic7e11b02cb1573cfdb6d11d4de9a77ab1c563262
Implement SRXGK_CombineTokens

Most of the logic we need is already in place in rxgk_token.c; we just
need to pull out the token data structures, combine the identity lists,
and call into that code.

Change-Id: I68dd5dffab579d89601a55b8ed82961f8e12fc1b
Build rxgk support into libafsrpc

This is done rather differently for the shared and static libafsrpc
forms.  For the shared library, we can add a dependency on the shared
$(GSSAPI_LIBS) and link in liboafs_rxgk.la directly.  libafsrpc_rxgk.la
(which only has stubs for the rxgk GSS-using routines) is linked into
the static library, so that it remains useful for statically linking
applications.  Consumers of libafsrpc.a need not be modified in
accordance with this change.

Change-Id: I76c0329ba842fb0d4d66534810b114a0813c90a0
BuildServerSecurityObjects allocate for rxgk

Don't do anything with it for now, just leave a place in the
array.

Change-Id: I304e0f6bcf7d3b2a2cb46c976f41e09809a436db
Let superuser identities be superusers

We have a special rx_identity_kind for superusers, let it actually
be useful for something.

Change-Id: I1d551ed8e5fcfd6bdc29c6c27eee4c2ae67e1a89
Add rxgk support to userok

Sprinkle @RXGK_LIBS_STATIC@ as needed to keep LWP bits building.

Change-Id: I5da2a89532453b6bec61fc87218a61455e39f6f0
Implement afsconf_GetRXGKKey

Also afsconf_GetLatestRXGKKey, as a side effect, since we want to have
a single getkey function both for getting encrypting and decrypting keys;
a kvno/enctype pair of 0/0 indicates that the "get latest" behavior is
desired.

Implement both functions in terms of an internal helper that takes
as an argument the type of key to look for in the KeyFileExt.  We
can reuse these helpers wholesale for per-fileserver keys, later.

This also requires implementing an ordering on the quality of the
different RFC 3961 enctypes (which are stored as the subtype of keys
of type afsconf_rxgk).  This is ... pretty awkward to code up, and
also subject to debate on the actual ordering.  Since the IANA enctype
registry changes rarely, just assign a full ordering on the standardized
(symmetric!) enctypes, giving integers as the ordered values, and
store that in a constant array.  Then, the lookup table allows the
comparison of the strength of enctypes ~directly.

Provide stubs for KERNEL use; UKERNEL builds this file but does not
have any real rxgk support yet, so fails to link due to the
missing rxgk_make_key symbol.

Sprinkle some @RXGK_LIBS_STATIC@ to keep the LWP bits building and
add the corresponding dependencies on @RXGK_TARGET@.

Change-Id: I81389b21238fd6588cc4381b026816005f81a30c
Add afsconf_BuildUbikServerSecurityObjects

This new interface is specifically for use in building the server
security objects that will be used to handle ubik-internal connections
(that is, DISK_ and VOTE_).

This is the normaml set from BuildServerSecurityObjects, with a custom
rxgk server security object.  The only tokens used for ubik-internal
communication are printed tokens, so the rxgk key negotiation service
(RXGK_) should not be provided.  afsconf_GetRXGKKey is used as the
getkey function for these connections, since the cell-wide rxgk key
from KeyFileExt is used for them.

Change-Id: Id332aabcf80ed35bda36dcce92e762d46b590f47