contrib/wpa/src/radius/radius_server.h

   1 /*
   2  * RADIUS authentication server
   3  * Copyright (c) 2005-2009, 2011, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #ifndef RADIUS_SERVER_H
  10 #define RADIUS_SERVER_H
  11
  12 struct radius_server_data;
  13 struct eap_user;
  14
  15 /**
  16  * struct radius_server_conf - RADIUS server configuration
  17  */
  18 struct radius_server_conf {
  19         /**
  20          * auth_port - UDP port to listen to as an authentication server
  21          */
  22         int auth_port;
  23
  24         /**
  25          * acct_port - UDP port to listen to as an accounting server
  26          */
  27         int acct_port;
  28
  29         /**
  30          * client_file - RADIUS client configuration file
  31          *
  32          * This file contains the RADIUS clients and the shared secret to be
  33          * used with them in a format where each client is on its own line. The
  34          * first item on the line is the IPv4 or IPv6 address of the client
  35          * with an optional address mask to allow full network to be specified
  36          * (e.g., 192.168.1.2 or 192.168.1.0/24). This is followed by white
  37          * space (space or tabulator) and the shared secret. Lines starting
  38          * with '#' are skipped and can be used as comments.
  39          */
  40         char *client_file;
  41
  42         /**
  43          * sqlite_file - SQLite database for storing debug log information
  44          */
  45         const char *sqlite_file;
  46
  47         /**
  48          * conf_ctx - Context pointer for callbacks
  49          *
  50          * This is used as the ctx argument in get_eap_user() calls.
  51          */
  52         void *conf_ctx;
  53
  54         /**
  55          * eap_sim_db_priv - EAP-SIM/AKA database context
  56          *
  57          * This is passed to the EAP-SIM/AKA server implementation as a
  58          * callback context.
  59          */
  60         void *eap_sim_db_priv;
  61
  62         /**
  63          * ssl_ctx - TLS context
  64          *
  65          * This is passed to the EAP server implementation as a callback
  66          * context for TLS operations.
  67          */
  68         void *ssl_ctx;
  69
  70         /**
  71          * pac_opaque_encr_key - PAC-Opaque encryption key for EAP-FAST
  72          *
  73          * This parameter is used to set a key for EAP-FAST to encrypt the
  74          * PAC-Opaque data. It can be set to %NULL if EAP-FAST is not used. If
  75          * set, must point to a 16-octet key.
  76          */
  77         u8 *pac_opaque_encr_key;
  78
  79         /**
  80          * eap_fast_a_id - EAP-FAST authority identity (A-ID)
  81          *
  82          * If EAP-FAST is not used, this can be set to %NULL. In theory, this
  83          * is a variable length field, but due to some existing implementations
  84          * requiring A-ID to be 16 octets in length, it is recommended to use
  85          * that length for the field to provide interoperability with deployed
  86          * peer implementations.
  87          */
  88         u8 *eap_fast_a_id;
  89
  90         /**
  91          * eap_fast_a_id_len - Length of eap_fast_a_id buffer in octets
  92          */
  93         size_t eap_fast_a_id_len;
  94
  95         /**
  96          * eap_fast_a_id_info - EAP-FAST authority identifier information
  97          *
  98          * This A-ID-Info contains a user-friendly name for the A-ID. For
  99          * example, this could be the enterprise and server names in
 100          * human-readable format. This field is encoded as UTF-8. If EAP-FAST
 101          * is not used, this can be set to %NULL.
 102          */
 103         char *eap_fast_a_id_info;
 104
 105         /**
 106          * eap_fast_prov - EAP-FAST provisioning modes
 107          *
 108          * 0 = provisioning disabled, 1 = only anonymous provisioning allowed,
 109          * 2 = only authenticated provisioning allowed, 3 = both provisioning
 110          * modes allowed.
 111          */
 112         int eap_fast_prov;
 113
 114         /**
 115          * pac_key_lifetime - EAP-FAST PAC-Key lifetime in seconds
 116          *
 117          * This is the hard limit on how long a provisioned PAC-Key can be
 118          * used.
 119          */
 120         int pac_key_lifetime;
 121
 122         /**
 123          * pac_key_refresh_time - EAP-FAST PAC-Key refresh time in seconds
 124          *
 125          * This is a soft limit on the PAC-Key. The server will automatically
 126          * generate a new PAC-Key when this number of seconds (or fewer) of the
 127          * lifetime remains.
 128          */
 129         int pac_key_refresh_time;
 130
 131         int eap_teap_auth;
 132         int eap_teap_pac_no_inner;
 133
 134         /**
 135          * eap_sim_aka_result_ind - EAP-SIM/AKA protected success indication
 136          *
 137          * This controls whether the protected success/failure indication
 138          * (AT_RESULT_IND) is used with EAP-SIM and EAP-AKA.
 139          */
 140         int eap_sim_aka_result_ind;
 141
 142         int eap_sim_id;
 143
 144         /**
 145          * tnc - Trusted Network Connect (TNC)
 146          *
 147          * This controls whether TNC is enabled and will be required before the
 148          * peer is allowed to connect. Note: This is only used with EAP-TTLS
 149          * and EAP-FAST. If any other EAP method is enabled, the peer will be
 150          * allowed to connect without TNC.
 151          */
 152         int tnc;
 153
 154         /**
 155          * pwd_group - EAP-pwd D-H group
 156          *
 157          * This is used to select which D-H group to use with EAP-pwd.
 158          */
 159         u16 pwd_group;
 160
 161         /**
 162          * server_id - Server identity
 163          */
 164         const char *server_id;
 165
 166         /**
 167          * erp - Whether EAP Re-authentication Protocol (ERP) is enabled
 168          *
 169          * This controls whether the authentication server derives ERP key
 170          * hierarchy (rRK and rIK) from full EAP authentication and allows
 171          * these keys to be used to perform ERP to derive rMSK instead of full
 172          * EAP authentication to derive MSK.
 173          */
 174         int erp;
 175
 176         const char *erp_domain;
 177
 178         unsigned int tls_session_lifetime;
 179
 180         unsigned int tls_flags;
 181
 182         /**
 183          * wps - Wi-Fi Protected Setup context
 184          *
 185          * If WPS is used with an external RADIUS server (which is quite
 186          * unlikely configuration), this is used to provide a pointer to WPS
 187          * context data. Normally, this can be set to %NULL.
 188          */
 189         struct wps_context *wps;
 190
 191         /**
 192          * ipv6 - Whether to enable IPv6 support in the RADIUS server
 193          */
 194         int ipv6;
 195
 196         /**
 197          * get_eap_user - Callback for fetching EAP user information
 198          * @ctx: Context data from conf_ctx
 199          * @identity: User identity
 200          * @identity_len: identity buffer length in octets
 201          * @phase2: Whether this is for Phase 2 identity
 202          * @user: Data structure for filling in the user information
 203          * Returns: 0 on success, -1 on failure
 204          *
 205          * This is used to fetch information from user database. The callback
 206          * will fill in information about allowed EAP methods and the user
 207          * password. The password field will be an allocated copy of the
 208          * password data and RADIUS server will free it after use.
 209          */
 210         int (*get_eap_user)(void *ctx, const u8 *identity, size_t identity_len,
 211                             int phase2, struct eap_user *user);
 212
 213         /**
 214          * eap_req_id_text - Optional data for EAP-Request/Identity
 215          *
 216          * This can be used to configure an optional, displayable message that
 217          * will be sent in EAP-Request/Identity. This string can contain an
 218          * ASCII-0 character (nul) to separate network infromation per RFC
 219          * 4284. The actual string length is explicit provided in
 220          * eap_req_id_text_len since nul character will not be used as a string
 221          * terminator.
 222          */
 223         const char *eap_req_id_text;
 224
 225         /**
 226          * eap_req_id_text_len - Length of eap_req_id_text buffer in octets
 227          */
 228         size_t eap_req_id_text_len;
 229
 230         /*
 231          * msg_ctx - Context data for wpa_msg() calls
 232          */
 233         void *msg_ctx;
 234
 235 #ifdef CONFIG_RADIUS_TEST
 236         const char *dump_msk_file;
 237 #endif /* CONFIG_RADIUS_TEST */
 238
 239         char *subscr_remediation_url;
 240         u8 subscr_remediation_method;
 241         char *hs20_sim_provisioning_url;
 242
 243         char *t_c_server_url;
 244 };
 245
 246
 247 struct radius_server_data *
 248 radius_server_init(struct radius_server_conf *conf);
 249
 250 void radius_server_erp_flush(struct radius_server_data *data);
 251 void radius_server_deinit(struct radius_server_data *data);
 252
 253 int radius_server_get_mib(struct radius_server_data *data, char *buf,
 254                           size_t buflen);
 255
 256 void radius_server_eap_pending_cb(struct radius_server_data *data, void *ctx);
 257 int radius_server_dac_request(struct radius_server_data *data, const char *req);
 258
 259 #endif /* RADIUS_SERVER_H */