← Back to branch summary

~ubuntu-branches/ubuntu/utopic/moonshot-gss-eap/utopic-backports

« back to all changes in this revision

Viewing changes to libeap/src/radius/radius.h

  • Committer: Package Import Robot
  • Author(s): Sam Hartman
  • Date: 2014-09-16 08:38:39 UTC
  • Revision ID: package-import@ubuntu.com-20140916083839-ipqco3thb1wcwvs0
Tags: upstream-0.9.2
Import upstream version 0.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libeap/src/radius/radius.h
 
1
/*
 
2
 * RADIUS message processing
 
3
 * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License version 2 as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * Alternatively, this software may be distributed under the terms of BSD
 
10
 * license.
 
11
 *
 
12
 * See README and COPYING for more details.
 
13
 */
 
14
 
 
15
#ifndef RADIUS_H
 
16
#define RADIUS_H
 
17
 
 
18
/* RFC 2865 - RADIUS */
 
19
 
 
20
#ifdef _MSC_VER
 
21
#pragma pack(push, 1)
 
22
#endif /* _MSC_VER */
 
23
 
 
24
struct radius_hdr {
 
25
        u8 code;
 
26
        u8 identifier;
 
27
        u16 length; /* including this header */
 
28
        u8 authenticator[16];
 
29
        /* followed by length-20 octets of attributes */
 
30
} STRUCT_PACKED;
 
31
 
 
32
enum { RADIUS_CODE_ACCESS_REQUEST = 1,
 
33
       RADIUS_CODE_ACCESS_ACCEPT = 2,
 
34
       RADIUS_CODE_ACCESS_REJECT = 3,
 
35
       RADIUS_CODE_ACCOUNTING_REQUEST = 4,
 
36
       RADIUS_CODE_ACCOUNTING_RESPONSE = 5,
 
37
       RADIUS_CODE_ACCESS_CHALLENGE = 11,
 
38
       RADIUS_CODE_STATUS_SERVER = 12,
 
39
       RADIUS_CODE_STATUS_CLIENT = 13,
 
40
       RADIUS_CODE_RESERVED = 255
 
41
};
 
42
 
 
43
struct radius_attr_hdr {
 
44
        u8 type;
 
45
        u8 length; /* including this header */
 
46
        /* followed by length-2 octets of attribute value */
 
47
} STRUCT_PACKED;
 
48
 
 
49
#define RADIUS_MAX_ATTR_LEN (255 - sizeof(struct radius_attr_hdr))
 
