wlantest/wired.c

   1 /*
   2  * Received frame processing for wired interface
   3  * Copyright (c) 2010, 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 #include "utils/includes.h"
  16 #include <net/ethernet.h>
  17 #include <netinet/ip.h>
  18 #include <netinet/udp.h>
  19
  20 #include "utils/common.h"
  21 #include "radius/radius.h"
  22 #include "wlantest.h"
  23
  24
  25 static struct wlantest_radius * radius_get(struct wlantest *wt, u32 srv,
  26                                            u32 cli)
  27 {
  28         struct wlantest_radius *r;
  29
  30         dl_list_for_each(r, &wt->radius, struct wlantest_radius, list) {
  31                 if (r->srv == srv && r->cli == cli)
  32                         return r;
  33         }
  34
  35         r = os_zalloc(sizeof(*r));
  36         if (r == NULL)
  37                 return NULL;
  38
  39         r->srv = srv;
  40         r->cli = cli;
  41         dl_list_add(&wt->radius, &r->list);
  42
  43         return r;
  44 }
  45
  46
  47 static const char * radius_code_string(u8 code)
  48 {
  49         switch (code) {
  50         case RADIUS_CODE_ACCESS_REQUEST:
  51                 return "Access-Request";
  52         case RADIUS_CODE_ACCESS_ACCEPT:
  53                 return "Access-Accept";
  54         case RADIUS_CODE_ACCESS_REJECT:
  55                 return "Access-Reject";
  56         case RADIUS_CODE_ACCOUNTING_REQUEST:
  57                 return "Accounting-Request";
  58         case RADIUS_CODE_ACCOUNTING_RESPONSE:
  59                 return "Accounting-Response";
  60         case RADIUS_CODE_ACCESS_CHALLENGE:
  61                 return "Access-Challenge";
  62         case RADIUS_CODE_STATUS_SERVER:
  63                 return "Status-Server";
  64         case RADIUS_CODE_STATUS_CLIENT:
  65                 return "Status-Client";
  66         case RADIUS_CODE_RESERVED:
  67                 return "Reserved";
  68         default:
  69                 return "?Unknown?";
  70         }
  71 }
  72
  73
  74 static void process_radius_access_request(struct wlantest *wt, u32 dst,
  75                                           u32 src, const u8 *data, size_t len)
  76 {
  77         struct radius_msg *msg;
  78         struct wlantest_radius *r;
  79
  80         msg = radius_msg_parse(data, len);
  81         if (msg == NULL) {
  82                 wpa_printf(MSG_DEBUG, "Failed to parse RADIUS Access-Request");
  83                 return;
  84         }
  85
  86         r = radius_get(wt, dst, src);
  87         if (r) {
  88                 radius_msg_free(r->last_req);
  89                 r->last_req = msg;
  90                 return;
  91         }
  92         radius_msg_free(msg);
  93 }
  94
  95
  96 static void wlantest_add_pmk(struct wlantest *wt, const u8 *pmk)
  97 {
  98         struct wlantest_pmk *p;
  99
 100         p = os_zalloc(sizeof(*p));
 101         if (p == NULL)
 102                 return;
 103         os_memcpy(p->pmk, pmk, 32);
 104         dl_list_add(&wt->pmk, &p->list);
 105         wpa_hexdump(MSG_INFO, "Add PMK", pmk, 32);
 106 }
 107
 108
 109 static void process_radius_access_accept(struct wlantest *wt, u32 dst, u32 src,
 110                                          const u8 *data, size_t len)
 111 {
 112         struct radius_msg *msg;
 113         struct wlantest_radius *r;
 114         struct radius_ms_mppe_keys *keys;
 115         struct wlantest_radius_secret *s;
 116
 117         r = radius_get(wt, src, dst);
 118         if (r == NULL || r->last_req == NULL) {
 119                 wpa_printf(MSG_DEBUG, "No RADIUS Access-Challenge found for "
 120                            "decrypting Access-Accept keys");
 121                 return;
 122         }
 123
 124         msg = radius_msg_parse(data, len);
 125         if (msg == NULL) {
 126                 wpa_printf(MSG_DEBUG, "Failed to parse RADIUS Access-Accept");
 127                 return;
 128         }
 129
 130         dl_list_for_each(s, &wt->secret, struct wlantest_radius_secret, list) {
 131                 int found = 0;
 132                 keys = radius_msg_get_ms_keys(msg, r->last_req,
 133                                               (u8 *) s->secret,
 134                                               os_strlen(s->secret));
 135                 if (keys && keys->send && keys->recv) {
 136                         u8 pmk[32];
 137                         wpa_hexdump_key(MSG_DEBUG, "MS-MPPE-Send-Key",
 138                                         keys->send, keys->send_len);
 139                         wpa_hexdump_key(MSG_DEBUG, "MS-MPPE-Recv-Key",
 140                                         keys->recv, keys->recv_len);
 141                         os_memcpy(pmk, keys->recv,
 142                                   keys->recv_len > 32 ? 32 : keys->recv_len);
 143                         if (keys->recv_len < 32) {
 144                                 os_memcpy(pmk + keys->recv_len,
 145                                           keys->send,
 146                                           keys->recv_len + keys->send_len > 32
 147                                           ? 32 : 32 - keys->recv_len);
 148                         }
 149                         wlantest_add_pmk(wt, pmk);
 150                         found = 1;
 151                 }
 152
 153                 if (keys) {
 154                         os_free(keys->send);
 155                         os_free(keys->recv);
 156                         os_free(keys);
 157                 }
 158
 159                 if (found)
 160                         break;
 161         }
 162
 163         radius_msg_free(msg);
 164 }
 165
 166
 167 static void process_radius(struct wlantest *wt, u32 dst, u16 dport, u32 src,
 168                            u16 sport, const u8 *data, size_t len)
 169 {
 170         struct in_addr addr;
 171         char buf[20];
 172         const struct radius_hdr *hdr;
 173         u16 rlen;
 174
 175         if (len < sizeof(*hdr))
 176                 return;
 177         hdr = (const struct radius_hdr *) data;
 178         rlen = be_to_host16(hdr->length);
 179         if (len < rlen)
 180                 return;
 181         if (len > rlen)
 182                 len = rlen;
 183
 184         addr.s_addr = dst;
 185         snprintf(buf, sizeof(buf), "%s", inet_ntoa(addr));
 186
 187         addr.s_addr = src;
 188         wpa_printf(MSG_DEBUG, "RADIUS %s:%u -> %s:%u id=%u %s",
 189                    inet_ntoa(addr), sport, buf, dport, hdr->identifier,
 190                    radius_code_string(hdr->code));
 191
 192         switch (hdr->code) {
 193         case RADIUS_CODE_ACCESS_REQUEST:
 194                 process_radius_access_request(wt, dst, src, data, len);
 195                 break;
 196         case RADIUS_CODE_ACCESS_ACCEPT:
 197                 process_radius_access_accept(wt, dst, src, data, len);
 198                 break;
 199         }
 200 }
 201
 202
 203 static void process_udp(struct wlantest *wt, u32 dst, u32 src,
 204                         const u8 *data, size_t len)
 205 {
 206         const struct udphdr *udp;
 207         u16 sport, dport, ulen;
 208         const u8 *payload;
 209         size_t plen;
 210
 211         if (len < sizeof(*udp))
 212                 return;
 213         udp = (const struct udphdr *) data;
 214         /* TODO: check UDP checksum */
 215         sport = be_to_host16(udp->source);
 216         dport = be_to_host16(udp->dest);
 217         ulen = be_to_host16(udp->len);
 218
 219         if (ulen > len)
 220                 return;
 221         if (len < ulen)
 222                 len = ulen;
 223
 224         payload = (const u8 *) (udp + 1);
 225         plen = len - sizeof(*udp);
 226
 227         if (sport == 1812 || dport == 1812)
 228                 process_radius(wt, dst, dport, src, sport, payload, plen);
 229 }
 230
 231
 232 static void process_ipv4(struct wlantest *wt, const u8 *data, size_t len)
 233 {
 234         const struct iphdr *ip;
 235         const u8 *payload;
 236         size_t plen;
 237         u16 frag_off, tot_len;
 238
 239         if (len < sizeof(*ip))
 240                 return;
 241
 242         ip = (const struct iphdr *) data;
 243         if (ip->version != 4)
 244                 return;
 245         if (ip->ihl < 5)
 246                 return;
 247
 248         /* TODO: check header checksum in ip->check */
 249
 250         frag_off = be_to_host16(ip->frag_off);
 251         if (frag_off & 0x1fff) {
 252                 wpa_printf(MSG_EXCESSIVE, "IP fragment reassembly not yet "
 253                            "supported");
 254                 return;
 255         }
 256
 257         tot_len = be_to_host16(ip->tot_len);
 258         if (tot_len > len)
 259                 return;
 260         if (tot_len < len)
 261                 len = tot_len;
 262
 263         payload = data + 4 * ip->ihl;
 264         plen = len - 4 * ip->ihl;
 265         if (payload + plen > data + len)
 266                 return;
 267
 268         switch (ip->protocol) {
 269         case IPPROTO_UDP:
 270                 process_udp(wt, ip->daddr, ip->saddr, payload, plen);
 271                 break;
 272         }
 273 }
 274
 275
 276 void wlantest_process_wired(struct wlantest *wt, const u8 *data, size_t len)
 277 {
 278         const struct ether_header *eth;
 279         u16 ethertype;
 280
 281         wpa_hexdump(MSG_EXCESSIVE, "Process wired frame", data, len);
 282
 283         if (len < sizeof(*eth))
 284                 return;
 285
 286         eth = (const struct ether_header *) data;
 287         ethertype = be_to_host16(eth->ether_type);
 288
 289         switch (ethertype) {
 290         case ETHERTYPE_IP:
 291                 process_ipv4(wt, data + sizeof(*eth), len - sizeof(*eth));
 292                 break;
 293         }
 294 }