dbc9b31c01a90e819a6c7ff709d4e1e338e0d4ba
[openafs.git] / src / rxkad / private_data.h
1 /* Declarations of data structures associated with rxkad security objects. */
2
3 /*
4 ****************************************************************************
5 *        Copyright IBM Corporation 1988, 1989 - All Rights Reserved        *
6 *                                                                          *
7 * Permission to use, copy, modify, and distribute this software and its    *
8 * documentation for any purpose and without fee is hereby granted,         *
9 * provided that the above copyright notice appear in all copies and        *
10 * that both that copyright notice and this permission notice appear in     *
11 * supporting documentation, and that the name of IBM not be used in        *
12 * advertising or publicity pertaining to distribution of the software      *
13 * without specific, written prior permission.                              *
14 *                                                                          *
15 * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL *
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL IBM *
17 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY      *
18 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER  *
19 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING   *
20 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.    *
21 ****************************************************************************
22 */
23
24 /* Copyright (C) 1991, 1990 Transarc Corporation - All rights reserved */
25
26
27 #ifndef TRANSARC_RXKAD_PRIVATE_DATA_H
28 #define TRANSARC_RXKAD_PRIVATE_DATA_H
29
30 #include "rxkad.h"
31
32
33 #include "fcrypt.h"
34
35 struct connStats {
36     afs_uint32
37         bytesReceived, bytesSent, packetsReceived, packetsSent;
38 };
39         
40 /* Private data structure representing an RX server end point for rxkad.
41  * This structure is encrypted in network byte order and transmitted as
42  * part of a challenge response.  It is also used as part of the per-packet
43  * checksum sent on every packet, to ensure that the per-packet checksum
44  * is not used in the context of another end point.
45  *
46  * THIS STRUCTURE MUST BE A MULTIPLE OF 8 BYTES LONG SINCE IT IS
47  * ENCRYPTED IN PLACE!
48  */
49 struct rxkad_endpoint {
50     afs_int32 cuid[2];                  /* being used for connection routing */
51     afs_uint32 cksum;                   /* cksum of challenge response */
52     afs_int32 securityIndex;                    /* security index */
53 };
54
55 /* structure used for generating connection IDs; must be encrypted in network
56  * byte order.  Also must be a multiple of 8 bytes for encryption to work
57  * properly.
58  */
59 struct rxkad_cidgen {
60     struct clock time;  /* time now */
61     afs_int32 random1;  /* some implementation-specific random info */
62     afs_int32 random2;  /* more random info */
63     afs_int32 counter;  /* a counter */
64     afs_int32 ipAddr;   /* or an approximation to it */
65 };
66
67 /* private data in client-side security object */
68 struct rxkad_cprivate {
69     afs_int32      kvno;                /* key version of ticket */
70     afs_int32      ticketLen;           /* length of ticket */
71     fc_KeySchedule keysched;            /* the session key */
72     fc_InitializationVector ivec;       /* initialization vector for cbc */
73     char           ticket[MAXKTCTICKETLEN]; /* the ticket for the server */
74     rxkad_type     type;                /* always client */
75     rxkad_level    level;               /* minimum security level of client */
76 };
77
78 /* Per connection client-side info */
79 struct rxkad_cconn {
80     fc_InitializationVector preSeq;     /* used in computing checksum */
81     struct connStats stats;
82     char             cksumSeen;         /* rx: header.spare is a checksum */
83 };
84
85 /* private data in server-side security object */
86 struct rxkad_sprivate {
87     char       *get_key_rock;           /* rock for get_key function */
88     int       (*get_key)();             /* func. of kvno and server key ptr */
89     int       (*user_ok)();             /* func called with new client name */
90     rxkad_type  type;                   /* always server */
91     rxkad_level level;                  /* minimum security level of server */
92 };
93
94 /* private data in server-side connection */
95 struct rxkad_sconn {
96     rxkad_level      level;             /* security level of connection */
97     char             tried;             /* did we ever try to auth this conn */
98     char             authenticated;     /* connection is good */
99     char             cksumSeen;         /* rx: header.spare is a checksum */
100     afs_uint32    expirationTime;       /* when the ticket expires */
101     afs_int32        challengeID;       /* unique challenge */
102     struct connStats stats;             /* per connection stats */
103     fc_KeySchedule   keysched;          /* session key */
104     fc_InitializationVector ivec;       /* initialization vector for cbc */
105     fc_InitializationVector preSeq;     /* used in computing checksum */
106     struct rxkad_serverinfo *rock;      /* info about client if saved */
107 };
108
109 struct rxkad_serverinfo {
110     int kvno;
111     struct ktc_principal client;
112 };
113
114 #define RXKAD_CHALLENGE_PROTOCOL_VERSION 2
115
116 /* An old style (any version predating 2) challenge packet */
117 struct rxkad_oldChallenge {
118     afs_int32 challengeID;
119     afs_int32 level;                            /* minimum security level */
120 };
121
122 /* A version 2 challenge */
123 struct rxkad_v2Challenge {
124     afs_int32 version;
125     afs_int32 challengeID;
126     afs_int32 level;
127     afs_int32 spare;
128 };
129
130 /* An old challenge response packet */
131 struct rxkad_oldChallengeResponse {
132     struct { /* encrypted with session key */
133         afs_int32 incChallengeID;
134         afs_int32 level;
135     } encrypted;
136     afs_int32 kvno;
137     afs_int32 ticketLen;
138 };
139 /*  <ticketLen> bytes of ticket follow here */
140
141 /* A version 2 challenge response also includes connection routing (Rx server
142  * end point) and client call number state as well as version and spare fields.
143  * The encrypted part probably doesn't need to start on an 8 byte boundary, but
144  * just in case we put in a spare. */
145 struct rxkad_v2ChallengeResponse {
146     afs_int32 version;
147     afs_int32 spare;
148     struct { /* encrypted with session key */
149         struct rxkad_endpoint endpoint; /* for connection routing */
150         afs_int32 callNumbers[RX_MAXCALLS];     /* client call # state */
151         afs_int32 incChallengeID;
152         afs_int32 level;
153     } encrypted;
154     afs_int32 kvno;
155     afs_int32 ticketLen;
156 };
157 /*  <ticketLen> bytes of ticket follow here */
158 #if RX_MAXCALLS != 4
159     The above structure requires that (RX_MAXCALLS == 4).
160 #endif
161
162 /* This should be afs_int32, but the RXS ops are defined as int returning  */
163 #define rxs_return_t int
164 extern rxs_return_t
165     rxkad_Close(),
166     rxkad_NewConnection(),
167     rxkad_CheckAuthentication(),
168     rxkad_CreateChallenge(),
169     rxkad_GetChallenge(),
170     rxkad_GetResponse(),
171     rxkad_CheckPacket(),
172     rxkad_PreparePacket(),
173     rxkad_CheckResponse(),
174     rxkad_DestroyConnection(),
175     rxkad_AllocCID(),
176     rxkad_GetStats();
177
178 #endif /* TRANSARC_RXKAD_PRIVATE_DATA_H */