50
 
 
51
enum { RADIUS_ATTR_USER_NAME = 1,
 
52
       RADIUS_ATTR_USER_PASSWORD = 2,
 
53
       RADIUS_ATTR_NAS_IP_ADDRESS = 4,
 
54
       RADIUS_ATTR_NAS_PORT = 5,
 
55
       RADIUS_ATTR_FRAMED_MTU = 12,
 
56
       RADIUS_ATTR_REPLY_MESSAGE = 18,
 
57
       RADIUS_ATTR_STATE = 24,
 
58
       RADIUS_ATTR_CLASS = 25,
 
59
       RADIUS_ATTR_VENDOR_SPECIFIC = 26,
 
60
       RADIUS_ATTR_SESSION_TIMEOUT = 27,
 
61
       RADIUS_ATTR_IDLE_TIMEOUT = 28,
 
62
       RADIUS_ATTR_TERMINATION_ACTION = 29,
 
63
       RADIUS_ATTR_CALLED_STATION_ID = 30,
 
64
       RADIUS_ATTR_CALLING_STATION_ID = 31,
 
65
       RADIUS_ATTR_NAS_IDENTIFIER = 32,
 
66
       RADIUS_ATTR_PROXY_STATE = 33,
 
67
       RADIUS_ATTR_ACCT_STATUS_TYPE = 40,
 
68
       RADIUS_ATTR_ACCT_DELAY_TIME = 41,
 
69
       RADIUS_ATTR_ACCT_INPUT_OCTETS = 42,
 
70
       RADIUS_ATTR_ACCT_OUTPUT_OCTETS = 43,
 
71
       RADIUS_ATTR_ACCT_SESSION_ID = 44,
 
72
       RADIUS_ATTR_ACCT_AUTHENTIC = 45,
 
73
       RADIUS_ATTR_ACCT_SESSION_TIME = 46,
 
74
       RADIUS_ATTR_ACCT_INPUT_PACKETS = 47,
 
75
       RADIUS_ATTR_ACCT_OUTPUT_PACKETS = 48,
 
76
       RADIUS_ATTR_ACCT_TERMINATE_CAUSE = 49,
 
77
       RADIUS_ATTR_ACCT_MULTI_SESSION_ID = 50,
 
78
       RADIUS_ATTR_ACCT_LINK_COUNT = 51,
 
79
       RADIUS_ATTR_ACCT_INPUT_GIGAWORDS = 52,
 
80
       RADIUS_ATTR_ACCT_OUTPUT_GIGAWORDS = 53,
 
81
       RADIUS_ATTR_EVENT_TIMESTAMP = 55,
 
82
       RADIUS_ATTR_NAS_PORT_TYPE = 61,
 
83
       RADIUS_ATTR_TUNNEL_TYPE = 64,
 
84
       RADIUS_ATTR_TUNNEL_MEDIUM_TYPE = 65,
 
85
       RADIUS_ATTR_CONNECT_INFO = 77,
 
86
       RADIUS_ATTR_EAP_MESSAGE = 79,
 
87
       RADIUS_ATTR_MESSAGE_AUTHENTICATOR = 80,
 
88
       RADIUS_ATTR_TUNNEL_PRIVATE_GROUP_ID = 81,
 
89
       RADIUS_ATTR_ACCT_INTERIM_INTERVAL = 85,
 
90
       RADIUS_ATTR_CHARGEABLE_USER_IDENTITY = 89,
 
91
       RADIUS_ATTR_NAS_IPV6_ADDRESS = 95
 
92
};
 
93
 
 
94
 
 
95
/* Termination-Action */
 
96
#define RADIUS_TERMINATION_ACTION_DEFAULT 0
 
97
#define RADIUS_TERMINATION_ACTION_RADIUS_REQUEST 1
 
98
 
 
99
/* NAS-Port-Type */
 
100
#define RADIUS_NAS_PORT_TYPE_IEEE_802_11 19
 
101
 
 
102
/* Acct-Status-Type */
 
103
#define RADIUS_ACCT_STATUS_TYPE_START 1
 
104
#define RADIUS_ACCT_STATUS_TYPE_STOP 2
 
105
#define RADIUS_ACCT_STATUS_TYPE_INTERIM_UPDATE 3
 
106
#define RADIUS_ACCT_STATUS_TYPE_ACCOUNTING_ON 7
 
107
#define RADIUS_ACCT_STATUS_TYPE_ACCOUNTING_OFF 8
 
108
 
 
109
/* Acct-Authentic */
 
110
#define RADIUS_ACCT_AUTHENTIC_RADIUS 1
 
111
#define RADIUS_ACCT_AUTHENTIC_LOCAL 2
 
112
#define RADIUS_ACCT_AUTHENTIC_REMOTE 3
 
113
 
 
114
/* Acct-Terminate-Cause */
 
115
#define RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST 1
 
116
#define RADIUS_ACCT_TERMINATE_CAUSE_LOST_CARRIER 2
 
117
#define RADIUS_ACCT_TERMINATE_CAUSE_LOST_SERVICE 3
 
118
#define RADIUS_ACCT_TERMINATE_CAUSE_IDLE_TIMEOUT 4
 
119
#define RADIUS_ACCT_TERMINATE_CAUSE_SESSION_TIMEOUT 5
 
120
#define RADIUS_ACCT_TERMINATE_CAUSE_ADMIN_RESET 6
 
121
#define RADIUS_ACCT_TERMINATE_CAUSE_ADMIN_REBOOT 7
 
122
#define RADIUS_ACCT_TERMINATE_CAUSE_PORT_ERROR 8
 
123
#define RADIUS_ACCT_TERMINATE_CAUSE_NAS_ERROR 9
 
