The FreeRADIUS server $Id: f3670dba8951ca10eb4948feb3dc3db9423a334f $
Loading...
Searching...
No Matches
radclient.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: c6decfdbfa0d568c3b3cf60bcfb33e3b59b6d198 $
19 *
20 * @file src/bin/radclient.c
21 * @brief General radius client and debug tool.
22 *
23 * @copyright 2000,2006,2014 The FreeRADIUS server project
24 * @copyright 2000 Miquel van Smoorenburg (miquels@cistron.nl)
25 * @copyright 2000 Alan DeKok (aland@freeradius.org)
26 */
27
28RCSID("$Id: c6decfdbfa0d568c3b3cf60bcfb33e3b59b6d198 $")
29
30#include <freeradius-devel/util/conf.h>
31#include <freeradius-devel/util/syserror.h>
32#include <freeradius-devel/util/atexit.h>
33#include <freeradius-devel/util/pair_legacy.h>
34#include <freeradius-devel/util/time.h>
35#include <freeradius-devel/server/packet.h>
36#include <freeradius-devel/radius/list.h>
37#include <freeradius-devel/radius/radius.h>
38#include <freeradius-devel/util/chap.h>
39#ifdef HAVE_OPENSSL_SSL_H
40#include <openssl/ssl.h>
41#include <freeradius-devel/util/md4.h>
42#endif
43
44#ifdef HAVE_GETOPT_H
45# include <getopt.h>
46#endif
47
48
49typedef struct request_s request_t; /* to shut up warnings about mschap.h */
50
51#include "smbdes.h"
52#include "mschap.h"
53
54#include "radclient.h"
55
56#define pair_update_request(_attr, _da) do { \
57 _attr = fr_pair_find_by_da(&request->request_pairs, NULL, _da); \
58 if (!_attr) { \
59 _attr = fr_pair_afrom_da(request, _da); \
60 fr_assert(_attr != NULL); \
61 fr_pair_append(&request->request_pairs, _attr); \
62 } \
63 } while (0)
64
65static int retries = 3;
66static fr_time_delta_t timeout = fr_time_delta_wrap((int64_t)5 * NSEC); /* 5 seconds */
67static fr_time_delta_t sleep_time = fr_time_delta_wrap(-1);
68static char *secret = NULL;
69static bool do_output = true;
70
71static const char *attr_coa_filter_name = "User-Name";
72
73static rc_stats_t stats;
74
75static uint16_t server_port = 0;
76static int packet_code = FR_RADIUS_CODE_UNDEFINED;
77static fr_ipaddr_t server_ipaddr;
78static int resend_count = 1;
79static int ignore_count = 0;
80static bool done = true;
81static bool print_filename = false;
82static bool blast_radius = false;
83
84static fr_ipaddr_t client_ipaddr;
85static uint16_t client_port = 0;
86
87static int sockfd;
88static int last_used_id = -1;
89static int fixed_id = -1;
90
91static int ipproto = IPPROTO_UDP;
92
93static bool do_coa = false;
94static int coafd;
95static uint16_t coa_port = FR_COA_UDP_PORT;
96static fr_rb_tree_t *coa_tree = NULL;
97
98static fr_packet_list_t *packet_list = NULL;
99
100static FR_DLIST_HEAD(rc_request_list) rc_request_list;
101
102static char const *radclient_version = RADIUSD_VERSION_BUILD("radclient");
103
104static fr_dict_t const *dict_freeradius;
105static fr_dict_t const *dict_radius;
106
107static const fr_dict_autoload_t radclient_dict[] = {
108 { .out = &dict_freeradius, .proto = "freeradius" },
109 { .out = &dict_radius, .proto = "radius" },
110 DICT_AUTOLOAD_TERMINATOR
111};
112
113static fr_dict_attr_t const *attr_cleartext_password;
114
115static fr_dict_attr_t const *attr_ms_chap_challenge;
116static fr_dict_attr_t const *attr_ms_chap_password;
117static fr_dict_attr_t const *attr_ms_chap_response;
118
119static fr_dict_attr_t const *attr_radclient_test_name;
120static fr_dict_attr_t const *attr_request_authenticator;
121
122static fr_dict_attr_t const *attr_chap_password;
123static fr_dict_attr_t const *attr_chap_challenge;
124static fr_dict_attr_t const *attr_packet_type;
125static fr_dict_attr_t const *attr_user_name;
126static fr_dict_attr_t const *attr_user_password;
127static fr_dict_attr_t const *attr_proxy_state;
128static fr_dict_attr_t const *attr_message_authenticator;
129
130static fr_dict_attr_t const *attr_radclient_coa_filename;
131static fr_dict_attr_t const *attr_radclient_coa_filter;
132
133static fr_dict_attr_t const *attr_coa_match_attr = NULL;
134
135static const fr_dict_attr_autoload_t radclient_dict_attr[] = {
136 { .out = &attr_cleartext_password, .name = "Password.Cleartext", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
137 { .out = &attr_ms_chap_challenge, .name = "Vendor-Specific.Microsoft.CHAP-Challenge", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
138 { .out = &attr_ms_chap_password, .name = "Password.MS-CHAP", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
139 { .out = &attr_ms_chap_response, .name = "Vendor-Specific.Microsoft.CHAP-Response", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
140
141 { .out = &attr_radclient_test_name, .name = "Radclient-Test-Name", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
142 { .out = &attr_request_authenticator, .name = "Request-Authenticator", .type = FR_TYPE_OCTETS, .dict = &dict_freeradius },
143
144 { .out = &attr_radclient_coa_filename, .name = "Radclient-CoA-Filename", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
145 { .out = &attr_radclient_coa_filter, .name = "Radclient-CoA-Filter", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
146
147 { .out = &attr_chap_password, .name = "CHAP-Password", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
148 { .out = &attr_chap_challenge, .name = "CHAP-Challenge", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
149 { .out = &attr_packet_type, .name = "Packet-Type", .type = FR_TYPE_UINT32, .dict = &dict_radius },
150 { .out = &attr_user_password, .name = "User-Password", .type = FR_TYPE_STRING, .dict = &dict_radius },
151 { .out = &attr_user_name, .name = "User-Name", .type = FR_TYPE_STRING, .dict = &dict_radius },
152 { .out = &attr_proxy_state, .name = "Proxy-State", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
153 { .out = &attr_message_authenticator, .name = "Message-Authenticator", .type = FR_TYPE_OCTETS, .dict = &dict_radius },
154
155 DICT_AUTOLOAD_TERMINATOR
156};
157
158static NEVER_RETURNS void usage(void)
159{
160 fprintf(stderr, "Usage: radclient [options] server[:port] <command> [<secret>]\n");
161
162 fprintf(stderr, " <command> One of auth, acct, status, coa, disconnect or auto.\n");
163 fprintf(stderr, " -4 Use IPv4 address of server\n");
164 fprintf(stderr, " -6 Use IPv6 address of server.\n");
165 fprintf(stderr, " -A <attribute> Use named 'attribute' to match CoA requests to packets. Default is User-Name\n");
166 fprintf(stderr, " -b Mandate checks for Blast RADIUS issue (this is not set by default).\n");
167 fprintf(stderr, " -C [<client_ip>:]<client_port> Client source port and source IP address. Port values may be 1..65535\n");
168 fprintf(stderr, " -c <count> Send each packet 'count' times.\n");
169 fprintf(stderr, " -d <confdir> Set user dictionary directory (defaults to " CONFDIR ").\n");
170 fprintf(stderr, " -D <dictdir> Set main dictionary directory (defaults to " DICTDIR ").\n");
171 fprintf(stderr, " -f <request>[:<expected>][:<coa_reply>][:<coa_expected>] Read packets from file, not stdin.\n");
172 fprintf(stderr, " If a second file is provided, it will be used to verify responses\n");
173 fprintf(stderr, " -F Print the file name, packet number and reply code.\n");
174 fprintf(stderr, " -h Print usage help information.\n");
175 fprintf(stderr, " -i <id> Set request id to 'id'. Values may be 0..255\n");
176 fprintf(stderr, " -n <num> Send N requests/s\n");
177 fprintf(stderr, " -o <port> Set CoA listening port (defaults to 3799)\n");
178 fprintf(stderr, " -p <num> Send 'num' packets from a file in parallel.\n");
179 fprintf(stderr, " -P <proto> Use proto (tcp or udp) for transport.\n");
180 fprintf(stderr, " -r <retries> If timeout, retry sending the packet 'retries' times.\n");
181 fprintf(stderr, " -s Print out summary information of auth results.\n");
182 fprintf(stderr, " -S <file> read secret from file, not command line.\n");
183 fprintf(stderr, " -t <timeout> Wait 'timeout' seconds before retrying (may be a floating point number).\n");
184 fprintf(stderr, " -v Show program version information.\n");
185 fprintf(stderr, " -x Debugging mode.\n");
186
187 fr_exit_now(EXIT_SUCCESS);
188}
189
190/*
191 * Free a radclient struct, which may (or may not)
192 * already be in the list.
193 */
194static int _rc_request_free(rc_request_t *request)
195{
196 rc_request_list_remove(&rc_request_list, request);
197
198 if (do_coa && fr_rb_node_inline_in_tree(&request->node) && !coa_tree->being_freed) {
199 (void) fr_rb_delete_by_inline_node(coa_tree, &request->node);
200 }
201
202 return 0;
203}
204
205#ifdef HAVE_OPENSSL_SSL_H
206#include <openssl/provider.h>
207
208static OSSL_PROVIDER *openssl_default_provider = NULL;
209static OSSL_PROVIDER *openssl_legacy_provider = NULL;
210
211static int openssl3_init(void)
212{
213 /*
214 * Load the default provider for most algorithms
215 */
216 openssl_default_provider = OSSL_PROVIDER_load(NULL, "default");
217 if (!openssl_default_provider) {
218 ERROR("(TLS) Failed loading default provider");
219 return -1;
220 }
221
222 /*
223 * Needed for MD4
224 *
225 * https://www.openssl.org/docs/man3.0/man7/migration_guide.html#Legacy-Algorithms
226 */
227 openssl_legacy_provider = OSSL_PROVIDER_load(NULL, "legacy");
228 if (!openssl_legacy_provider) {
229 ERROR("(TLS) Failed loading legacy provider");
230 return -1;
231 }
232
233 fr_md5_openssl_init();
234 fr_md4_openssl_init();
235
236 return 0;
237}
238
239static void openssl3_free(void)
240{
241 if (openssl_default_provider && !OSSL_PROVIDER_unload(openssl_default_provider)) {
242 ERROR("Failed unloading default provider");
243 }
244 openssl_default_provider = NULL;
245
246 if (openssl_legacy_provider && !OSSL_PROVIDER_unload(openssl_legacy_provider)) {
247 ERROR("Failed unloading legacy provider");
248 }
249 openssl_legacy_provider = NULL;
250
251 fr_md5_openssl_free();
252 fr_md4_openssl_free();
253}
254#else
255#define openssl3_init() (0)
256#define openssl3_free()
257#endif
258
259static int mschapv1_encode(fr_packet_t *packet, fr_pair_list_t *list,
260 char const *password)
261{
262 unsigned int i;
263 uint8_t *p;
264 fr_pair_t *challenge, *reply;
265 uint8_t nthash[16];
266
267 fr_pair_delete_by_da(list, attr_ms_chap_challenge);
268 fr_pair_delete_by_da(list, attr_ms_chap_response);
269
270 MEM(challenge = fr_pair_afrom_da(packet, attr_ms_chap_challenge));
271
272 fr_pair_append(list, challenge);
273
274 MEM(p = talloc_array(challenge, uint8_t, 8));
275 fr_pair_value_memdup_buffer_shallow(challenge, p, false);
276
277 for (i = 0; i < challenge->vp_length; i++) {
278 p[i] = fr_rand();
279 }
280
281 MEM(reply = fr_pair_afrom_da(packet, attr_ms_chap_response));
282 fr_pair_append(list, reply);
283 p = talloc_zero_array(reply, uint8_t, 50); /* really reply->da->flags.length */
284 fr_pair_value_memdup_buffer_shallow(reply, p, false);
285
286 p[1] = 0x01; /* NT hash */
287
288 if (mschap_nt_password_hash(nthash, password) < 0) return 0;
289
290 smbdes_mschap(nthash, challenge->vp_octets, p + 26);
291 return 1;
292}
293
294
295static int getport(char const *name)
296{
297 struct servent *svp;
298
299 svp = getservbyname(name, "udp");
300 if (!svp) return 0;
301
302 return ntohs(svp->s_port);
303}
304
305/*
306 * Set a port from the request type if we don't already have one
307 */
308static void radclient_get_port(fr_radius_packet_code_t type, uint16_t *port)
309{
310 switch (type) {
311 default:
312 case FR_RADIUS_CODE_ACCESS_REQUEST:
313 case FR_RADIUS_CODE_ACCESS_CHALLENGE:
314 case FR_RADIUS_CODE_STATUS_SERVER:
315 if (*port == 0) *port = getport("radius");
316 if (*port == 0) *port = FR_AUTH_UDP_PORT;
317 return;
318
319 case FR_RADIUS_CODE_ACCOUNTING_REQUEST:
320 if (*port == 0) *port = getport("radacct");
321 if (*port == 0) *port = FR_ACCT_UDP_PORT;
322 return;
323
324 case FR_RADIUS_CODE_DISCONNECT_REQUEST:
325 if (*port == 0) *port = FR_POD_UDP_PORT;
326 return;
327
328 case FR_RADIUS_CODE_COA_REQUEST:
329 if (*port == 0) *port = FR_COA_UDP_PORT;
330 return;
331
332 case FR_RADIUS_CODE_UNDEFINED:
333 if (*port == 0) *port = 0;
334 return;
335 }
336}
337
338/*
339 * Resolve a port to a request type
340 */
341static fr_radius_packet_code_t radclient_get_code(uint16_t port)
342{
343 /*
344 * getport returns 0 if the service doesn't exist
345 * so we need to return early, to avoid incorrect
346 * codes.
347 */
348 if (port == 0) return FR_RADIUS_CODE_UNDEFINED;
349
350 if ((port == getport("radius")) || (port == FR_AUTH_UDP_PORT) || (port == FR_AUTH_UDP_PORT_ALT)) {
351 return FR_RADIUS_CODE_ACCESS_REQUEST;
352 }
353 if ((port == getport("radacct")) || (port == FR_ACCT_UDP_PORT) || (port == FR_ACCT_UDP_PORT_ALT)) {
354 return FR_RADIUS_CODE_ACCOUNTING_REQUEST;
355 }
356 if (port == FR_COA_UDP_PORT) return FR_RADIUS_CODE_COA_REQUEST;
357
358 return FR_RADIUS_CODE_UNDEFINED;
359}
360
361
362static bool already_hex(fr_pair_t *vp)
363{
364 size_t i;
365
366 if (!vp || (vp->vp_type != FR_TYPE_OCTETS)) return true;
367
368 /*
369 * If it's 17 octets, it *might* be already encoded.
370 * Or, it might just be a 17-character password (maybe UTF-8)
371 * Check it for non-printable characters. The odds of ALL
372 * of the characters being 32..255 is (1-7/8)^17, or (1/8)^17,
373 * or 1/(2^51), which is pretty much zero.
374 */
375 for (i = 0; i < vp->vp_length; i++) {
376 if (vp->vp_octets[i] < 32) {
377 return true;
378 }
379 }
380
381 return false;
382}
383
384/** Read one CoA reply and potentially a filter
385 *
386 *
387 */
388static int coa_init(rc_request_t *parent,
389 FILE *coa_reply, char const *reply_filename, bool *coa_reply_done,
390 FILE *coa_filter, char const *filter_filename, bool *coa_filter_done)
391{
392 rc_request_t *request;
393 fr_pair_t *vp;
394
395 /*
396 * Allocate it.
397 */
398 MEM(request = talloc_zero(parent, rc_request_t));
399 MEM(request->reply = fr_packet_alloc(request, false));
400
401 /*
402 * Don't initialize src/dst IP/port, or anything else. That will be read from the network.
403 */
404 fr_pair_list_init(&request->filter);
405 fr_pair_list_init(&request->request_pairs);
406 fr_pair_list_init(&request->reply_pairs);
407
408 /*
409 * Read the reply VP's.
410 */
411 if (fr_pair_list_afrom_file(request, dict_radius,
412 &request->reply_pairs, coa_reply, coa_reply_done, true) < 0) {
413 REDEBUG("Error parsing \"%s\"", reply_filename);
414 error:
415 talloc_free(request);
416 return -1;
417 }
418
419 /*
420 * The reply can be empty. In which case we just send an empty ACK.
421 */
422 vp = fr_pair_find_by_da(&request->reply_pairs, NULL, attr_packet_type);
423 if (vp) request->reply->code = vp->vp_uint32;
424
425 /*
426 * Read in filter VP's.
427 */
428 if (coa_filter) {
429 if (fr_pair_list_afrom_file(request, dict_radius,
430 &request->filter, coa_filter, coa_filter_done, true) < 0) {
431 REDEBUG("Error parsing \"%s\"", filter_filename);
432 goto error;
433 }
434
435 if (*coa_filter_done && !*coa_reply_done) {
436 REDEBUG("Differing number of replies/filters in %s:%s "
437 "(too many replies)", reply_filename, filter_filename);
438 goto error;
439 }
440
441 if (!*coa_filter_done && *coa_reply_done) {
442 REDEBUG("Differing number of replies/filters in %s:%s "
443 "(too many filters)", reply_filename, filter_filename);
444 goto error;
445 }
446
447 /*
448 * This allows efficient list comparisons later
449 */
450 fr_pair_list_sort(&request->filter, fr_pair_cmp_by_da);
451 }
452
453 request->name = parent->name;
454
455 /*
456 * Automatically set the response code from the request code
457 * (if one wasn't already set).
458 */
459 if (request->filter_code == FR_RADIUS_CODE_UNDEFINED) {
460 request->filter_code = FR_RADIUS_CODE_COA_REQUEST;
461 }
462
463 parent->coa = request;
464
465 /*
466 * Ensure that the packet is also tracked in the CoA tree.
467 */
468 fr_assert(coa_tree);
469 if (!fr_rb_insert(coa_tree, parent)) {
470 ERROR("Failed inserting packet from %s into CoA tree", request->name);
471 fr_exit_now(1);
472 }
473
474 return 0;
475}
476
477/*
478 * Initialize a radclient data structure and add it to
479 * the global linked list.
480 */
481static int radclient_init(TALLOC_CTX *ctx, rc_file_pair_t *files)
482{
483 FILE *packets, *filters = NULL;
484
485 fr_pair_t *vp;
486 rc_request_t *request = NULL;
487 bool packets_done = false;
488 uint64_t num = 0;
489
490 FILE *coa_reply = NULL;
491 FILE *coa_filter = NULL;
492 bool coa_reply_done = false;
493 bool coa_filter_done = false;
494
495 fr_assert(files->packets != NULL);
496
497 /*
498 * Determine where to read the VP's from.
499 */
500 if (strcmp(files->packets, "-") != 0) {
501 packets = fopen(files->packets, "r");
502 if (!packets) {
503 ERROR("Error opening %s: %s", files->packets, fr_syserror(errno));
504 return -1;
505 }
506
507 /*
508 * Read in the pairs representing the expected response.
509 */
510 if (files->filters) {
511 filters = fopen(files->filters, "r");
512 if (!filters) {
513 ERROR("Error opening %s: %s", files->filters, fr_syserror(errno));
514 goto error;
515 }
516 }
517
518 if (files->coa_reply) {
519 coa_reply = fopen(files->coa_reply, "r");
520 if (!coa_reply) {
521 ERROR("Error opening %s: %s", files->coa_reply, fr_syserror(errno));
522 goto error;
523 }
524 }
525
526 if (files->coa_filter) {
527 coa_filter = fopen(files->coa_filter, "r");
528 if (!coa_filter) {
529 ERROR("Error opening %s: %s", files->coa_filter, fr_syserror(errno));
530 goto error;
531 }
532 }
533 } else {
534 packets = stdin;
535 }
536
537 /*
538 * Loop until the file is done.
539 */
540 do {
541 char const *coa_reply_filename = NULL;
542 char const *coa_filter_filename = NULL;
543
544 /*
545 * Allocate it.
546 */
547 MEM(request = talloc_zero(ctx, rc_request_t));
548 MEM(request->packet = fr_packet_alloc(request, true));
549 request->packet->uctx = request;
550
551 request->packet->socket.inet.src_ipaddr = client_ipaddr;
552 request->packet->socket.inet.src_port = client_port;
553 request->packet->socket.inet.dst_ipaddr = server_ipaddr;
554 request->packet->socket.inet.dst_port = server_port;
555 request->packet->socket.type = (ipproto == IPPROTO_TCP) ? SOCK_STREAM : SOCK_DGRAM;
556
557 request->files = files;
558 request->packet->id = last_used_id;
559 request->num = num++;
560
561 fr_pair_list_init(&request->filter);
562 fr_pair_list_init(&request->request_pairs);
563 fr_pair_list_init(&request->reply_pairs);
564
565 /*
566 * Read the request VP's.
567 */
568 if (fr_pair_list_afrom_file(request, dict_radius,
569 &request->request_pairs, packets, &packets_done, true) < 0) {
570 char const *input;
571
572 if ((files->packets[0] == '-') && (files->packets[1] == '\0')) {
573 input = "stdin";
574 } else {
575 input = files->packets;
576 }
577
578 REDEBUG("Error parsing \"%s\"", input);
579 goto error;
580 }
581
582 /*
583 * Skip empty entries
584 */
585 if (fr_pair_list_empty(&request->request_pairs)) {
586 WARN("Skipping \"%s\": No Attributes", files->packets);
587 talloc_free(request);
588 continue;
589 }
590
591 /*
592 * Read in filter VP's.
593 */
594 if (filters) {
595 bool filters_done;
596
597 if (fr_pair_list_afrom_file(request, dict_radius,
598 &request->filter, filters, &filters_done, true) < 0) {
599 REDEBUG("Error parsing \"%s\"", files->filters);
600 goto error;
601 }
602
603 if (filters_done && !packets_done) {
604 REDEBUG("Differing number of packets/filters in %s:%s "
605 "(too many requests))", files->packets, files->filters);
606 goto error;
607 }
608
609 if (!filters_done && packets_done) {
610 REDEBUG("Differing number of packets/filters in %s:%s "
611 "(too many filters))", files->packets, files->filters);
612 goto error;
613 }
614
615 vp = fr_pair_find_by_da(&request->filter, NULL, attr_packet_type);
616 if (vp) {
617 if (!FR_RADIUS_PACKET_CODE_VALID(vp->vp_uint32)) {
618 REDEBUG("Invalid filter code %u in %s:%s", vp->vp_uint32,
619 files->packets, files->filters);
620 goto error;
621 }
622
623 request->filter_code = vp->vp_uint32;
624 fr_pair_delete(&request->filter, vp);
625 }
626
627 /*
628 * This allows efficient list comparisons later
629 */
630 fr_pair_list_sort(&request->filter, fr_pair_cmp_by_da);
631 }
632
633 /*
634 * Process special attributes
635 */
636 for (vp = fr_pair_list_head(&request->request_pairs);
637 vp;
638 vp = fr_pair_list_next(&request->request_pairs, vp)) {
639 /*
640 * Allow it to set the packet type in
641 * the attributes read from the file.
642 */
643 if (vp->da == attr_packet_type) {
644 request->packet->code = vp->vp_uint32;
645 } else if (vp->da == attr_request_authenticator) {
646 if (vp->vp_length >= sizeof(request->packet->vector)) {
647 memcpy(request->packet->vector, vp->vp_octets, sizeof(request->packet->vector));
648 } else {
649 memset(request->packet->vector, 0, sizeof(request->packet->vector));
650 memcpy(request->packet->vector, vp->vp_octets, vp->vp_length);
651 }
652 } else if (vp->da == attr_cleartext_password) {
653 request->password = vp;
654 /*
655 * Keep a copy of the the password attribute.
656 */
657 } else if (vp->da == attr_chap_password) {
658 /*
659 * If it's already hex, do nothing.
660 */
661 if ((vp->vp_length == 17) && (already_hex(vp))) continue;
662
663 /*
664 * CHAP-Password is octets, so it may not be zero terminated.
665 */
666 pair_update_request(request->password, attr_cleartext_password);
667 fr_pair_value_bstrndup(request->password, vp->vp_strvalue, vp->vp_length, true);
668 } else if (vp->da == attr_ms_chap_password) {
669 pair_update_request(request->password, attr_cleartext_password);
670 fr_pair_value_bstrndup(request->password, vp->vp_strvalue, vp->vp_length, true);
671
672 } else if (vp->da == attr_radclient_test_name) {
673 request->name = vp->vp_strvalue;
674
675 /*
676 * Allow these to be dynamically specified
677 * in the request file, as well as on the
678 * command line.
679 */
680 } else if (vp->da == attr_radclient_coa_filename) {
681 coa_reply_filename = vp->vp_strvalue;
682
683 } else if (vp->da == attr_radclient_coa_filter) {
684 coa_filter_filename = vp->vp_strvalue;
685 }
686 } /* loop over the VP's we read in */
687
688 /*
689 * Use the default set on the command line
690 */
691 if (request->packet->code == FR_RADIUS_CODE_UNDEFINED) request->packet->code = packet_code;
692
693 /*
694 * Fill in the packet header from attributes, and then
695 * re-realize the attributes.
696 */
697 fr_packet_net_from_pairs(request->packet, &request->request_pairs);
698
699 /*
700 * Default to the filename
701 */
702 if (!request->name) request->name = request->files->packets;
703
704 /*
705 * Automatically set the response code from the request code
706 * (if one wasn't already set).
707 */
708 if (request->filter_code == FR_RADIUS_CODE_UNDEFINED) {
709 switch (request->packet->code) {
710 case FR_RADIUS_CODE_ACCESS_REQUEST:
711 request->filter_code = FR_RADIUS_CODE_ACCESS_ACCEPT;
712 break;
713
714 case FR_RADIUS_CODE_ACCOUNTING_REQUEST:
715 request->filter_code = FR_RADIUS_CODE_ACCOUNTING_RESPONSE;
716 break;
717
718 case FR_RADIUS_CODE_COA_REQUEST:
719 request->filter_code = FR_RADIUS_CODE_COA_ACK;
720 break;
721
722 case FR_RADIUS_CODE_DISCONNECT_REQUEST:
723 request->filter_code = FR_RADIUS_CODE_DISCONNECT_ACK;
724 break;
725
726 case FR_RADIUS_CODE_STATUS_SERVER:
727 switch (radclient_get_code(request->packet->socket.inet.dst_port)) {
728 case FR_RADIUS_CODE_ACCESS_REQUEST:
729 request->filter_code = FR_RADIUS_CODE_ACCESS_ACCEPT;
730 break;
731
732 case FR_RADIUS_CODE_ACCOUNTING_REQUEST:
733 request->filter_code = FR_RADIUS_CODE_ACCOUNTING_RESPONSE;
734 break;
735
736 default:
737 request->filter_code = FR_RADIUS_CODE_UNDEFINED;
738 break;
739 }
740 break;
741
742 case FR_RADIUS_CODE_UNDEFINED:
743 REDEBUG("Packet-Type must be defined,"
744 "or a well known RADIUS port");
745 goto error;
746
747 default:
748 REDEBUG("Can't determine expected reply.Packet-Type for Packet-Type %i",
749 request->packet->code);
750 goto error;
751 }
752 /*
753 * Automatically set the request code from the response code
754 * (if one wasn't already set).
755 */
756 } else if (request->packet->code == FR_RADIUS_CODE_UNDEFINED) {
757 switch (request->filter_code) {
758 case FR_RADIUS_CODE_ACCESS_ACCEPT:
759 case FR_RADIUS_CODE_ACCESS_REJECT:
760 request->packet->code = FR_RADIUS_CODE_ACCESS_REQUEST;
761 break;
762
763 case FR_RADIUS_CODE_ACCOUNTING_RESPONSE:
764 request->packet->code = FR_RADIUS_CODE_ACCOUNTING_REQUEST;
765 break;
766
767 case FR_RADIUS_CODE_DISCONNECT_ACK:
768 case FR_RADIUS_CODE_DISCONNECT_NAK:
769 request->packet->code = FR_RADIUS_CODE_DISCONNECT_REQUEST;
770 break;
771
772 case FR_RADIUS_CODE_COA_ACK:
773 case FR_RADIUS_CODE_COA_NAK:
774 request->packet->code = FR_RADIUS_CODE_COA_REQUEST;
775 break;
776
777 default:
778 REDEBUG("Can't determine expected Packet-Type for reply.Packet-Type %i",
779 request->filter_code);
780 goto error;
781 }
782 }
783
784 /*
785 * Automatically set the dst port (if one wasn't already set).
786 */
787 if (request->packet->socket.inet.dst_port == 0) {
788 radclient_get_port(request->packet->code, &request->packet->socket.inet.dst_port);
789 if (request->packet->socket.inet.dst_port == 0) {
790 REDEBUG("Can't determine destination port");
791 goto error;
792 }
793 }
794
795 /*
796 * Read in the CoA filename and filter.
797 */
798 if (coa_reply_filename) {
799 if (coa_reply) {
800 RDEBUG("Cannot specify CoA file on both the command line and via Radclient-CoA-Filename");
801 goto error;
802 }
803
804 coa_reply = fopen(coa_reply_filename, "r");
805 if (!coa_reply) {
806 ERROR("Error opening %s: %s", coa_reply_filename, fr_syserror(errno));
807 goto error;
808 }
809
810 if (coa_filter_filename) {
811 coa_filter = fopen(coa_filter_filename, "r");
812 if (!coa_filter) {
813 ERROR("Error opening %s: %s", coa_filter_filename, fr_syserror(errno));
814 goto error;
815 }
816 } else {
817 coa_filter = NULL;
818 }
819
820 /*
821 * Read in one CoA reply and/or filter
822 */
823 if (coa_init(request,
824 coa_reply, coa_reply_filename, &coa_reply_done,
825 coa_filter, coa_filter_filename, &coa_filter_done) < 0) {
826 goto error;
827 }
828
829 fclose(coa_reply);
830 coa_reply = NULL;
831 if (coa_filter) {
832 fclose(coa_filter);
833 coa_filter = NULL;
834 }
835 do_coa = true;
836
837 } else if (coa_reply) {
838 if (coa_init(request,
839 coa_reply, coa_reply_filename, &coa_reply_done,
840 coa_filter, coa_filter_filename, &coa_filter_done) < 0) {
841 goto error;
842 }
843
844 if (coa_reply_done != packets_done) {
845 REDEBUG("Differing number of packets in input file and coa_reply in %s:%s ",
846 files->packets, files->coa_reply);
847 goto error;
848
849 }
850 }
851
852 /*
853 * Add it to the tail of the list.
854 */
855 rc_request_list_insert_tail(&rc_request_list, request);
856
857 /*
858 * Set the destructor so it removes itself from the
859 * request list when freed. We don't set this until
860 * the packet is actually in the list, else we trigger
861 * the asserts in the free callback.
862 */
863 talloc_set_destructor(request, _rc_request_free);
864 } while (!packets_done); /* loop until the file is done. */
865
866 if (packets != stdin) fclose(packets);
867 if (filters) fclose(filters);
868 if (coa_reply) fclose(coa_reply);
869 if (coa_filter) fclose(coa_filter);
870
871 /*
872 * And we're done.
873 */
874 return 0;
875
876error:
877 talloc_free(request);
878
879 if (packets != stdin) fclose(packets);
880 if (filters) fclose(filters);
881 if (coa_reply) fclose(coa_reply);
882 if (coa_filter) fclose(coa_filter);
883
884 return -1;
885}
886
887
888/*
889 * Sanity check each argument.
890 */
891static int radclient_sane(rc_request_t *request)
892{
893 if (request->packet->socket.inet.dst_port == 0) {
894 request->packet->socket.inet.dst_port = server_port;
895 }
896 if (request->packet->socket.inet.dst_ipaddr.af == AF_UNSPEC) {
897 if (server_ipaddr.af == AF_UNSPEC) {
898 ERROR("No server was given, and request %" PRIu64 " in file %s did not contain "
899 "Packet-Dst-IP-Address", request->num, request->files->packets);
900 return -1;
901 }
902 request->packet->socket.inet.dst_ipaddr = server_ipaddr;
903 }
904 if (request->packet->code == 0) {
905 if (packet_code == -1) {
906 ERROR("Request was \"auto\", and request %" PRIu64 " in file %s did not contain Packet-Type",
907 request->num, request->files->packets);
908 return -1;
909 }
910 request->packet->code = packet_code;
911 }
912 request->packet->socket.fd = -1;
913
914 return 0;
915}
916
917
918static int8_t request_cmp(void const *one, void const *two)
919{
920 rc_request_t const *a = one, *b = two;
921 fr_pair_t *vp1, *vp2;
922
923 vp1 = fr_pair_find_by_da(&a->request_pairs, NULL, attr_coa_match_attr);
924 vp2 = fr_pair_find_by_da(&b->request_pairs, NULL, attr_coa_match_attr);
925
926 if (!vp1) return -1;
927 if (!vp2) return +1;
928
929 return fr_value_box_cmp(&vp1->data, &vp2->data);
930}
931
932
933/*
934 * Deallocate packet ID, etc.
935 */
936static void deallocate_id(rc_request_t *request)
937{
938 if (!request || !request->packet ||
939 (request->packet->id < 0)) {
940 return;
941 }
942
943 /*
944 * One more unused RADIUS ID.
945 */
946 fr_packet_list_id_free(packet_list, request->packet, true);
947
948 /*
949 * If we've already sent a packet, free up the old one,
950 * and ensure that the next packet has a unique
951 * authentication vector.
952 */
953 if (request->packet->data) TALLOC_FREE(request->packet->data);
954 if (request->reply) fr_packet_free(&request->reply);
955}
956
957/*
958 * Send one packet.
959 */
960static int send_one_packet(rc_request_t *request)
961{
962 fr_pair_t *vp;
963
964 fr_assert(request->done == false);
965
966#ifdef STATIC_ANALYZER
967 if (!secret) fr_exit_now(1);
968#endif
969
970 /*
971 * Remember when we have to wake up, to re-send the
972 * request, of we didn't receive a reply.
973 */
974 if ((fr_time_delta_eq(sleep_time, fr_time_delta_wrap(-1)) || (fr_time_delta_gt(sleep_time, timeout)))) {
975 sleep_time = timeout;
976 }
977
978 /*
979 * Haven't sent the packet yet. Initialize it.
980 */
981 if (!request->tries || request->packet->id == -1) {
982 bool rcode;
983
984 fr_assert(request->reply == NULL);
985
986 /*
987 * Didn't find a free packet ID, we're not done,
988 * we don't sleep, and we stop trying to process
989 * this packet.
990 */
991 retry:
992 request->packet->socket.inet.src_ipaddr.af = server_ipaddr.af;
993 request->packet->socket.inet.src_port = 0;
994
995 rcode = fr_packet_list_id_alloc(packet_list, ipproto, request->packet, NULL);
996 if (!rcode) {
997 int mysockfd;
998
999 if ((fixed_id >0) && (request->packet->id == fixed_id)) {
1000 fr_perror("Failed assigning fixed ID %d", fixed_id);
1001 return -1;
1002 }
1003
1004 if (ipproto == IPPROTO_TCP) {
1005 mysockfd = fr_socket_client_tcp(NULL, NULL,
1006 &request->packet->socket.inet.dst_ipaddr,
1007 request->packet->socket.inet.dst_port, false);
1008 if (mysockfd < 0) {
1009 fr_perror("Error opening client TCP socket");
1010 return -1;
1011 }
1012 } else {
1013 uint16_t port = 0;
1014
1015 mysockfd = fr_socket_server_udp(&client_ipaddr, &port, NULL, true);
1016 if (mysockfd < 0) {
1017 fr_perror("Error opening client UDP socket");
1018 return -1;
1019 }
1020
1021 if (fr_socket_bind(mysockfd, NULL, &client_ipaddr, &port) < 0) {
1022 fr_perror("Error binding socket");
1023 return -1;
1024 }
1025 }
1026
1027 if (!fr_packet_list_socket_add(packet_list, mysockfd, ipproto,
1028 &request->packet->socket.inet.dst_ipaddr,
1029 request->packet->socket.inet.dst_port, NULL)) {
1030 ERROR("Can't add new socket");
1031 fr_exit_now(1);
1032 }
1033 goto retry;
1034 }
1035
1036 fr_assert(request->packet->id != -1);
1037 fr_assert(request->packet->data == NULL);
1038
1039 /*
1040 * Update the password, so it can be encrypted with the
1041 * new authentication vector.
1042 */
1043 if (request->password) {
1044 if ((vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_chap_password)) != NULL) {
1045 uint8_t buffer[17];
1046 fr_pair_t *challenge;
1047
1048 /*
1049 * Use CHAP-Challenge pair if present, otherwise create CHAP-Challenge and
1050 * populate with current Request Authenticator.
1051 *
1052 * Request Authenticator is re-calculated by fr_packet_sign
1053 */
1054 challenge = fr_pair_find_by_da(&request->request_pairs, NULL, attr_chap_challenge);
1055 if (!challenge || (challenge->vp_length < 7)) {
1056 pair_update_request(challenge, attr_chap_challenge);
1057 fr_pair_value_memdup(challenge, request->packet->vector, RADIUS_AUTH_VECTOR_LENGTH, false);
1058 }
1059
1060 fr_chap_encode(buffer,
1061 fr_rand() & 0xff, challenge->vp_octets, challenge->vp_length,
1062 request->password->vp_strvalue,
1063 request->password->vp_length);
1064 fr_pair_value_memdup(vp, buffer, sizeof(buffer), false);
1065
1066 } else if (fr_pair_find_by_da_nested(&request->request_pairs, NULL, attr_ms_chap_password) != NULL) {
1067 mschapv1_encode(request->packet, &request->request_pairs, request->password->vp_strvalue);
1068
1069 } else {
1070 DEBUG("WARNING: No password in the request");
1071 }
1072 }
1073
1074 request->timestamp = fr_time();
1075 request->tries = 1;
1076 request->resend++;
1077
1078 } else { /* request->packet->id >= 0 */
1079 fr_time_t now = fr_time();
1080
1081 /*
1082 * FIXME: Accounting packets are never retried!
1083 * The Acct-Delay-Time attribute is updated to
1084 * reflect the delay, and the packet is re-sent
1085 * from scratch!
1086 */
1087
1088 /*
1089 * Not time for a retry, do so.
1090 */
1091 if (fr_time_delta_lt(fr_time_sub(now, request->timestamp), timeout)) {
1092 fr_time_delta_t remaining;
1093
1094 remaining = fr_time_delta_sub(timeout, fr_time_sub(now, request->timestamp));
1095
1096 if (fr_time_delta_eq(sleep_time, fr_time_delta_wrap(-1)) ||
1097 fr_time_delta_gt(sleep_time, remaining)) {
1098 sleep_time = remaining;
1099 }
1100 return 0;
1101 }
1102
1103 /*
1104 * We're not trying later, maybe the packet is done.
1105 */
1106 if (request->tries == retries) {
1107 fr_assert(request->packet->id >= 0);
1108
1109 /*
1110 * Delete the request from the tree of
1111 * outstanding requests.
1112 */
1113 fr_packet_list_yank(packet_list, request->packet);
1114
1115 REDEBUG("No reply from server for ID %d socket %d",
1116 request->packet->id, request->packet->socket.fd);
1117 deallocate_id(request);
1118
1119 /*
1120 * Normally we mark it "done" when we've received
1121 * the reply, but this is a special case.
1122 */
1123 if (request->resend == resend_count) {
1124 request->done = true;
1125 }
1126 stats.lost++;
1127 return -1;
1128 }
1129
1130 /*
1131 * We are trying later.
1132 */
1133 request->timestamp = now;
1134 request->tries++;
1135 }
1136
1137 /*
1138 * If there's a Message-Authenticator in the packet, AND it has a "don't send" operator, then
1139 * delete it. We manually encode the packet (which also prints out Message-Authenticator), and
1140 * then manually remove the Message-Authenticator bytes from the packet. The encoder still
1141 * prints out that it's sending Message-Authenticator, but oh well.
1142 */
1143 vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_message_authenticator);
1144 if (vp && (vp->op == T_OP_CMP_FALSE) && !request->packet->data &&
1145 (request->packet->code = FR_RADIUS_CODE_ACCESS_REQUEST)) {
1146 fr_pair_delete(&request->request_pairs, vp);
1147
1148 if (fr_radius_packet_encode(request->packet, &request->request_pairs, NULL, secret) < 0) {
1149 REDEBUG("Failed to encode packet for ID %d", request->packet->id);
1150 goto error;
1151 }
1152
1153 /*
1154 * Manually re-write the packet to get rid of Message-Authenticator.
1155 */
1156 if ((request->packet->data_len >= (RADIUS_HEADER_LENGTH + 18)) &&
1157 (request->packet->data[RADIUS_HEADER_LENGTH] = attr_message_authenticator->attr) &&
1158 (request->packet->data[RADIUS_HEADER_LENGTH + 1] == 18)) {
1159 memmove(request->packet->data + RADIUS_HEADER_LENGTH,
1160 request->packet->data + RADIUS_HEADER_LENGTH + 18,
1161 request->packet->data_len - RADIUS_HEADER_LENGTH - 18);
1162 request->packet->data_len -= 18;
1163 fr_nbo_from_uint16(request->packet->data + 2, request->packet->data_len);
1164 }
1165
1166 if (fr_radius_packet_sign(request->packet, NULL, secret) < 0) {
1167 REDEBUG("Failed to sign packet for ID %d", request->packet->id);
1168 goto error;
1169 }
1170 }
1171
1172 /*
1173 * Send the packet.
1174 */
1175 if (fr_radius_packet_send(request->packet, &request->request_pairs, NULL, secret) < 0) {
1176 REDEBUG("Failed to send packet for ID %d", request->packet->id);
1177 error:
1178 deallocate_id(request);
1179 request->done = true;
1180 return -1;
1181 }
1182
1183 fr_radius_packet_log(&default_log, request->packet, &request->request_pairs, false);
1184
1185 return 0;
1186}
1187
1188/*
1189 * Receive a CoA packet, maybe.
1190 */
1191static int recv_coa_packet(fr_time_delta_t wait_time)
1192{
1193 fd_set set;
1194 fr_time_delta_t our_wait_time;
1195 rc_request_t *request, *parent;
1196 fr_packet_t *packet;
1197 rc_request_t my;
1198
1199#ifdef STATIC_ANALYZER
1200 if (!secret) fr_exit_now(1);
1201#endif
1202
1203 /* And wait for reply, timing out as necessary */
1204 FD_ZERO(&set);
1205 FD_SET(coafd, &set);
1206
1207 our_wait_time = !fr_time_delta_ispos(wait_time) ? fr_time_delta_from_sec(0) : wait_time;
1208
1209 /*
1210 * No packet was received.
1211 */
1212 if (select(coafd + 1, &set, NULL, NULL, &fr_time_delta_to_timeval(our_wait_time)) <= 0) return 0;
1213
1214 /*
1215 * Read a packet from a network.
1216 */
1217 packet = fr_packet_recv(NULL, coafd, 0, 200, false);
1218 if (!packet) {
1219 DEBUG("Failed reading CoA packet");
1220 return 0;
1221 }
1222
1223 /*
1224 * Fails the signature validation: not a real reply
1225 */
1226 if (fr_radius_packet_verify(packet, NULL, secret) < 0) {
1227 DEBUG("CoA verification failed");
1228 talloc_free(packet);
1229 return 0;
1230 }
1231
1232 fr_pair_list_init(&my.request_pairs);
1233
1234 /*
1235 * Decode the packet before looking up the parent, so that we can compare the pairs.
1236 */
1237 if (fr_radius_decode_simple(packet, &my.request_pairs,
1238 packet->data, packet->data_len,
1239 NULL, secret) < 0) {
1240 DEBUG("Failed decoding CoA packet");
1241 talloc_free(packet);
1242 return 0;
1243 }
1244
1245 fr_radius_packet_log(&default_log, packet, &my.request_pairs, true);
1246
1247 /*
1248 * Find a Access-Request which has the same User-Name / etc. as this CoA packet.
1249 */
1250 my.name = "receive CoA request";
1251 my.packet = packet;
1252
1253 parent = fr_rb_find(coa_tree, &my);
1254 if (!parent) {
1255 DEBUG("No matching request packet for CoA packet %u %u", packet->data[0], packet->data[1]);
1256 talloc_free(packet);
1257 return 0;
1258 }
1259 fr_assert(parent->coa);
1260
1261 request = parent->coa;
1262 request->packet = talloc_steal(request, packet);
1263
1264 fr_pair_list_steal(request, &my.request_pairs);
1265 fr_pair_list_append(&request->request_pairs, &my.request_pairs);
1266
1267 /*
1268 * If we had an expected response code, check to see if the
1269 * packet matched that.
1270 */
1271 if (request->packet->code != request->filter_code) {
1272 if (FR_RADIUS_PACKET_CODE_VALID(request->reply->code)) {
1273 REDEBUG("%s: Expected %s got %s", request->name, fr_radius_packet_name[request->filter_code],
1274 fr_radius_packet_name[request->packet->code]);
1275 } else {
1276 REDEBUG("%s: Expected %u got %i", request->name, request->filter_code,
1277 request->packet->code);
1278 }
1279 stats.failed++;
1280
1281 /*
1282 * Check if the contents of the packet matched the filter
1283 */
1284 } else if (fr_pair_list_empty(&request->filter)) {
1285 stats.passed++;
1286
1287 } else {
1288 fr_pair_t const *failed[2];
1289
1290 fr_pair_list_sort(&request->request_pairs, fr_pair_cmp_by_da);
1291 if (fr_pair_validate(failed, &request->filter, &request->request_pairs)) {
1292 RDEBUG("%s: CoA request passed filter", request->name);
1293 stats.passed++;
1294 } else {
1295 fr_pair_validate_debug(failed);
1296 REDEBUG("%s: CoA Request for failed filter", request->name);
1297 stats.failed++;
1298 }
1299 }
1300
1301 request->reply->id = request->packet->id;
1302
1303 request->reply->socket.type = SOCK_DGRAM;
1304 request->reply->socket.af = client_ipaddr.af;
1305 request->reply->socket.fd = coafd;
1306 request->reply->socket.inet.src_ipaddr = client_ipaddr;
1307 request->reply->socket.inet.src_port = coa_port;
1308 request->reply->socket.inet.dst_ipaddr = packet->socket.inet.src_ipaddr;
1309 request->reply->socket.inet.dst_port = packet->socket.inet.src_port;
1310
1311 if (!request->reply->code) switch (packet->code) {
1312 case FR_RADIUS_CODE_COA_REQUEST:
1313 request->reply->code = FR_RADIUS_CODE_COA_ACK;
1314 break;
1315
1316 case FR_RADIUS_CODE_DISCONNECT_REQUEST:
1317 request->reply->code = FR_RADIUS_CODE_DISCONNECT_ACK;
1318 break;
1319
1320 default:
1321 RDEBUG("Failed getting reply packet type");
1322 return 0;
1323 }
1324
1325 fr_radius_packet_log(&default_log, request->reply, &request->reply_pairs, false);
1326
1327
1328 /*
1329 * Send reply.
1330 */
1331 if (fr_radius_packet_send(request->reply, &request->reply_pairs, packet, secret) < 0) {
1332 REDEBUG("Failed sending CoA reply");
1333 return 0;
1334 }
1335
1336 fr_rb_remove(coa_tree, parent);
1337
1338 /*
1339 * No longer waiting for a CoA packet for this request.
1340 */
1341 TALLOC_FREE(parent->coa);
1342 return 0;
1343}
1344
1345
1346/*
1347 * Do Blast RADIUS checks.
1348 *
1349 * The request is an Access-Request, and does NOT contain Proxy-State.
1350 *
1351 * The reply is a raw packet, and is NOT yet decoded.
1352 */
1353static int blast_radius_check(rc_request_t *request, fr_packet_t *reply)
1354{
1355 uint8_t *attr, *end;
1356 fr_pair_t *vp;
1357 bool have_message_authenticator = false;
1358
1359 /*
1360 * We've received a raw packet. Nothing has (as of yet) checked
1361 * anything in it other than the length, and that it's a
1362 * well-formed RADIUS packet.
1363 */
1364 switch (reply->data[0]) {
1365 case FR_RADIUS_CODE_ACCESS_ACCEPT:
1366 case FR_RADIUS_CODE_ACCESS_REJECT:
1367 case FR_RADIUS_CODE_ACCESS_CHALLENGE:
1368 case FR_RADIUS_CODE_PROTOCOL_ERROR:
1369 if (reply->data[1] != request->packet->id) {
1370 ERROR("Invalid reply ID %d to Access-Request ID %d", reply->data[1], request->packet->id);
1371 return -1;
1372 }
1373 break;
1374
1375 default:
1376 ERROR("Invalid reply code %d to Access-Request", reply->data[0]);
1377 return -1;
1378 }
1379
1380 /*
1381 * If the reply has a Message-Authenticator, then it MIGHT be fine.
1382 */
1383 attr = reply->data + 20;
1384 end = reply->data + reply->data_len;
1385
1386 /*
1387 * It should be the first attribute, so we warn if it isn't there.
1388 *
1389 * But it's not a fatal error.
1390 */
1391 if (blast_radius && (attr[0] != FR_MESSAGE_AUTHENTICATOR)) {
1392 RDEBUG("WARNING The %s reply packet does not have Message-Authenticator as the first attribute. The packet may be vulnerable to Blast RADIUS attacks.",
1393 fr_radius_packet_name[reply->data[0]]);
1394 }
1395
1396 /*
1397 * Set up for Proxy-State checks.
1398 *
1399 * If we see a Proxy-State in the reply which we didn't send, then it's a Blast RADIUS attack.
1400 */
1401 vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_proxy_state);
1402
1403 while (attr < end) {
1404 /*
1405 * Blast RADIUS work-arounds require that
1406 * Message-Authenticator is the first attribute in the
1407 * reply. Note that we don't check for it being the
1408 * first attribute, but simply that it exists.
1409 *
1410 * That check is a balance between securing the reply
1411 * packet from attacks, and not violating the RFCs which
1412 * say that there is no order to attributes in the
1413 * packet.
1414 *
1415 * However, no matter the status of the '-b' flag we
1416 * still can check for the signature of the attack, and
1417 * discard packets which are suspicious. This behavior
1418 * protects radclient from the attack, without mandating
1419 * new behavior on the server side.
1420 *
1421 * Note that we don't set the '-b' flag by default.
1422 * radclient is intended for testing / debugging, and is
1423 * not intended to be used as part of a secure login /
1424 * user checking system.
1425 */
1426 if (attr[0] == FR_MESSAGE_AUTHENTICATOR) {
1427 have_message_authenticator = true;
1428 goto next;
1429 }
1430
1431 /*
1432 * If there are Proxy-State attributes in the reply, they must
1433 * match EXACTLY the Proxy-State attributes in the request.
1434 *
1435 * Note that we don't care if there are more Proxy-States
1436 * in the request than in the reply. The Blast RADIUS
1437 * issue requires _adding_ Proxy-State attributes, and
1438 * cannot work when the server _deletes_ Proxy-State
1439 * attributes.
1440 */
1441 if (attr[0] == FR_PROXY_STATE) {
1442 if (!vp || (vp->vp_length != (size_t) (attr[1] - 2)) || (memcmp(vp->vp_octets, attr + 2, vp->vp_length) != 0)) {
1443 ERROR("Invalid reply to Access-Request ID %d - Discarding packet due to Blast RADIUS attack being detected.", request->packet->id);
1444 ERROR("We received a Proxy-State in the reply which we did not send, or which is different from what we sent.");
1445 return -1;
1446 }
1447
1448 vp = fr_pair_find_by_da(&request->request_pairs, vp, attr_proxy_state);
1449 }
1450
1451 next:
1452 attr += attr[1];
1453 }
1454
1455 /*
1456 * If "-b" is set, then we require Message-Authenticator in the reply.
1457 */
1458 if (blast_radius && !have_message_authenticator) {
1459 ERROR("The %s reply packet does not contain Message-Authenticator - discarding packet due to Blast RADIUS checks.",
1460 fr_radius_packet_name[reply->data[0]]);
1461 return -1;
1462 }
1463
1464 /*
1465 * The packet doesn't look like it's a Blast RADIUS attack. The
1466 * caller will now verify the packet signature.
1467 */
1468 return 0;
1469}
1470
1471/*
1472 * Receive one packet, maybe.
1473 */
1474static int recv_one_packet(fr_time_delta_t wait_time)
1475{
1476 int rcode;
1477 fd_set set;
1478 fr_time_delta_t our_wait_time;
1479 rc_request_t *request;
1480 fr_packet_t *reply, *packet;
1481 volatile int max_fd;
1482
1483#ifdef STATIC_ANALYZER
1484 if (!secret) fr_exit_now(1);
1485#endif
1486
1487 /* And wait for reply, timing out as necessary */
1488 FD_ZERO(&set);
1489
1490 max_fd = fr_packet_list_fd_set(packet_list, &set);
1491 if (max_fd < 0) fr_exit_now(1); /* no sockets to listen on! */
1492
1493 our_wait_time = !fr_time_delta_ispos(wait_time) ? fr_time_delta_from_sec(0) : wait_time;
1494
1495 if (do_coa && fr_rb_num_elements(coa_tree) > 0) {
1496 FD_SET(coafd, &set);
1497 if (coafd >= max_fd) max_fd = coafd + 1;
1498 }
1499
1500 /*
1501 * See if a packet was received.
1502 */
1503retry:
1504 if (select(max_fd, &set, NULL, NULL, &fr_time_delta_to_timeval(our_wait_time)) <= 0) return 0;
1505
1506 /*
1507 * Read a CoA packet
1508 */
1509 if (FD_ISSET(coafd, &set)) {
1510 recv_coa_packet(fr_time_delta_wrap(0));
1511 FD_CLR(coafd, &set);
1512 our_wait_time = fr_time_delta_from_sec(0);
1513 goto retry;
1514 }
1515
1516 /*
1517 * Look for the packet.
1518 */
1519 rcode = fr_packet_list_recv(packet_list, &set, NULL, &reply, RADIUS_MAX_ATTRIBUTES, false);
1520 if (rcode < 0) {
1521 ERROR("Received bad packet");
1522
1523 /*
1524 * If the packet is bad, we close the socket.
1525 * I'm not sure how to do that now, so we just
1526 * die...
1527 */
1528 if (ipproto == IPPROTO_TCP) fr_exit_now(1);
1529 return -1; /* bad packet */
1530 }
1531
1532 /*
1533 * We don't use udpfromto. So if we bind to "*", we want
1534 * to find replies sent to 192.0.2.4. Therefore, we
1535 * force all replies to have the one address we know
1536 * about, no matter what real address they were sent to.
1537 *
1538 * This only works if were not using any of the
1539 * Packet-* attributes, or running with 'auto'.
1540 */
1541 reply->socket.inet.dst_ipaddr = client_ipaddr;
1542 reply->socket.inet.dst_port = client_port;
1543 reply->code = reply->data[0];
1544 reply->id = reply->data[1];
1545
1546 /*
1547 * TCP sockets don't use recvmsg(), and thus don't get
1548 * the source IP/port. However, since they're TCP, we
1549 * know what the source IP/port is, because that's where
1550 * we connected to.
1551 */
1552 if (ipproto == IPPROTO_TCP) {
1553 reply->socket.inet.src_ipaddr = server_ipaddr;
1554 reply->socket.inet.src_port = server_port;
1555 }
1556
1557 packet = fr_packet_list_find_byreply(packet_list, reply);
1558 if (!packet) {
1559 ERROR("Received reply to request we did not send. (id=%d socket %d)",
1560 reply->id, reply->socket.fd);
1561 fr_packet_free(&reply);
1562 return -1; /* got reply to packet we didn't send */
1563 }
1564 request = packet->uctx;
1565
1566 /*
1567 * We want radclient to be able to send any packet, including
1568 * imperfect ones. However, we do NOT want to be vulnerable to
1569 * the "Blast RADIUS" issue. Instead of adding command-line
1570 * flags to enable/disable similar flags to what the server
1571 * sends, we just do a few more smart checks to double-check
1572 * things.
1573 */
1574 if ((request->packet->code == FR_RADIUS_CODE_ACCESS_REQUEST) &&
1575 blast_radius_check(request, reply) < 0) {
1576 fr_packet_free(&reply);
1577 return -1;
1578 }
1579
1580 /*
1581 * Fails the signature validation: not a real reply.
1582 * FIXME: Silently drop it and listen for another packet.
1583 */
1584 if (fr_radius_packet_verify(reply, request->packet, secret) < 0) {
1585 REDEBUG("Reply verification failed");
1586 stats.lost++;
1587 goto packet_done; /* shared secret is incorrect */
1588 }
1589
1590 if (print_filename) {
1591 RDEBUG("%s response code %d", request->files->packets, reply->code);
1592 }
1593
1594 if (request->tries < ignore_count) {
1595 RDEBUG("Ignoring response %d due to -e ignore_count=%d", request->tries, ignore_count);
1596 goto packet_done;
1597 }
1598
1599 deallocate_id(request);
1600 request->reply = reply;
1601 reply = NULL;
1602
1603 /*
1604 * If this fails, we're out of memory.
1605 */
1606 if (fr_radius_decode_simple(request, &request->reply_pairs,
1607 request->reply->data, request->reply->data_len,
1608 request->packet->vector, secret) < 0) {
1609 REDEBUG("Reply decode failed");
1610 stats.lost++;
1611 goto packet_done;
1612 }
1613 PAIR_LIST_VERIFY(&request->reply_pairs);
1614 fr_radius_packet_log(&default_log, request->reply, &request->reply_pairs, true);
1615
1616 /*
1617 * Increment counters...
1618 */
1619 switch (request->reply->code) {
1620 case FR_RADIUS_CODE_ACCESS_ACCEPT:
1621 case FR_RADIUS_CODE_ACCOUNTING_RESPONSE:
1622 case FR_RADIUS_CODE_COA_ACK:
1623 case FR_RADIUS_CODE_DISCONNECT_ACK:
1624 stats.accepted++;
1625 break;
1626
1627 case FR_RADIUS_CODE_ACCESS_CHALLENGE:
1628 break;
1629
1630 case FR_RADIUS_CODE_PROTOCOL_ERROR:
1631 stats.error++;
1632 break;
1633 default:
1634 stats.rejected++;
1635 }
1636
1637 fr_strerror_clear(); /* Clear strerror buffer */
1638
1639 /*
1640 * If we had an expected response code, check to see if the
1641 * packet matched that.
1642 */
1643 if ((request->filter_code != FR_RADIUS_CODE_UNDEFINED) && (request->reply->code != request->filter_code)) {
1644 if (FR_RADIUS_PACKET_CODE_VALID(request->reply->code)) {
1645 REDEBUG("%s: Expected %s got %s", request->name, fr_radius_packet_name[request->filter_code],
1646 fr_radius_packet_name[request->reply->code]);
1647 } else {
1648 REDEBUG("%s: Expected %u got %i", request->name, request->filter_code,
1649 request->reply->code);
1650 }
1651 stats.failed++;
1652 /*
1653 * Check if the contents of the packet matched the filter
1654 */
1655 } else if (fr_pair_list_empty(&request->filter)) {
1656 stats.passed++;
1657 } else {
1658 fr_pair_t const *failed[2];
1659
1660 fr_pair_list_sort(&request->reply_pairs, fr_pair_cmp_by_da);
1661 if (fr_pair_validate(failed, &request->filter, &request->reply_pairs)) {
1662 RDEBUG("%s: Response passed filter", request->name);
1663 stats.passed++;
1664 } else {
1665 fr_pair_validate_debug(failed);
1666 REDEBUG("%s: Response for failed filter", request->name);
1667 stats.failed++;
1668 }
1669 }
1670
1671 if (request->resend == resend_count) {
1672 request->done = true;
1673 }
1674
1675packet_done:
1676 fr_packet_free(&request->reply);
1677 fr_packet_free(&reply); /* may be NULL */
1678
1679 return 0;
1680}
1681
1682/**
1683 *
1684 * @hidecallgraph
1685 */
1686int main(int argc, char **argv)
1687{
1688 int ret = EXIT_SUCCESS;
1689 int c;
1690 char const *confdir = CONFDIR;
1691 char const *dict_dir = DICTDIR;
1692 char filesecret[256];
1693 FILE *fp;
1694 int do_summary = false;
1695 int persec = 0;
1696 int parallel = 1;
1697 int force_af = AF_UNSPEC;
1698#ifndef NDEBUG
1699 TALLOC_CTX *autofree;
1700#endif
1701 fr_dlist_head_t filenames;
1702 rc_request_t *request;
1703
1704 /*
1705 * It's easier having two sets of flags to set the
1706 * verbosity of library calls and the verbosity of
1707 * radclient.
1708 */
1709 fr_debug_lvl = 0;
1710 fr_log_fp = stdout;
1711
1712 /*
1713 * Must be called first, so the handler is called last
1714 */
1715 fr_atexit_global_setup();
1716
1717#ifndef NDEBUG
1718 autofree = talloc_autofree_context();
1719
1720 if (fr_fault_setup(autofree, getenv("PANIC_ACTION"), argv[0]) < 0) {
1721 fr_perror("radclient");
1722 fr_exit_now(EXIT_FAILURE);
1723 }
1724#endif
1725
1726 talloc_set_log_stderr();
1727
1728 rc_request_list_talloc_init(&rc_request_list);
1729
1730 fr_dlist_talloc_init(&filenames, rc_file_pair_t, entry);
1731
1732 /*
1733 * Always log to stdout
1734 */
1735 default_log.dst = L_DST_STDOUT;
1736 default_log.fd = STDOUT_FILENO;
1737 default_log.print_level = false;
1738
1739 while ((c = getopt(argc, argv, "46bc:A:C:d:D:e:f:Fhi:n:o:p:P:r:sS:t:vx")) != -1) switch (c) {
1740 case '4':
1741 force_af = AF_INET;
1742 break;
1743
1744 case '6':
1745 force_af = AF_INET6;
1746 break;
1747
1748 case 'A':
1749 attr_coa_filter_name = optarg;
1750 break;
1751
1752 case 'b':
1753 blast_radius = true;
1754 break;
1755
1756 case 'c':
1757 if (!isdigit((uint8_t) *optarg)) usage();
1758
1759 resend_count = atoi(optarg);
1760
1761 if (resend_count < 1) usage();
1762 break;
1763
1764 case 'C':
1765 {
1766 int tmp;
1767
1768 if (strchr(optarg, ':')) {
1769 if (fr_inet_pton_port(&client_ipaddr, &client_port,
1770 optarg, -1, AF_UNSPEC, true, false) < 0) {
1771 fr_perror("Failed parsing source address");
1772 fr_exit_now(1);
1773 }
1774 break;
1775 }
1776
1777 tmp = atoi(optarg);
1778 if (tmp < 1 || tmp > 65535) usage();
1779
1780 client_port = (uint16_t)tmp;
1781 }
1782 break;
1783
1784 case 'D':
1785 dict_dir = optarg;
1786 break;
1787
1788 case 'd':
1789 confdir = optarg;
1790 break;
1791
1792 case 'e': /* magical extra stuff */
1793 if (strncmp(optarg, "ignore_count=", 13) == 0) {
1794 ignore_count = atoi(optarg + 13);
1795 break;
1796 }
1797 usage();
1798
1799 /*
1800 * packet,filter,coa_reply,coa_filter
1801 */
1802 case 'f':
1803 {
1804 char const *p;
1805 rc_file_pair_t *files;
1806
1807 MEM(files = talloc_zero(talloc_autofree_context(), rc_file_pair_t));
1808
1809 /*
1810 * Commas are nicer than colons.
1811 */
1812 c = ':';
1813
1814 p = strchr(optarg, c);
1815 if (!p) {
1816 c = ',';
1817 p = strchr(optarg, c);
1818 }
1819 if (!p) {
1820 files->packets = optarg;
1821 files->filters = NULL;
1822 } else {
1823 char *q;
1824
1825 MEM(files->packets = talloc_strndup(files, optarg, p - optarg));
1826 files->filters = p + 1;
1827
1828 /*
1829 * Look for CoA filename
1830 */
1831 q = UNCONST(char *, strchr(files->filters, c));
1832 if (q) {
1833 do_coa = true;
1834
1835 *(q++) = '\0';
1836 files->coa_reply = q;
1837
1838 q = UNCONST(char *, strchr(files->coa_reply, c));
1839 if (q) {
1840 *(q++) = '\0';
1841 files->coa_filter = q;
1842 }
1843 }
1844 }
1845 fr_dlist_insert_tail(&filenames, files);
1846 }
1847 break;
1848
1849 case 'F':
1850 print_filename = true;
1851 break;
1852
1853 case 'i':
1854 if (!isdigit((uint8_t) *optarg)) {
1855 usage();
1856 }
1857 fixed_id = last_used_id = atoi(optarg);
1858 if ((last_used_id < 0) || (last_used_id > 255)) {
1859 usage();
1860 }
1861 break;
1862
1863 case 'n':
1864 persec = atoi(optarg);
1865 if (persec <= 0) usage();
1866 break;
1867
1868 case 'o':
1869 coa_port = atoi(optarg);
1870 break;
1871
1872 /*
1873 * Note that sending MANY requests in
1874 * parallel can over-run the kernel
1875 * queues, and Linux will happily discard
1876 * packets. So even if the server responds,
1877 * the client may not see the reply.
1878 */
1879 case 'p':
1880 parallel = atoi(optarg);
1881 if (parallel <= 0) usage();
1882 break;
1883
1884 case 'P':
1885 if (!strcmp(optarg, "tcp")) {
1886 ipproto = IPPROTO_TCP;
1887 } else if (!strcmp(optarg, "udp")) {
1888 ipproto = IPPROTO_UDP;
1889 } else {
1890 usage();
1891 }
1892 break;
1893
1894 case 'r':
1895 if (!isdigit((uint8_t) *optarg)) usage();
1896 retries = atoi(optarg);
1897 if ((retries == 0) || (retries > 1000)) usage();
1898 break;
1899
1900 case 's':
1901 do_summary = true;
1902 break;
1903
1904 case 'S':
1905 {
1906 char *p;
1907 fp = fopen(optarg, "r");
1908 if (!fp) {
1909 ERROR("Error opening %s: %s", optarg, fr_syserror(errno));
1910 fr_exit_now(1);
1911 }
1912 if (fgets(filesecret, sizeof(filesecret), fp) == NULL) {
1913 ERROR("Error reading %s: %s", optarg, fr_syserror(errno));
1914 fr_exit_now(1);
1915 }
1916 fclose(fp);
1917
1918 /* truncate newline */
1919 p = filesecret + strlen(filesecret) - 1;
1920 while ((p >= filesecret) &&
1921 (*p < ' ')) {
1922 *p = '\0';
1923 --p;
1924 }
1925
1926 if (strlen(filesecret) < 2) {
1927 ERROR("Secret in %s is too short", optarg);
1928 fr_exit_now(1);
1929 }
1930 secret = talloc_strdup(NULL, filesecret);
1931 }
1932 break;
1933
1934 case 't':
1935 if (fr_time_delta_from_str(&timeout, optarg, strlen(optarg), FR_TIME_RES_SEC) < 0) {
1936 fr_perror("Failed parsing timeout value");
1937 fr_exit_now(EXIT_FAILURE);
1938 }
1939 break;
1940
1941 case 'v':
1942 fr_debug_lvl = 1;
1943 DEBUG("%s", radclient_version);
1944 fr_exit_now(0);
1945
1946 case 'x':
1947 fr_debug_lvl++;
1948 if (fr_debug_lvl > 1) default_log.print_level = true;
1949 break;
1950
1951 case 'h':
1952 default:
1953 usage();
1954 }
1955 argc -= (optind - 1);
1956 argv += (optind - 1);
1957
1958 if ((argc < 3) || ((secret == NULL) && (argc < 4))) {
1959 ERROR("Insufficient arguments");
1960 usage();
1961 }
1962 /*
1963 * Mismatch between the binary and the libraries it depends on
1964 */
1965 if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) {
1966 fr_perror("radclient");
1967 fr_exit_now(EXIT_FAILURE);
1968 }
1969
1970 if (!fr_dict_global_ctx_init(NULL, true, dict_dir)) {
1971 fr_perror("radclient");
1972 fr_exit_now(EXIT_FAILURE);
1973 }
1974
1975 if (fr_radius_global_init() < 0) {
1976 fr_perror("radclient");
1977 fr_exit_now(EXIT_FAILURE);
1978 }
1979
1980 if (fr_dict_autoload(radclient_dict) < 0) {
1981 fr_perror("radclient");
1982 exit(EXIT_FAILURE);
1983 }
1984
1985 if (fr_dict_attr_autoload(radclient_dict_attr) < 0) {
1986 fr_perror("radclient");
1987 exit(EXIT_FAILURE);
1988 }
1989
1990 if (fr_dict_read(fr_dict_unconst(dict_freeradius), confdir, FR_DICTIONARY_FILE) == -1) {
1991 fr_log_perror(&default_log, L_ERR, __FILE__, __LINE__, NULL,
1992 "Failed to initialize the dictionaries");
1993 exit(EXIT_FAILURE);
1994 }
1995
1996 if (do_coa) {
1997 attr_coa_match_attr = fr_dict_attr_by_name(NULL, fr_dict_root(dict_radius), attr_coa_filter_name);
1998 if (!attr_coa_match_attr) {
1999 ERROR("Unknown or invalid CoA filter attribute %s", attr_coa_filter_name);
2000 fr_exit_now(1);
2001 }
2002
2003 MEM(coa_tree = fr_rb_inline_talloc_alloc(NULL, rc_request_t, node, request_cmp, NULL));
2004 }
2005 packet_global_init();
2006
2007 fr_strerror_clear(); /* Clear the error buffer */
2008
2009 /*
2010 * Get the request type
2011 */
2012 if (!isdigit((uint8_t) argv[2][0])) {
2013 packet_code = fr_table_value_by_str(fr_radius_request_name_table, argv[2], -2);
2014 if (packet_code == -2) {
2015 ERROR("Unrecognised request type \"%s\"", argv[2]);
2016 usage();
2017 }
2018 } else {
2019 packet_code = atoi(argv[2]);
2020 }
2021
2022 /*
2023 * Resolve hostname.
2024 */
2025 if (strcmp(argv[1], "-") != 0) {
2026 if (fr_inet_pton_port(&server_ipaddr, &server_port, argv[1], -1, force_af, true, true) < 0) {
2027 fr_perror("radclient");
2028 fr_exit_now(1);
2029 }
2030
2031 /*
2032 * Work backwards from the port to determine the packet type
2033 */
2034 if (packet_code == FR_RADIUS_CODE_UNDEFINED) packet_code = radclient_get_code(server_port);
2035 }
2036 radclient_get_port(packet_code, &server_port);
2037
2038 /*
2039 * Add the secret.
2040 */
2041 if (argv[3]) {
2042 talloc_free(secret);
2043 secret = talloc_strdup(NULL, argv[3]);
2044 }
2045
2046 /*
2047 * If no '-f' is specified, we're reading from stdin.
2048 */
2049 if (fr_dlist_num_elements(&filenames) == 0) {
2050 rc_file_pair_t *files;
2051
2052 files = talloc_zero(talloc_autofree_context(), rc_file_pair_t);
2053 files->packets = "-";
2054 if (radclient_init(files, files) < 0) fr_exit_now(1);
2055 }
2056
2057 /*
2058 * Walk over the list of filenames, creating the requests.
2059 */
2060 fr_dlist_foreach(&filenames, rc_file_pair_t, files) {
2061 if (radclient_init(files, files)) {
2062 ERROR("Failed parsing input files");
2063 fr_exit_now(1);
2064 }
2065 }
2066
2067 /*
2068 * No packets read. Die.
2069 */
2070 if (!rc_request_list_num_elements(&rc_request_list)) {
2071 ERROR("Nothing to send");
2072 fr_exit_now(1);
2073 }
2074
2075 if (openssl3_init() < 0) {
2076 fr_perror("radclient");
2077 fr_exit_now(EXIT_FAILURE);
2078 }
2079
2080 /*
2081 * Bind to the first specified IP address and port.
2082 * This means we ignore later ones.
2083 */
2084 request = rc_request_list_head(&rc_request_list);
2085
2086 if (client_ipaddr.af == AF_UNSPEC) {
2087 if (request->packet->socket.inet.src_ipaddr.af == AF_UNSPEC) {
2088 memset(&client_ipaddr, 0, sizeof(client_ipaddr));
2089 client_ipaddr.af = server_ipaddr.af;
2090 } else {
2091 client_ipaddr = request->packet->socket.inet.src_ipaddr;
2092 }
2093 }
2094
2095 if (client_port == 0) client_port = request->packet->socket.inet.src_port;
2096
2097 if (ipproto == IPPROTO_TCP) {
2098 sockfd = fr_socket_client_tcp(NULL, NULL, &server_ipaddr, server_port, false);
2099 if (sockfd < 0) {
2100 ERROR("Failed opening client TCP socket");
2101 return -1;
2102 }
2103
2104 } else {
2105 sockfd = fr_socket_server_udp(&client_ipaddr, &client_port, NULL, false);
2106 if (sockfd < 0) {
2107 fr_perror("Error opening client UDP socket");
2108 return -1;
2109 }
2110
2111 if (fr_socket_bind(sockfd, NULL, &client_ipaddr, &client_port) < 0) {
2112 fr_perror("Error binding socket");
2113 return -1;
2114 }
2115 }
2116
2117 if (do_coa) {
2118 coafd = fr_socket_server_udp(&client_ipaddr, &coa_port, NULL, false);
2119 if (coafd < 0) {
2120 fr_perror("Error opening CoA socket");
2121 return -1;
2122 }
2123
2124 if (fr_socket_bind(coafd, NULL, &client_ipaddr, &coa_port) < 0) {
2125 fr_perror("Error binding socket");
2126 return -1;
2127 }
2128 }
2129
2130 MEM(packet_list = fr_packet_list_create(1));
2131 if (!fr_packet_list_socket_add(packet_list, sockfd, ipproto, &server_ipaddr,
2132 server_port, NULL)) {
2133 fr_perror("Failed adding socket");
2134 fr_exit_now(1);
2135 }
2136
2137 /*
2138 * Walk over the list of packets, sanity checking
2139 * everything.
2140 */
2141 rc_request_list_foreach(&rc_request_list, this) {
2142 this->packet->socket.inet.src_ipaddr = client_ipaddr;
2143 this->packet->socket.inet.src_port = client_port;
2144 if (radclient_sane(this) != 0) {
2145 fr_exit_now(1);
2146 }
2147 }
2148
2149 /*
2150 * Walk over the packets to send, until
2151 * we're all done.
2152 *
2153 * FIXME: This currently busy-loops until it receives
2154 * all of the packets. It should really have some sort of
2155 * send packet, get time to wait, select for time, etc.
2156 * loop.
2157 */
2158 do {
2159 int n = parallel;
2160 char const *filename = NULL;
2161
2162 done = true;
2163 sleep_time = fr_time_delta_wrap(-1);
2164
2165 /*
2166 * Walk over the packets, sending them.
2167 *
2168 * This essentially ends up handling
2169 * retries as well, as requests to
2170 * retry stay in the request list, and
2171 * then get sent again on the next
2172 * iteration of the outer loop.
2173 */
2174 rc_request_list_foreach(&rc_request_list, this) {
2175 /*
2176 * If there's a packet to receive,
2177 * receive it, but don't wait for a
2178 * packet.
2179 */
2180 recv_one_packet(fr_time_delta_wrap(0));
2181
2182 /*
2183 * This packet is done. Delete it.
2184 */
2185 if (this->done) {
2186 /*
2187 * We still have a CoA reply to
2188 * receive for this packet.
2189 */
2190 if (this->coa) {
2191 recv_coa_packet(fr_time_delta_wrap(0));
2192 if (this->coa) continue;
2193 }
2194
2195 talloc_free(this);
2196 continue;
2197 }
2198
2199 /*
2200 * Packets from multiple '-f' are sent
2201 * in parallel.
2202 *
2203 * Packets from one file are sent in
2204 * series, unless '-p' is specified, in
2205 * which case N packets from each file
2206 * are sent in parallel.
2207 */
2208 if (this->files->packets != filename) {
2209 filename = this->files->packets;
2210 n = parallel;
2211 }
2212
2213 if (n > 0) {
2214 n--;
2215
2216 /*
2217 * Send the current packet.
2218 */
2219 if (send_one_packet(this) < 0) {
2220 talloc_free(this);
2221 break;
2222 }
2223
2224 /*
2225 * Wait a little before sending
2226 * the next packet, if told to.
2227 */
2228 if (persec) {
2229 fr_time_delta_t psec;
2230
2231 psec = (persec == 1) ? fr_time_delta_from_sec(1) : fr_time_delta_wrap(1000000 / persec);
2232
2233 /*
2234 * Don't sleep elsewhere.
2235 */
2236 sleep_time = fr_time_delta_wrap(0);
2237
2238
2239 /*
2240 * Sleep for milliseconds,
2241 * portably.
2242 *
2243 * If we get an error or
2244 * a signal, treat it like
2245 * a normal timeout.
2246 */
2247 select(0, NULL, NULL, NULL, &fr_time_delta_to_timeval(psec));
2248 }
2249
2250 /*
2251 * If we haven't sent this packet
2252 * often enough, we're not done,
2253 * and we shouldn't sleep.
2254 */
2255 if (this->resend < resend_count) {
2256 int i;
2257
2258 done = false;
2259 sleep_time = fr_time_delta_wrap(0);
2260
2261 for (i = 0; i < 4; i++) {
2262 ((uint32_t *) this->packet->vector)[i] = fr_rand();
2263 }
2264 }
2265 } else { /* haven't sent this packet, we're not done */
2266 fr_assert(this->done == false);
2267 fr_assert(this->reply == NULL);
2268 done = false;
2269 }
2270 }
2271
2272 /*
2273 * Still have outstanding requests.
2274 */
2275 if (fr_packet_list_num_elements(packet_list) > 0) {
2276 done = false;
2277 } else {
2278 sleep_time = fr_time_delta_wrap(0);
2279 }
2280
2281 /*
2282 * Nothing to do until we receive a request, so
2283 * sleep until then. Once we receive one packet,
2284 * we go back, and walk through the whole list again,
2285 * sending more packets (if necessary), and updating
2286 * the sleep time.
2287 */
2288 if (!done && fr_time_delta_ispos(sleep_time)) {
2289 recv_one_packet(sleep_time);
2290 }
2291 } while (!done);
2292
2293 fr_packet_list_free(packet_list);
2294
2295 rc_request_list_talloc_free(&rc_request_list);
2296
2297 talloc_free(coa_tree);
2298
2299 talloc_free(secret);
2300
2301 fr_radius_global_free();
2302
2303 if (fr_dict_autofree(radclient_dict) < 0) {
2304 fr_perror("radclient");
2305 ret = EXIT_FAILURE;
2306 }
2307
2308#ifndef NDEBUG
2309 talloc_free(autofree);
2310#endif
2311
2312 if (do_summary) {
2313 fr_perror("Packet summary:\n"
2314 "\tAccepted : %" PRIu64 "\n"
2315 "\tRejected : %" PRIu64 "\n"
2316 "\tLost : %" PRIu64 "\n"
2317 "\tErrored : %" PRIu64 "\n"
2318 "\tPassed filter : %" PRIu64 "\n"
2319 "\tFailed filter : %" PRIu64,
2320 stats.accepted,
2321 stats.rejected,
2322 stats.lost,
2323 stats.error,
2324 stats.passed,
2325 stats.failed
2326 );
2327 }
2328
2329 /*
2330 * Ensure our atexit handlers run before any other
2331 * atexit handlers registered by third party libraries.
2332 */
2333 fr_atexit_global_trigger_all();
2334
2335 if ((stats.lost > 0) || (stats.failed > 0)) return EXIT_FAILURE;
2336
2337 openssl3_free();
2338
2339 return ret;
2340}
buffer
static int const char char buffer[256]
Definition acutest.h:576
n
int n
Definition acutest.h:577
fr_atexit_global_setup
int fr_atexit_global_setup(void)
Setup the atexit handler, should be called at the start of a program's execution.
Definition atexit.c:179
fr_atexit_global_trigger_all
int fr_atexit_global_trigger_all(void)
Cause all global free triggers to fire.
Definition atexit.c:308
UNCONST
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
Definition build.h:186
RCSID
#define RCSID(id)
Definition build.h:512
NEVER_RETURNS
#define NEVER_RETURNS
Should be placed before the function return type.
Definition build.h:334
fr_chap_encode
void fr_chap_encode(uint8_t out[static 1+FR_CHAP_CHALLENGE_LENGTH], uint8_t id, uint8_t const *challenge, size_t challenge_len, char const *password, size_t password_len)
Encode a CHAP password.
Definition chap.c:34
autofree
TALLOC_CTX * autofree
Definition common.c:29
fr_fault_setup
int fr_fault_setup(TALLOC_CTX *ctx, char const *cmd, char const *program)
Registers signal handlers to execute panic_action on fatal signal.
Definition debug.c:1071
MEM
#define MEM(x)
Definition debug.h:36
fr_exit_now
#define fr_exit_now(_x)
Exit without calling atexit() handlers, producing a log message in debug builds.
Definition debug.h:226
fr_radius_packet_code_t
fr_radius_packet_code_t
RADIUS packet codes.
Definition defs.h:31
FR_RADIUS_CODE_ACCESS_CHALLENGE
@ FR_RADIUS_CODE_ACCESS_CHALLENGE
RFC2865 - Access-Challenge.
Definition defs.h:43
FR_RADIUS_CODE_ACCESS_REQUEST
@ FR_RADIUS_CODE_ACCESS_REQUEST
RFC2865 - Access-Request.
Definition defs.h:33
FR_RADIUS_CODE_DISCONNECT_REQUEST
@ FR_RADIUS_CODE_DISCONNECT_REQUEST
RFC3575/RFC5176 - Disconnect-Request.
Definition defs.h:46
FR_RADIUS_CODE_DISCONNECT_ACK
@ FR_RADIUS_CODE_DISCONNECT_ACK
RFC3575/RFC5176 - Disconnect-Ack (positive)
Definition defs.h:47
FR_RADIUS_CODE_STATUS_SERVER
@ FR_RADIUS_CODE_STATUS_SERVER
RFC2865/RFC5997 - Status Server (request)
Definition defs.h:44
FR_RADIUS_CODE_COA_REQUEST
@ FR_RADIUS_CODE_COA_REQUEST
RFC3575/RFC5176 - CoA-Request.
Definition defs.h:49
FR_RADIUS_CODE_ACCESS_ACCEPT
@ FR_RADIUS_CODE_ACCESS_ACCEPT
RFC2865 - Access-Accept.
Definition defs.h:34
FR_RADIUS_CODE_ACCOUNTING_RESPONSE
@ FR_RADIUS_CODE_ACCOUNTING_RESPONSE
RFC2866 - Accounting-Response.
Definition defs.h:37
FR_RADIUS_CODE_COA_NAK
@ FR_RADIUS_CODE_COA_NAK
RFC3575/RFC5176 - CoA-Nak (not willing to perform)
Definition defs.h:51
FR_RADIUS_CODE_UNDEFINED
@ FR_RADIUS_CODE_UNDEFINED
Packet code has not been set.
Definition defs.h:32
FR_RADIUS_CODE_COA_ACK
@ FR_RADIUS_CODE_COA_ACK
RFC3575/RFC5176 - CoA-Ack (positive)
Definition defs.h:50
FR_RADIUS_CODE_DISCONNECT_NAK
@ FR_RADIUS_CODE_DISCONNECT_NAK
RFC3575/RFC5176 - Disconnect-Nak (not willing to perform)
Definition defs.h:48
FR_RADIUS_CODE_PROTOCOL_ERROR
@ FR_RADIUS_CODE_PROTOCOL_ERROR
RFC7930 - Protocol-Error (generic NAK)
Definition defs.h:52
FR_RADIUS_CODE_ACCOUNTING_REQUEST
@ FR_RADIUS_CODE_ACCOUNTING_REQUEST
RFC2866 - Accounting-Request.
Definition defs.h:36
FR_RADIUS_CODE_ACCESS_REJECT
@ FR_RADIUS_CODE_ACCESS_REJECT
RFC2865 - Access-Reject.
Definition defs.h:35
FR_COA_UDP_PORT
#define FR_COA_UDP_PORT
Definition defs.h:63
FR_AUTH_UDP_PORT
#define FR_AUTH_UDP_PORT
Definition defs.h:57
FR_ACCT_UDP_PORT_ALT
#define FR_ACCT_UDP_PORT_ALT
Definition defs.h:60
FR_AUTH_UDP_PORT_ALT
#define FR_AUTH_UDP_PORT_ALT
Definition defs.h:58
FR_POD_UDP_PORT
#define FR_POD_UDP_PORT
Definition defs.h:61
FR_ACCT_UDP_PORT
#define FR_ACCT_UDP_PORT
Definition defs.h:59
ERROR
#define ERROR(fmt,...)
Definition dhcpclient.c:40
dict_freeradius
static fr_dict_t const * dict_freeradius
Definition dhcpclient.c:78
DEBUG
#define DEBUG(fmt,...)
Definition dhcpclient.c:38
fr_dict_unconst
fr_dict_t * fr_dict_unconst(fr_dict_t const *dict)
Coerce to non-const.
Definition dict_util.c:4880
fr_dict_autofree
#define fr_dict_autofree(_to_free)
Definition dict.h:915
fr_dict_attr_by_name
fr_dict_attr_t const * fr_dict_attr_by_name(fr_dict_attr_err_t *err, fr_dict_attr_t const *parent, char const *attr))
Locate a fr_dict_attr_t by its name.
Definition dict_util.c:3505
fr_dict_root
fr_dict_attr_t const * fr_dict_root(fr_dict_t const *dict)
Return the root attribute of a dictionary.
Definition dict_util.c:2639
fr_dict_attr_autoload_t::out
fr_dict_attr_t const ** out
Where to write a pointer to the resolved fr_dict_attr_t.
Definition dict.h:292
fr_dict_autoload_t::out
fr_dict_t const ** out
Where to write a pointer to the loaded/resolved fr_dict_t.
Definition dict.h:305
fr_dict_read
int fr_dict_read(fr_dict_t *dict, char const *dict_dir, char const *filename))
Read supplementary attribute definitions into an existing dictionary.
Definition dict_tokenize.c:3850
fr_dict_attr_autoload
int fr_dict_attr_autoload(fr_dict_attr_autoload_t const *to_load)
Process a dict_attr_autoload element to load/verify a dictionary attribute.
Definition dict_util.c:4372
fr_dict_autoload
#define fr_dict_autoload(_to_load)
Definition dict.h:912
DICT_AUTOLOAD_TERMINATOR
#define DICT_AUTOLOAD_TERMINATOR
Definition dict.h:311
fr_dict_global_ctx_init
fr_dict_gctx_t * fr_dict_global_ctx_init(TALLOC_CTX *ctx, bool free_at_exit, char const *dict_dir))
Initialise the global protocol hashes.
Definition dict_util.c:4690
fr_dict_attr_autoload_t
Specifies an attribute which must be present for the module to function.
Definition dict.h:291
fr_dict_autoload_t
Specifies a dictionary which must be loaded/loadable for the module to function.
Definition dict.h:304
fr_dlist_foreach
#define fr_dlist_foreach(_list_head, _type, _iter)
Iterate over the contents of a list.
Definition dlist.h:98
fr_dlist_num_elements
static unsigned int fr_dlist_num_elements(fr_dlist_head_t const *head)
Return the number of elements in the dlist.
Definition dlist.h:921
fr_dlist_insert_tail
static int fr_dlist_insert_tail(fr_dlist_head_t *list_head, void *ptr)
Insert an item into the tail of a list.
Definition dlist.h:360
FR_DLIST_HEAD
#define FR_DLIST_HEAD(_name)
Expands to the type name used for the head wrapper structure.
Definition dlist.h:1104
fr_dlist_talloc_init
#define fr_dlist_talloc_init(_head, _type, _field)
Initialise the head structure of a doubly linked list.
Definition dlist.h:257
fr_dlist_head_t
Head of a doubly linked list.
Definition dlist.h:51
my
void fr_bio_shutdown & my
Definition fd_errno.h:73
talloc_free
talloc_free(hp)
fr_inet_pton_port
int fr_inet_pton_port(fr_ipaddr_t *out, uint16_t *port_out, char const *value, ssize_t inlen, int af, bool resolve, bool mask)
Parses IPv4/6 address + port, to fr_ipaddr_t and integer (port)
Definition inet.c:944
fr_ipaddr_t::af
int af
Address family.
Definition inet.h:63
fr_ipaddr_t
IPv4/6 prefix.
Definition merged_model.c:266
packet_global_init
int packet_global_init(void)
Initialises the Net.
Definition packet.c:200
fr_packet_net_from_pairs
void fr_packet_net_from_pairs(fr_packet_t *packet, fr_pair_list_t const *list)
Convert pairs to information in a packet.
Definition packet.c:154
fr_time
#define fr_time()
Definition event.c:60
fr_debug_lvl
int fr_debug_lvl
Definition log.c:41
fr_log_fp
FILE * fr_log_fp
Definition log.c:40
default_log
fr_log_t default_log
Definition log.c:306
fr_log_perror
void fr_log_perror(fr_log_t const *log, fr_log_type_t type, char const *file, int line, fr_log_perror_format_t const *rules, char const *fmt,...)
Drain any outstanding messages from the fr_strerror buffers.
Definition log.c:742
L_DST_STDOUT
@ L_DST_STDOUT
Log to stdout.
Definition log.h:75
L_ERR
@ L_ERR
Error message.
Definition log.h:53
fr_packet_alloc
fr_packet_t * fr_packet_alloc(TALLOC_CTX *ctx, bool new_vector)
Allocate a new fr_packet_t.
Definition packet.c:38
fr_packet_free
void fr_packet_free(fr_packet_t **packet_p)
Free a fr_packet_t.
Definition packet.c:89
fr_packet_list_find_byreply
fr_packet_t * fr_packet_list_find_byreply(fr_packet_list_t *pl, fr_packet_t *reply)
Definition list.c:338
fr_packet_list_free
void fr_packet_list_free(fr_packet_list_t *pl)
Definition list.c:279
fr_packet_list_recv
int fr_packet_list_recv(fr_packet_list_t *pl, fd_set *set, TALLOC_CTX *ctx, fr_packet_t **packet_p, uint32_t max_attributes, bool require_message_authenticator)
Definition list.c:692
fr_packet_list_create
fr_packet_list_t * fr_packet_list_create(int alloc_id)
Definition list.c:291
fr_packet_list_id_alloc
bool fr_packet_list_id_alloc(fr_packet_list_t *pl, int proto, fr_packet_t *request, void **pctx)
Definition list.c:410
fr_packet_list_yank
bool fr_packet_list_yank(fr_packet_list_t *pl, fr_packet_t *request)
Definition list.c:376
fr_packet_list_socket_add
bool fr_packet_list_socket_add(fr_packet_list_t *pl, int sockfd, int proto, fr_ipaddr_t *dst_ipaddr, uint16_t dst_port, void *ctx)
Definition list.c:193
fr_packet_list_num_elements
uint32_t fr_packet_list_num_elements(fr_packet_list_t *pl)
Definition list.c:383
fr_packet_list_fd_set
int fr_packet_list_fd_set(fr_packet_list_t *pl, fd_set *set)
Definition list.c:665
fr_packet_list_id_free
bool fr_packet_list_id_free(fr_packet_list_t *pl, fr_packet_t *request, bool yank)
Definition list.c:641
fr_packet_list_s
Definition list.c:110
uint16_t
unsigned short uint16_t
Definition merged_model.c:31
FR_TYPE_STRING
@ FR_TYPE_STRING
String of printable characters.
Definition merged_model.c:83
FR_TYPE_UINT32
@ FR_TYPE_UINT32
32 Bit unsigned integer.
Definition merged_model.c:99
FR_TYPE_OCTETS
@ FR_TYPE_OCTETS
Raw octets.
Definition merged_model.c:84
uint32_t
unsigned int uint32_t
Definition merged_model.c:33
uint8_t
unsigned char uint8_t
Definition merged_model.c:30
fr_dict_attr_t
Definition merged_model.c:133
fr_dict_t
Definition merged_model.c:198
request_t
Definition merged_model.c:210
mschap_nt_password_hash
int mschap_nt_password_hash(uint8_t out[static NT_DIGEST_LENGTH], char const *password)
Converts Unicode password to 16-byte NT hash with MD4.
Definition mschap.c:52
fr_nbo_from_uint16
static void fr_nbo_from_uint16(uint8_t out[static sizeof(uint16_t)], uint16_t num)
Write out an unsigned 16bit integer in wire format (big endian)
Definition nbo.h:38
RADIUS_HEADER_LENGTH
#define RADIUS_HEADER_LENGTH
Definition net.h:80
RADIUS_AUTH_VECTOR_LENGTH
#define RADIUS_AUTH_VECTOR_LENGTH
Definition net.h:89
fr_pair_value_memdup
int fr_pair_value_memdup(fr_pair_t *vp, uint8_t const *src, size_t len, bool tainted)
Copy data into an "octets" data type.
Definition pair.c:2962
fr_pair_validate_debug
void fr_pair_validate_debug(fr_pair_t const *failed[2])
Write an error to the library errorbuff detailing the mismatch.
Definition pair.c:2096
fr_pair_find_by_da_nested
fr_pair_t * fr_pair_find_by_da_nested(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find a pair with a matching fr_dict_attr_t, by walking the nested fr_dict_attr_t tree.
Definition pair.c:784
fr_pair_find_by_da
fr_pair_t * fr_pair_find_by_da(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find the first pair with a matching da.
Definition pair.c:707
fr_pair_append
int fr_pair_append(fr_pair_list_t *list, fr_pair_t *to_add)
Add a VP to the end of the list.
Definition pair.c:1352
fr_pair_delete_by_da
int fr_pair_delete_by_da(fr_pair_list_t *list, fr_dict_attr_t const *da)
Delete matching pairs from the specified list.
Definition pair.c:1696
fr_pair_afrom_da
fr_pair_t * fr_pair_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Dynamically allocate a new attribute and assign a fr_dict_attr_t.
Definition pair.c:290
fr_pair_validate
bool fr_pair_validate(fr_pair_t const *failed[2], fr_pair_list_t *filter, fr_pair_list_t *list)
Uses fr_pair_cmp to verify all fr_pair_ts in list match the filter defined by check.
Definition pair.c:2131
fr_pair_list_init
void fr_pair_list_init(fr_pair_list_t *list)
Initialise a pair list header.
Definition pair.c:46
fr_pair_value_bstrndup
int fr_pair_value_bstrndup(fr_pair_t *vp, char const *src, size_t len, bool tainted)
Copy data into a "string" type value pair.
Definition pair.c:2812
fr_pair_delete
int fr_pair_delete(fr_pair_list_t *list, fr_pair_t *vp)
Remove fr_pair_t from a list and free.
Definition pair.c:1833
fr_pair_list_steal
void fr_pair_list_steal(TALLOC_CTX *ctx, fr_pair_list_t *list)
Steal a list of pairs to a new context.
Definition pair.c:2307
fr_pair_cmp_by_da
int8_t fr_pair_cmp_by_da(void const *a, void const *b)
Order attributes by their da, and tag.
Definition pair.c:1851
fr_pair_value_memdup_buffer_shallow
int fr_pair_value_memdup_buffer_shallow(fr_pair_t *vp, uint8_t const *src, bool tainted)
Assign a talloced buffer to a "octets" type value pair.
Definition pair.c:3037
fr_pair_list_afrom_file
int fr_pair_list_afrom_file(TALLOC_CTX *ctx, fr_dict_t const *dict, fr_pair_list_t *out, FILE *fp, bool *pfiledone, bool allow_exec)
Read valuepairs from the fp up to End-Of-File.
Definition pair_legacy.c:1270
fr_radius_global_init
int fr_radius_global_init(void)
Definition base.c:1313
fr_radius_decode_simple
ssize_t fr_radius_decode_simple(TALLOC_CTX *ctx, fr_pair_list_t *out, uint8_t *packet, size_t packet_len, uint8_t const *vector, char const *secret)
Simple wrapper for callers who just need a shared secret.
Definition base.c:1291
fr_radius_global_free
void fr_radius_global_free(void)
Definition base.c:1337
fr_radius_request_name_table
fr_table_num_sorted_t const fr_radius_request_name_table[]
Definition base.c:104
fr_radius_packet_name
char const * fr_radius_packet_name[FR_RADIUS_CODE_MAX]
Definition base.c:115
fr_radius_packet_sign
int fr_radius_packet_sign(fr_packet_t *packet, fr_packet_t const *original, char const *secret)
Sign a previously encoded packet.
Definition packet.c:150
fr_radius_packet_verify
int fr_radius_packet_verify(fr_packet_t *packet, fr_packet_t *original, char const *secret)
Verify the Request/Response Authenticator (and Message-Authenticator if present) of a packet.
Definition packet.c:129
fr_radius_packet_send
int fr_radius_packet_send(fr_packet_t *packet, fr_pair_list_t *list, fr_packet_t const *original, char const *secret)
Reply to the request.
Definition packet.c:277
fr_packet_recv
fr_packet_t * fr_packet_recv(TALLOC_CTX *ctx, int fd, int flags, uint32_t max_attributes, bool require_message_authenticator)
Receive UDP client requests, and fill in the basics of a fr_packet_t structure.
Definition packet.c:191
fr_radius_packet_log
void fr_radius_packet_log(fr_log_t const *log, fr_packet_t *packet, fr_pair_list_t *list, bool received)
Definition packet.c:478
fr_radius_packet_encode
ssize_t fr_radius_packet_encode(fr_packet_t *packet, fr_pair_list_t *list, fr_packet_t const *original, char const *secret)
Encode a packet.
Definition packet.c:43
fr_assert
#define fr_assert(_expr)
Definition rad_assert.h:37
REDEBUG
#define REDEBUG(fmt,...)
Definition radclient-ng.h:52
RDEBUG
#define RDEBUG(fmt,...)
Definition radclient-ng.h:53
rc_request_list_foreach
#define rc_request_list_foreach(_list_head, _iter)
Definition radclient-ng.h:109
WARN
#define WARN(fmt,...)
Definition radclient-ng.h:47
blast_radius_check
static int blast_radius_check(rc_request_t *request, fr_packet_t *reply)
Definition radclient.c:1353
coa_tree
static fr_rb_tree_t * coa_tree
Definition radclient.c:96
client_ipaddr
static fr_ipaddr_t client_ipaddr
Definition radclient.c:84
attr_packet_type
static fr_dict_attr_t const * attr_packet_type
Definition radclient.c:124
attr_request_authenticator
static fr_dict_attr_t const * attr_request_authenticator
Definition radclient.c:120
blast_radius
static bool blast_radius
Definition radclient.c:82
attr_user_password
static fr_dict_attr_t const * attr_user_password
Definition radclient.c:126
send_one_packet
static int send_one_packet(rc_request_t *request)
Definition radclient.c:960
getport
static int getport(char const *name)
Definition radclient.c:295
done
static bool done
Definition radclient.c:80
_rc_request_free
static int _rc_request_free(rc_request_t *request)
Definition radclient.c:194
client_port
static uint16_t client_port
Definition radclient.c:85
radclient_sane
static int radclient_sane(rc_request_t *request)
Definition radclient.c:891
recv_one_packet
static int recv_one_packet(fr_time_delta_t wait_time)
Definition radclient.c:1474
attr_coa_match_attr
static fr_dict_attr_t const * attr_coa_match_attr
Definition radclient.c:133
sleep_time
static fr_time_delta_t sleep_time
Definition radclient.c:67
coa_port
static uint16_t coa_port
Definition radclient.c:95
main
int main(int argc, char **argv)
Definition radclient.c:1686
attr_chap_password
static fr_dict_attr_t const * attr_chap_password
Definition radclient.c:122
ignore_count
static int ignore_count
Definition radclient.c:79
packet_list
static fr_packet_list_t * packet_list
Definition radclient.c:98
fixed_id
static int fixed_id
Definition radclient.c:89
resend_count
static int resend_count
Definition radclient.c:78
stats
static rc_stats_t stats
Definition radclient.c:73
attr_ms_chap_response
static fr_dict_attr_t const * attr_ms_chap_response
Definition radclient.c:117
attr_ms_chap_challenge
static fr_dict_attr_t const * attr_ms_chap_challenge
Definition radclient.c:115
last_used_id
static int last_used_id
Definition radclient.c:88
server_port
static uint16_t server_port
Definition radclient.c:75
packet_code
static int packet_code
Definition radclient.c:76
attr_chap_challenge
static fr_dict_attr_t const * attr_chap_challenge
Definition radclient.c:123
recv_coa_packet
static int recv_coa_packet(fr_time_delta_t wait_time)
Definition radclient.c:1191
do_output
static bool do_output
Definition radclient.c:69
server_ipaddr
static fr_ipaddr_t server_ipaddr
Definition radclient.c:77
openssl3_free
#define openssl3_free()
Definition radclient.c:256
ipproto
static int ipproto
Definition radclient.c:91
retries
static int retries
Definition radclient.c:65
attr_proxy_state
static fr_dict_attr_t const * attr_proxy_state
Definition radclient.c:127
attr_cleartext_password
static fr_dict_attr_t const * attr_cleartext_password
Definition radclient.c:113
deallocate_id
static void deallocate_id(rc_request_t *request)
Definition radclient.c:936
print_filename
static bool print_filename
Definition radclient.c:81
do_coa
static bool do_coa
Definition radclient.c:93
openssl3_init
#define openssl3_init()
Definition radclient.c:255
attr_radclient_test_name
static fr_dict_attr_t const * attr_radclient_test_name
Definition radclient.c:119
radclient_init
static int radclient_init(TALLOC_CTX *ctx, rc_file_pair_t *files)
Definition radclient.c:481
attr_radclient_coa_filename
static fr_dict_attr_t const * attr_radclient_coa_filename
Definition radclient.c:130
mschapv1_encode
static int mschapv1_encode(fr_packet_t *packet, fr_pair_list_t *list, char const *password)
Definition radclient.c:259
radclient_dict_attr
static const fr_dict_attr_autoload_t radclient_dict_attr[]
Definition radclient.c:135
already_hex
static bool already_hex(fr_pair_t *vp)
Definition radclient.c:362
attr_user_name
static fr_dict_attr_t const * attr_user_name
Definition radclient.c:125
secret
static char * secret
Definition radclient.c:68
coafd
static int coafd
Definition radclient.c:94
sockfd
static int sockfd
Definition radclient.c:87
radclient_get_port
static void radclient_get_port(fr_radius_packet_code_t type, uint16_t *port)
Definition radclient.c:308
attr_ms_chap_password
static fr_dict_attr_t const * attr_ms_chap_password
Definition radclient.c:116
pair_update_request
#define pair_update_request(_attr, _da)
Definition radclient.c:56
request_cmp
static int8_t request_cmp(void const *one, void const *two)
Definition radclient.c:918
attr_coa_filter_name
static const char * attr_coa_filter_name
Definition radclient.c:71
timeout
static fr_time_delta_t timeout
Definition radclient.c:66
attr_radclient_coa_filter
static fr_dict_attr_t const * attr_radclient_coa_filter
Definition radclient.c:131
usage
static NEVER_RETURNS void usage(void)
Definition radclient.c:158
radclient_get_code
static fr_radius_packet_code_t radclient_get_code(uint16_t port)
Definition radclient.c:341
attr_message_authenticator
static fr_dict_attr_t const * attr_message_authenticator
Definition radclient.c:128
coa_init
static int coa_init(rc_request_t *parent, FILE *coa_reply, char const *reply_filename, bool *coa_reply_done, FILE *coa_filter, char const *filter_filename, bool *coa_filter_done)
Read one CoA reply and potentially a filter.
Definition radclient.c:388
radclient.h
Structures for the radclient utility.
rc_stats_t::accepted
uint64_t accepted
Requests to which we received a accept.
Definition radclient-ng.h:57
rc_stats_t::rejected
uint64_t rejected
Requests to which we received a reject.
Definition radclient-ng.h:58
rc_stats_t::lost
uint64_t lost
Requests to which we received no response.
Definition radclient-ng.h:59
rc_stats_t::failed
uint64_t failed
Requests which failed a filter.
Definition radclient-ng.h:62
rc_file_pair_t::coa_filter
char const * coa_filter
file containing the CoA filter we want to match
Definition radclient-ng.h:70
rc_stats_t::passed
uint64_t passed
Requests which passed a filter.
Definition radclient-ng.h:61
rc_file_pair_t::filters
char const * filters
The file containing the definition of the packet we want to match.
Definition radclient-ng.h:68
rc_file_pair_t::coa_reply
char const * coa_reply
file containing the CoA reply we want to send
Definition radclient-ng.h:71
rc_file_pair_t::packets
char const * packets
The file containing the request packet.
Definition radclient-ng.h:67
rc_stats_t::error
uint64_t error
Requests which received a Protocol-Error response.
Definition radclient-ng.h:60
rc_file_pair_t
Definition radclient-ng.h:65
rc_stats_t
Definition radclient-ng.h:56
RADIUS_MAX_ATTRIBUTES
#define RADIUS_MAX_ATTRIBUTES
Definition radius.h:39
FR_RADIUS_PACKET_CODE_VALID
#define FR_RADIUS_PACKET_CODE_VALID(_x)
Definition radius.h:51
dict_radius
static fr_dict_t const * dict_radius
Definition radsniff.c:93
fr_rand
uint32_t fr_rand(void)
Return a 32-bit random number.
Definition rand.c:104
fr_rb_num_elements
uint32_t fr_rb_num_elements(fr_rb_tree_t *tree)
Return how many nodes there are in a tree.
Definition rb.c:781
fr_rb_remove
void * fr_rb_remove(fr_rb_tree_t *tree, void const *data)
Remove an entry from the tree, without freeing the data.
Definition rb.c:695
fr_rb_delete_by_inline_node
bool fr_rb_delete_by_inline_node(fr_rb_tree_t *tree, fr_rb_node_t *node)
Remove node and free data (if a free function was specified)
Definition rb.c:767
fr_rb_find
void * fr_rb_find(fr_rb_tree_t const *tree, void const *data)
Find an element in the tree, returning the data, not the node.
Definition rb.c:577
fr_rb_insert
bool fr_rb_insert(fr_rb_tree_t *tree, void const *data)
Insert data into a tree.
Definition rb.c:626
fr_rb_inline_talloc_alloc
#define fr_rb_inline_talloc_alloc(_ctx, _type, _field, _data_cmp, _data_free)
Allocs a red black that verifies elements are of a specific talloc type.
Definition rb.h:244
fr_rb_node_inline_in_tree
static bool fr_rb_node_inline_in_tree(fr_rb_node_t const *node)
Check to see if an item is in a tree by examining its inline fr_rb_node_t.
Definition rb.h:312
fr_rb_tree_s::being_freed
bool being_freed
Prevent double frees in talloc_destructor.
Definition rb.h:94
fr_rb_tree_s
The main red black tree structure.
Definition rb.h:71
request_s::reply
fr_packet_t * reply
Outgoing response.
Definition request.h:254
request_s::packet
char const *fr_packet_t * packet
< Module the request is currently being processed by.
Definition request.h:253
request_s
Definition request.h:193
name
static char const * name
Definition rlm_redis_ippool_tool.c:156
smbdes_mschap
void smbdes_mschap(uint8_t const win_password[16], uint8_t const *challenge, uint8_t *response)
Definition smbdes.c:339
fr_socket_server_udp
int fr_socket_server_udp(fr_ipaddr_t const *src_ipaddr, uint16_t *src_port, char const *port_name, bool async)
Open an IPv4/IPv6 unconnected UDP socket.
Definition socket.c:846
fr_socket_client_tcp
int fr_socket_client_tcp(char const *ifname, fr_ipaddr_t *src_ipaddr, fr_ipaddr_t const *dst_ipaddr, uint16_t dst_port, bool async)
Establish a connected TCP socket.
Definition socket.c:708
fr_socket_bind
int fr_socket_bind(int sockfd, char const *ifname, fr_ipaddr_t *src_ipaddr, uint16_t *src_port)
Bind a UDP/TCP v4/v6 socket to a given ipaddr src port, and interface.
Definition socket.c:200
type
fr_aka_sim_id_type_t type
Definition state_machine.c:3673
vp
fr_pair_t * vp
Definition state_machine.c:2287
fr_log_s::dst
fr_log_dst_t dst
Log destination.
Definition log.h:94
fr_log_s::fd
int fd
File descriptor to write messages to.
Definition log.h:109
fr_log_s::print_level
bool print_level
sometimes we don't want log levels printed
Definition log.h:103
pair_list_s
Definition pair.h:52
rc_request
Definition radclient-ng.h:77
rc_request::num
uint64_t num
The number (within the file) of the request were reading.
Definition radclient-ng.h:80
rc_request::reply
fr_packet_t * reply
The incoming response.
Definition radclient-ng.h:91
rc_request::password
fr_pair_t * password
Password.Cleartext.
Definition radclient-ng.h:87
rc_request::name
char const * name
Test name (as specified in the request).
Definition radclient-ng.h:104
rc_request::files
rc_file_pair_t * files
Request and response file names.
Definition radclient-ng.h:82
rc_request::coa
rc_request_t * coa
CoA filter and reply.
Definition radclient-ng.h:84
rc_request::packet
fr_packet_t * packet
The outgoing request.
Definition radclient-ng.h:90
rc_request::request_pairs
fr_pair_list_t request_pairs
Definition radclient-ng.h:93
rc_request::node
fr_rb_node_t node
rbtree node data for CoA
Definition radclient-ng.h:85
rc_request::done
bool done
Whether the request is complete.
Definition radclient-ng.h:102
rc_request::filter
fr_pair_list_t filter
If the reply passes the filter, then the request passes.
Definition radclient-ng.h:96
rc_request::reply_pairs
fr_pair_list_t reply_pairs
Definition radclient-ng.h:94
rc_request::filter_code
fr_radius_packet_code_t filter_code
Expected code of the response packet.
Definition radclient-ng.h:97
rc_request::timestamp
fr_time_t timestamp
Definition radclient-ng.h:88
rc_request::tries
int tries
Definition radclient-ng.h:100
rc_request::resend
int resend
Definition radclient-ng.h:99
value_pair_s
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
value_pair_s::da
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
fr_syserror
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
fr_table_value_by_str
#define fr_table_value_by_str(_table, _name, _def)
Convert a string to a value using a sorted or ordered table.
Definition table.h:685
talloc_strndup
#define talloc_strndup(_ctx, _str, _len)
Definition talloc.h:150
talloc_autofree_context
#define talloc_autofree_context
The original function is deprecated, so replace it with our version.
Definition talloc.h:55
talloc_strdup
#define talloc_strdup(_ctx, _str)
Definition talloc.h:149
fr_time_delta_from_str
fr_slen_t fr_time_delta_from_str(fr_time_delta_t *out, char const *in, size_t inlen, fr_time_res_t hint)
Create fr_time_delta_t from a string.
Definition time.c:412
fr_time_delta_lt
#define fr_time_delta_lt(_a, _b)
Definition time.h:285
fr_time_delta_from_sec
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:590
fr_time_delta_wrap
#define fr_time_delta_wrap(_time)
Definition time.h:152
fr_time_delta_ispos
#define fr_time_delta_ispos(_a)
Definition time.h:290
fr_time_delta_to_timeval
#define fr_time_delta_to_timeval(_delta)
Convert a delta to a timeval.
Definition time.h:656
fr_time_delta_eq
#define fr_time_delta_eq(_a, _b)
Definition time.h:287
FR_TIME_RES_SEC
@ FR_TIME_RES_SEC
Definition time.h:50
NSEC
#define NSEC
Definition time.h:379
fr_time_delta_sub
static fr_time_delta_t fr_time_delta_sub(fr_time_delta_t a, fr_time_delta_t b)
Definition time.h:261
fr_time_sub
#define fr_time_sub(_a, _b)
Subtract one time from another.
Definition time.h:229
fr_time_delta_gt
#define fr_time_delta_gt(_a, _b)
Definition time.h:283
fr_time_delta_s
A time delta, a difference in time measured in nanoseconds.
Definition time.h:80
fr_time_s
"server local" time.
Definition time.h:69
T_OP_CMP_FALSE
@ T_OP_CMP_FALSE
Definition token.h:103
FR_DICTIONARY_FILE
#define FR_DICTIONARY_FILE
Definition conf.h:7
fr_packet_t::uctx
void * uctx
Definition packet.h:79
fr_packet_t::code
unsigned int code
Packet code (type).
Definition packet.h:61
fr_packet_t::socket
fr_socket_t socket
This packet was received on.
Definition packet.h:57
fr_packet_t::id
int id
Packet ID (used to link requests/responses).
Definition packet.h:60
fr_packet_t::data
uint8_t * data
Packet data (body).
Definition packet.h:63
fr_packet_t::data_len
size_t data_len
Length of packet data.
Definition packet.h:64
fr_packet_t::vector
uint8_t vector[RADIUS_AUTH_VECTOR_LENGTH]
RADIUS authentication vector.
Definition packet.h:69
fr_packet_t
Definition packet.h:56
fr_pair_list_empty
bool fr_pair_list_empty(fr_pair_list_t const *list)
Is a valuepair list empty.
Definition pair_inline.c:124
fr_pair_list_sort
void fr_pair_list_sort(fr_pair_list_t *list, fr_cmp_t cmp)
Sort a doubly linked list of fr_pair_ts using merge sort.
Definition pair_inline.c:139
fr_pair_list_next
fr_pair_t * fr_pair_list_next(fr_pair_list_t const *list, fr_pair_t const *item))
Get the next item in a valuepair list after a specific entry.
Definition pair_inline.c:69
fr_pair_list_append
void fr_pair_list_append(fr_pair_list_t *dst, fr_pair_list_t *src)
Appends a list of fr_pair_t from a temporary list to a destination list.
Definition pair_inline.c:181
PAIR_LIST_VERIFY
#define PAIR_LIST_VERIFY(_x)
Definition pair.h:207
fr_pair_list_head
fr_pair_t * fr_pair_list_head(fr_pair_list_t const *list)
Get the head of a valuepair list.
Definition pair_inline.c:42
parent
static fr_slen_t parent
Definition pair.h:858
fr_socket_t::af
int af
AF_INET, AF_INET6, or AF_UNIX.
Definition socket.h:75
fr_socket_t::fd
int fd
File descriptor if this is a live socket.
Definition socket.h:78
fr_socket_t::type
int type
SOCK_STREAM, SOCK_DGRAM, etc.
Definition socket.h:76
fr_perror
void fr_perror(char const *fmt,...)
Print the current error to stderr with a prefix.
Definition strerror.c:737
fr_strerror_clear
void fr_strerror_clear(void)
Clears all pending messages from the talloc pools.
Definition strerror.c:581
fr_check_lib_magic
int fr_check_lib_magic(uint64_t magic)
Check if the application linking to the library has the correct magic number.
Definition version.c:40
RADIUSD_VERSION_BUILD
#define RADIUSD_VERSION_BUILD(_x)
Create a version string for a utility in the suite of FreeRADIUS utilities.
Definition version.h:58
RADIUSD_MAGIC_NUMBER
#define RADIUSD_MAGIC_NUMBER
Definition version.h:81
fr_value_box_cmp
int8_t fr_value_box_cmp(fr_value_box_t const *a, fr_value_box_t const *b)
Compare two values.
Definition value.c:748
Generated by   doxygen 1.9.8