124
#define RADIUS_ACCT_TERMINATE_CAUSE_NAS_REQUEST 10
 
125
#define RADIUS_ACCT_TERMINATE_CAUSE_NAS_REBOOT 11
 
126
#define RADIUS_ACCT_TERMINATE_CAUSE_PORT_UNNEEDED 12
 
127
#define RADIUS_ACCT_TERMINATE_CAUSE_PORT_PREEMPTED 13
 
128
#define RADIUS_ACCT_TERMINATE_CAUSE_PORT_SUSPENDED 14
 
129
#define RADIUS_ACCT_TERMINATE_CAUSE_SERVICE_UNAVAILABLE 15
 
130
#define RADIUS_ACCT_TERMINATE_CAUSE_CALLBACK 16
 
131
#define RADIUS_ACCT_TERMINATE_CAUSE_USER_ERROR 17
 
132
#define RADIUS_ACCT_TERMINATE_CAUSE_HOST_REQUEST 18
 
133
 
 
134
#define RADIUS_TUNNEL_TAGS 32
 
135
 
 
136
/* Tunnel-Type */
 
137
#define RADIUS_TUNNEL_TYPE_PPTP 1
 
138
#define RADIUS_TUNNEL_TYPE_L2TP 3
 
139
#define RADIUS_TUNNEL_TYPE_IPIP 7
 
140
#define RADIUS_TUNNEL_TYPE_GRE 10
 
141
#define RADIUS_TUNNEL_TYPE_VLAN 13
 
142
 
 
143
/* Tunnel-Medium-Type */
 
144
#define RADIUS_TUNNEL_MEDIUM_TYPE_IPV4 1
 
145
#define RADIUS_TUNNEL_MEDIUM_TYPE_IPV6 2
 
146
#define RADIUS_TUNNEL_MEDIUM_TYPE_802 6
 
147
 
 
148
 
 
149
struct radius_attr_vendor {
 
150
        u8 vendor_type;
 
151
        u8 vendor_length;
 
152
} STRUCT_PACKED;
 
153
 
 
154
#define RADIUS_VENDOR_ID_CISCO 9
 
155
#define RADIUS_CISCO_AV_PAIR 1
 
156
 
 
157
/* RFC 2548 - Microsoft Vendor-specific RADIUS Attributes */
 
158
#define RADIUS_VENDOR_ID_MICROSOFT 311
 
159
 
 
160
enum { RADIUS_VENDOR_ATTR_MS_MPPE_SEND_KEY = 16,
 
161
       RADIUS_VENDOR_ATTR_MS_MPPE_RECV_KEY = 17
 
162
};
 
163
 
 
164
#ifdef _MSC_VER
 
165
#pragma pack(pop)
 
166
#endif /* _MSC_VER */
 
167
 
 
168
struct radius_ms_mppe_keys {
 
169
        u8 *send;
 
170
        size_t send_len;
 
171
        u8 *recv;
 
172
        size_t recv_len;
 
173
};
 
174
 
 
175
 
 
176
struct radius_msg;
 
177
 
 
178
/* Default size to be allocated for new RADIUS messages */
 
179
#define RADIUS_DEFAULT_MSG_SIZE 1024
 
180
 
 
181
/* Default size to be allocated for attribute array */
 
182
#define RADIUS_DEFAULT_ATTR_COUNT 16
 
183
 
 
184
 
 
185
/* MAC address ASCII format for IEEE 802.1X use
 
186
 * (draft-congdon-radius-8021x-20.txt) */
 
187
#define RADIUS_802_1X_ADDR_FORMAT "%02X-%02X-%02X-%02X-%02X-%02X"
 
188
/* MAC address ASCII format for non-802.1X use */
 
189
#define RADIUS_ADDR_FORMAT "%02x%02x%02x%02x%02x%02x"
 
190
 
 
191
struct radius_hdr * radius_msg_get_hdr(struct radius_msg *msg);
 
192
struct wpabuf * radius_msg_get_buf(struct radius_msg *msg);
 
193
struct radius_msg * radius_msg_new(u8 code, u8 identifier);
 
194
void radius_msg_free(struct radius_msg *msg);
 
195
void radius_msg_dump(struct radius_msg *msg);
 
196
int radius_msg_finish(struct radius_msg *msg, const u8 *secret,
 
197
                      size_t secret_len);
 
198
int radius_msg_finish_srv(struct radius_msg *msg, const u8 *secret,
 
199
                          size_t secret_len, const u8 *req_authenticator);
 
200
void radius_msg_finish_acct(struct radius_msg *msg, const u8 *secret,
 
201
                            size_t secret_len);
 
202
struct radius_attr_hdr * radius_msg_add_attr(struct radius_msg *msg, u8 type,
 
203
                                             const u8 *data, size_t data_len);
 
204
struct radius_msg * radius_msg_parse(const u8 *data, size_t len);
 
205
int radius_msg_add_eap(struct radius_msg *msg, const u8 *data,
 
206
                       size_t data_len);
 
207
u8 *radius_msg_get_eap(struct radius_msg *msg, size_t *len);
 
208
int radius_msg_verify(struct radius_msg *msg, const u8 *secret,
 
209
                      size_t secret_len, struct radius_msg *sent_msg,
 
210
                      int auth);
 
211
int radius_msg_verify_msg_auth(struct radius_msg *msg, const u8 *secret,
 
212
                               size_t secret_len, const u8 *req_auth);
 
213
int radius_msg_copy_attr(struct radius_msg *dst, struct radius_msg *src,
 
214
                         u8 type);
 
215
void radius_msg_make_authenticator(struct radius_msg *msg,
 
216
                                   const u8 *data, size_t len);
 
217
struct radius_ms_mppe_keys *
 
218
radius_msg_get_ms_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
 
219
                       const u8 *secret, size_t secret_len);
 
220
struct radius_ms_mppe_keys *
 
221
radius_msg_get_cisco_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
 
222
                          const u8 *secret, size_t secret_len);
 
223
int radius_msg_add_mppe_keys(struct radius_msg *msg,
 
224
                             const u8 *req_authenticator,
 
225
                             const u8 *secret, size_t secret_len,
 
226
                             const u8 *send_key, size_t send_key_len,
 
227
                             const u8 *recv_key, size_t recv_key_len);
 
228
struct radius_attr_hdr *
 
229
radius_msg_add_attr_user_password(struct radius_msg *msg,
 
230
                                  const u8 *data, size_t data_len,
 
231
                                  const u8 *secret, size_t secret_len);
 
232
int radius_msg_get_attr(struct radius_msg *msg, u8 type, u8 *buf, size_t len);
 
233
int radius_msg_get_vlanid(struct radius_msg *msg);
 
234
 
 
235
static inline int radius_msg_add_attr_int32(struct radius_msg *msg, u8 type,
 
236
                                            u32 value)
 
237
{
 
238
        u32 val = htonl(value);
 
239
        return radius_msg_add_attr(msg, type, (u8 *) &val, 4) != NULL;
 
240
}
 
241
 
 
242
static inline int radius_msg_get_attr_int32(struct radius_msg *msg, u8 type,
 
243
                                            u32 *value)
 
244
{
 
245
        u32 val;
 
246
        int res;
 
247
        res = radius_msg_get_attr(msg, type, (u8 *) &val, 4);
 
248
        if (res != 4)
 
249
                return -1;
 
250
 
 
251
        *value = ntohl(val);
 
252
        return 0;
 
253
}
 
254
int radius_msg_get_attr_ptr(struct radius_msg *msg, u8 type, u8 **buf,
 
255
                            size_t *len, const u8 *start);
 
256
int radius_msg_count_attr(struct radius_msg *msg, u8 type, int min_len);
 
257
 
 
258
 
 
259
struct radius_attr_data {
 
260
        u8 *data;
 
261
        size_t len;
 
262
};
 
263
 
 
264
struct radius_class_data {
 
265
        struct radius_attr_data *attr;
 
266
        size_t count;
 
267
};
 
268
 
 
269
void radius_free_class(struct radius_class_data *c);
 
270
int radius_copy_class(struct radius_class_data *dst,
 
271
                      const struct radius_class_data *src);
 
272
 
 
273
#endif /* RADIUS_H */