/
auth.c
1976 lines (1698 loc) · 55 KB
1
2
3
/*
* OpenConnect (SSL + DTLS) VPN client
*
4
* Copyright © 2008-2015 Intel Corporation.
5
* Copyright © 2013 John Morrissey <jwm@horde.net>
6
7
8
9
10
11
12
13
14
15
16
17
18
*
* Author: David Woodhouse <dwmw2@infradead.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
19
20
#include <config.h>
21
22
#include "openconnect-internal.h"
23
24
#include <unistd.h>
#include <fcntl.h>
25
26
27
#include <sys/stat.h>
#include <sys/types.h>
#ifndef _WIN32
28
#include <sys/wait.h>
29
#include <pwd.h>
30
#include <grp.h>
31
#endif
32
33
34
35
36
37
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
38
39
40
41
42
43
44
enum {
CERT1_REQUESTED = (1<<0),
CERT1_AUTHENTICATED = (1<<1),
CERT2_REQUESTED = (1<<2),
};
45
struct cert_request {
46
47
48
49
unsigned int state:16;
unsigned int hashes:16;
};
50
static int xmlpost_append_form_opts(struct openconnect_info *vpninfo,
51
struct oc_auth_form *form, struct oc_text_buf *body);
52
53
54
static int cstp_can_gen_tokencode(struct openconnect_info *vpninfo,
struct oc_auth_form *form,
struct oc_form_opt *opt);
55
56
57
58
59
60
61
62
/* multiple certificate-based authentication */
static void parse_multicert_request(struct openconnect_info *vpninfo,
xmlNodePtr node, struct cert_request *cert_rq);
static int prepare_multicert_response(struct openconnect_info *vpninfo,
struct cert_request cert_rq, const char *challenge,
struct oc_text_buf *body);
63
64
65
66
67
68
69
int openconnect_set_option_value(struct oc_form_opt *opt, const char *value)
{
if (opt->type == OC_FORM_OPT_SELECT) {
struct oc_form_opt_select *sopt = (void *)opt;
int i;
for (i=0; i<sopt->nr_choices; i++) {
70
if (!strcmp(value, sopt->choices[i]->name)) {
71
opt->_value = sopt->choices[i]->name;
72
73
74
75
76
77
return 0;
}
}
return -EINVAL;
}
78
79
opt->_value = strdup(value);
if (!opt->_value)
80
81
82
83
84
return -ENOMEM;
return 0;
}
85
86
87
88
89
90
91
92
93
94
95
static int prop_equals(xmlNode *xml_node, const char *name, const char *value)
{
char *tmp = (char *)xmlGetProp(xml_node, (unsigned char *)name);
int ret = 0;
if (tmp && !strcasecmp(tmp, value))
ret = 1;
free(tmp);
return ret;
}
96
static int parse_auth_choice(struct openconnect_info *vpninfo, struct oc_auth_form *form,
97
xmlNode *xml_node)
98
{
99
struct oc_form_opt_select *opt;
100
xmlNode *opt_node;
101
int max_choices = 0, selection = 0;
102
103
104
105
106
107
for (opt_node = xml_node->children; opt_node; opt_node = opt_node->next)
max_choices++;
/* Return early when there is a <select/> tag with no children */
if (max_choices == 0) {
108
return 0;
109
110
}
111
112
113
114
opt = calloc(1, sizeof(*opt));
if (!opt)
return -ENOMEM;
115
opt->form.type = OC_FORM_OPT_SELECT;
116
117
opt->form.name = (char *)xmlGetProp(xml_node, (unsigned char *)"name");
opt->form.label = (char *)xmlGetProp(xml_node, (unsigned char *)"label");
118
119
if (!opt->form.name) {
120
vpn_progress(vpninfo, PRG_ERR, _("Form choice has no name\n"));
121
free_opt((struct oc_form_opt *)opt);
122
123
124
return -EINVAL;
}
125
126
127
128
129
130
131
opt->choices = calloc(1, max_choices * sizeof(struct oc_choice *));
if (!opt->choices) {
free_opt((struct oc_form_opt *)opt);
return -ENOMEM;
}
132
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
133
char *form_id;
134
struct oc_choice *choice;
135
136
137
138
139
140
141
142
if (xml_node->type != XML_ELEMENT_NODE)
continue;
if (strcmp((char *)xml_node->name, "option"))
continue;
form_id = (char *)xmlGetProp(xml_node, (unsigned char *)"value");
143
144
if (!form_id)
form_id = (char *)xmlNodeGetContent(xml_node);
145
146
147
if (!form_id)
continue;
148
149
150
choice = calloc(1, sizeof(*choice));
if (!choice) {
free_opt((struct oc_form_opt *)opt);
151
return -ENOMEM;
152
}
153
154
155
156
157
158
choice->name = form_id;
choice->label = (char *)xmlNodeGetContent(xml_node);
choice->auth_type = (char *)xmlGetProp(xml_node, (unsigned char *)"auth-type");
choice->override_name = (char *)xmlGetProp(xml_node, (unsigned char *)"override-name");
choice->override_label = (char *)xmlGetProp(xml_node, (unsigned char *)"override-label");
159
160
161
162
163
164
165
166
choice->second_auth = prop_equals(xml_node, "second-auth", "1");
choice->secondary_username = (char *)xmlGetProp(xml_node,
(unsigned char *)"secondary_username");
choice->secondary_username_editable = prop_equals(xml_node,
"secondary_username_editable", "true");
choice->noaaa = prop_equals(xml_node, "noaaa", "1");
167
168
169
if (prop_equals(xml_node, "selected", "true"))
selection = opt->nr_choices;
170
opt->choices[opt->nr_choices++] = choice;
171
}
172
173
174
if (!strcmp(opt->form.name, "group_list")) {
form->authgroup_opt = opt;
175
form->authgroup_selection = selection;
176
177
}
178
179
180
181
/* We link the choice _first_ so it's at the top of what we present
to the user */
opt->form.next = form->opts;
form->opts = &opt->form;
182
183
184
return 0;
}
185
static int parse_form(struct openconnect_info *vpninfo, struct oc_auth_form *form,
186
xmlNode *xml_node)
187
{
188
char *input_type, *input_name, *input_label;
189
190
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
191
struct oc_form_opt *opt, **p;
192
193
194
195
196
if (xml_node->type != XML_ELEMENT_NODE)
continue;
if (!strcmp((char *)xml_node->name, "select")) {
197
if (parse_auth_choice(vpninfo, form, xml_node))
198
199
200
201
return -EINVAL;
continue;
}
if (strcmp((char *)xml_node->name, "input")) {
202
vpn_progress(vpninfo, PRG_DEBUG,
203
_("name %s not input\n"), xml_node->name);
204
205
206
207
208
continue;
}
input_type = (char *)xmlGetProp(xml_node, (unsigned char *)"type");
if (!input_type) {
209
210
vpn_progress(vpninfo, PRG_INFO,
_("No input type in form\n"));
211
212
213
continue;
}
214
215
if (!strcmp(input_type, "submit") || !strcmp(input_type, "reset")) {
free(input_type);
216
continue;
217
}
218
219
220
input_name = (char *)xmlGetProp(xml_node, (unsigned char *)"name");
if (!input_name) {
221
222
vpn_progress(vpninfo, PRG_INFO,
_("No input name in form\n"));
223
free(input_type);
224
225
226
continue;
}
input_label = (char *)xmlGetProp(xml_node, (unsigned char *)"label");
227
228
if (!input_label && asprintf(&input_label, "%s:", input_name) == -1)
goto nomem;
229
230
opt = calloc(1, sizeof(*opt));
231
if (!opt) {
232
nomem:
233
234
235
free(input_type);
free(input_name);
free(input_label);
236
return -ENOMEM;
237
}
238
239
240
opt->name = input_name;
opt->label = input_label;
241
opt->flags = prop_equals(xml_node, "second-auth", "1") ? OC_FORM_OPT_SECOND_AUTH : 0;
242
243
if (!strcmp(input_type, "hidden")) {
244
opt->type = OC_FORM_OPT_HIDDEN;
245
opt->_value = (char *)xmlGetProp(xml_node, (unsigned char *)"value");
246
} else if (!strcmp(input_type, "text")) {
247
opt->type = OC_FORM_OPT_TEXT;
248
} else if (!strcmp(input_type, "sso")) {
249
opt->type = OC_FORM_OPT_SSO_TOKEN;
250
} else if (!strcmp(input_type, "password")) {
251
if (!cstp_can_gen_tokencode(vpninfo, form, opt))
252
opt->type = OC_FORM_OPT_TOKEN;
253
else
254
255
opt->type = OC_FORM_OPT_PASSWORD;
} else {
256
vpn_progress(vpninfo, PRG_INFO,
257
258
_("Unknown input type %s in form\n"),
input_type);
259
260
261
free(input_type);
free(input_name);
free(input_label);
262
263
free(opt);
continue;
264
}
265
266
free(input_type);
267
268
269
270
271
272
p = &form->opts;
while (*p)
p = &(*p)->next;
*p = opt;
273
274
}
275
276
277
return 0;
}
278
static char *xmlnode_msg(xmlNode *xml_node)
279
{
280
char *fmt = (char *)xmlNodeGetContent(xml_node);
281
282
char *result, *params[2], *pct;
int len;
283
int nr_params = 0;
284
285
286
if (!fmt || !fmt[0]) {
free(fmt);
287
return NULL;
288
}
289
290
len = strlen(fmt) + 1;
291
292
293
294
295
296
297
298
299
300
301
302
params[0] = (char *)xmlGetProp(xml_node, (unsigned char *)"param1");
if (params[0])
len += strlen(params[0]);
params[1] = (char *)xmlGetProp(xml_node, (unsigned char *)"param2");
if (params[1])
len += strlen(params[1]);
result = malloc(len);
if (!result) {
result = fmt;
goto out;
303
304
}
305
strcpy(result, fmt);
306
free(fmt);
307
308
309
310
for (pct = strchr(result, '%'); pct;
(pct = strchr(pct, '%'))) {
int paramlen;
311
312
313
314
315
316
317
318
/* We only cope with '%s' */
if (pct[1] != 's')
goto out;
if (params[nr_params]) {
paramlen = strlen(params[nr_params]);
/* Move rest of fmt string up... */
319
memmove(pct + paramlen, pct + 2, strlen(pct + 2) + 1);
320
321
322
323
324
325
326
327
328
329
330
331
/* ... and put the string parameter in where the '%s' was */
memcpy(pct, params[nr_params], paramlen);
pct += paramlen;
} else
pct++;
if (++nr_params == 2)
break;
}
out:
free(params[0]);
free(params[1]);
332
return result;
333
334
}
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
static int xmlnode_get_text(xmlNode *xml_node, const char *name, char **var)
{
char *str;
if (name && !xmlnode_is_named(xml_node, name))
return -EINVAL;
str = xmlnode_msg(xml_node);
if (!str)
return -ENOENT;
free(*var);
*var = str;
return 0;
}
351
352
353
354
355
/*
* Legacy server response looks like:
*
* <auth id="<!-- "main" for initial attempt, "success" means we have a cookie -->">
* <title><!-- title to display to user --></title>
356
357
* <csd
* token="<!-- save to vpninfo->csd_token -->"
358
* ticket="<!-- save to vpninfo->csd_ticket -->" />
359
360
361
362
* <csd
* stuburl="<!-- save to vpninfo->csd_stuburl if --os=win -->"
* starturl="<!-- save to vpninfo->csd_starturl if --os=win -->"
* waiturl="<!-- save to vpninfo->csd_starturl if --os=win -->"
363
* <csdMac
364
365
366
* stuburl="<!-- save to vpninfo->csd_stuburl if --os=mac-intel -->"
* starturl="<!-- save to vpninfo->csd_starturl if --os=mac-intel -->"
* waiturl="<!-- save to vpninfo->csd_waiturl if --os=mac-intel -->" />
367
* <csdLinux
368
369
370
* stuburl="<!-- same as above, for Linux -->"
* starturl="<!-- same as above, for Linux -->"
* waiturl="<!-- same as above, for Linux -->" />
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
* <banner><!-- display this to the user --></banner>
* <message>Please enter your username and password.</message>
* <form method="post" action="/+webvpn+/index.html">
* <input type="text" name="username" label="Username:" />
* <input type="password" name="password" label="Password:" />
* <input type="hidden" name="<!-- save these -->" value="<!-- ... -->" />
* <input type="submit" name="Login" value="Login" />
* <input type="reset" name="Clear" value="Clear" />
* </form>
* </auth>
*
* New server response looks like:
*
* <config-auth>
* <version><!-- whatever --></version>
* <session-token><!-- if present, save to vpninfo->cookie --></session-token>
* <opaque>
* <!-- this could contain anything; copy to vpninfo->opaque_srvdata -->
* <tunnel-group>foobar</tunnel-group>
* <config-hash>1234567</config-hash>
* </opaque>
* <auth id="<!-- see above -->
* <!-- all of our old familiar fields -->
* </auth>
* <host-scan>
* <host-scan-ticket><!-- save to vpninfo->csd_ticket --></host-scan-ticket>
* <host-scan-token><!-- save to vpninfo->csd_token --></host-scan-token>
* <host-scan-base-uri><!-- save to vpninfo->csd_starturl --></host-scan-base-uri>
* <host-scan-wait-uri><!-- save to vpninfo->csd_waiturl --></host-scan-wait-uri>
* </host-scan>
* </config-auth>
*
* Notes:
*
* 1) The new host-scan-*-uri nodes do not map directly to the old CSD fields.
*
* 2) The new <form> tag tends to omit the method/action properties.
*/
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
/* Translate platform names (derived from AnyConnect) into the relevant
* CSD tag names
*/
static inline const char *csd_tag_name(struct openconnect_info *vpninfo)
{
if (!strcmp(vpninfo->platname, "mac-intel"))
return "csdMac";
else if (!strcmp(vpninfo->platname, "win"))
return "csd";
else
/* linux, linux-64, android, apple-ios */
return "csdLinux";
}
/* Ignore stubs on mobile platforms */
static inline int csd_use_stub(struct openconnect_info *vpninfo)
{
if (!strcmp(vpninfo->platname, "android") || !strcmp(vpninfo->platname, "apple-ios"))
return 0;
else
return 1;
}
433
434
435
436
437
438
439
440
441
static int parse_auth_node(struct openconnect_info *vpninfo, xmlNode *xml_node,
struct oc_auth_form *form)
{
int ret = 0;
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
if (xml_node->type != XML_ELEMENT_NODE)
continue;
442
443
444
xmlnode_get_text(xml_node, "banner", &form->banner);
xmlnode_get_text(xml_node, "message", &form->message);
xmlnode_get_text(xml_node, "error", &form->error);
445
446
447
448
xmlnode_get_text(xml_node, "sso-v2-login", &vpninfo->sso_login);
xmlnode_get_text(xml_node, "sso-v2-login-final", &vpninfo->sso_login_final);
xmlnode_get_text(xml_node, "sso-v2-token-cookie-name", &vpninfo->sso_token_cookie);
xmlnode_get_text(xml_node, "sso-v2-error-cookie-name", &vpninfo->sso_error_cookie);
449
xmlnode_get_text(xml_node, "sso-v2-browser-mode", &vpninfo->sso_browser_mode);
450
451
452
if (xmlnode_is_named(xml_node, "form")) {
453
454
455
456
/* defaults for new XML POST */
form->method = strdup("POST");
form->action = strdup("/");
457
458
459
xmlnode_get_prop(xml_node, "method", &form->method);
xmlnode_get_prop(xml_node, "action", &form->action);
460
461
462
463
464
465
466
467
468
469
470
471
if (!form->method || !form->action ||
strcasecmp(form->method, "POST") || !form->action[0]) {
vpn_progress(vpninfo, PRG_ERR,
_("Cannot handle form method='%s', action='%s'\n"),
form->method, form->action);
ret = -EINVAL;
goto out;
}
ret = parse_form(vpninfo, form, xml_node);
if (ret < 0)
goto out;
472
473
474
} else if (!vpninfo->csd_scriptname && xmlnode_is_named(xml_node, "csd")) {
xmlnode_get_prop(xml_node, "token", &vpninfo->csd_token);
xmlnode_get_prop(xml_node, "ticket", &vpninfo->csd_ticket);
475
476
477
478
479
480
} else if (xmlnode_is_named(xml_node, "authentication-complete")) {
/* Ick. Since struct oc_auth_form is public there's no
* simple way to add a flag to it. So let's abuse the
* auth_id string instead. */
free(form->auth_id);
form->auth_id = strdup("openconnect_authentication_complete");
481
482
483
484
485
}
/* For Windows, vpninfo->csd_xmltag will be "csd" and there are *two* <csd>
nodes; one with token/ticket and one with the URLs. Process them both
the same and rely on the fact that xmlnode_get_prop() will not *clear*
the variable if no such property is found. */
486
if (!vpninfo->csd_scriptname && xmlnode_is_named(xml_node, csd_tag_name(vpninfo))) {
487
/* ignore the CSD trojan binary on mobile platforms */
488
if (csd_use_stub(vpninfo))
489
xmlnode_get_prop(xml_node, "stuburl", &vpninfo->csd_stuburl);
490
491
xmlnode_get_prop(xml_node, "starturl", &vpninfo->csd_starturl);
xmlnode_get_prop(xml_node, "waiturl", &vpninfo->csd_waiturl);
492
493
494
495
496
497
498
499
vpninfo->csd_preurl = strdup(vpninfo->urlpath);
}
}
out:
return ret;
}
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
static int parse_host_scan_node(struct openconnect_info *vpninfo, xmlNode *xml_node)
{
/* ignore this whole section if the CSD trojan has already run */
if (vpninfo->csd_scriptname)
return 0;
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
if (xml_node->type != XML_ELEMENT_NODE)
continue;
xmlnode_get_text(xml_node, "host-scan-ticket", &vpninfo->csd_ticket);
xmlnode_get_text(xml_node, "host-scan-token", &vpninfo->csd_token);
xmlnode_get_text(xml_node, "host-scan-base-uri", &vpninfo->csd_starturl);
xmlnode_get_text(xml_node, "host-scan-wait-uri", &vpninfo->csd_waiturl);
}
return 0;
}
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
static void parse_profile_node(struct openconnect_info *vpninfo, xmlNode *xml_node)
{
/* ignore this whole section if we already have a URL */
if (vpninfo->profile_url && vpninfo->profile_sha1)
return;
/* Find <vpn rev="1.0"> child... */
xml_node = xml_node->children;
while (1) {
if (!xml_node)
return;
if (xml_node->type == XML_ELEMENT_NODE &&
xmlnode_is_named(xml_node, "vpn") &&
!xmlnode_match_prop(xml_node, "rev", "1.0"))
break;
xml_node = xml_node->next;
}
/* Find <file type="profile" service-type="user"> */
xml_node = xml_node->children;
while (1) {
if (!xml_node)
return;
if (xml_node->type == XML_ELEMENT_NODE &&
xmlnode_is_named(xml_node, "file") &&
!xmlnode_match_prop(xml_node, "type", "profile") &&
!xmlnode_match_prop(xml_node, "service-type", "user"))
break;
xml_node = xml_node->next;
}
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
if (xml_node->type != XML_ELEMENT_NODE)
continue;
xmlnode_get_text(xml_node, "uri", &vpninfo->profile_url);
/* FIXME: Check for <hash type="sha1"> */
xmlnode_get_text(xml_node, "hash", &vpninfo->profile_sha1);
}
}
static void parse_config_node(struct openconnect_info *vpninfo, xmlNode *xml_node)
{
for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
if (xml_node->type != XML_ELEMENT_NODE)
continue;
if (xmlnode_is_named(xml_node, "vpn-profile-manifest"))
parse_profile_node(vpninfo, xml_node);
}
}
574
575
/* Return value:
* < 0, on error
576
* = 0, on success; *form is populated
577
*/
578
579
580
static int parse_xml_response(struct openconnect_info *vpninfo,
char *response,struct oc_auth_form **formp,
struct cert_request *cert_rq)
581
{
582
struct oc_auth_form *form;
583
584
xmlDocPtr xml_doc;
xmlNode *xml_node;
585
int old_cert_rq_state = 0;
586
int ret;
587
588
589
590
591
if (*formp) {
free_auth_form(*formp);
*formp = NULL;
}
592
593
594
595
if (cert_rq) {
old_cert_rq_state = cert_rq->state;
*cert_rq = (struct cert_request) { 0 };
}
596
597
if (!response) {
598
vpn_progress(vpninfo, PRG_DEBUG,
599
600
601
602
_("Empty response from server\n"));
return -EINVAL;
}
603
604
605
form = calloc(1, sizeof(*form));
if (!form)
return -ENOMEM;
606
xml_doc = xmlReadMemory(response, strlen(response), NULL, NULL,
607
XML_PARSE_NOERROR|XML_PARSE_RECOVER);
608
if (!xml_doc) {
609
610
vpn_progress(vpninfo, PRG_ERR,
_("Failed to parse server response\n"));
611
vpn_progress(vpninfo, PRG_DEBUG,
612
_("Response was:%s\n"), response);
613
614
615
free(form);
return -EINVAL;
}
616
617
xml_node = xmlDocGetRootElement(xml_doc);
618
while (xml_node) {
619
ret = 0;
620
621
622
623
624
625
626
627
628
if (xml_node->type != XML_ELEMENT_NODE) {
xml_node = xml_node->next;
continue;
}
if (xmlnode_is_named(xml_node, "config-auth")) {
/* if we do have a config-auth node, it is the root element */
xml_node = xml_node->children;
continue;
629
630
} else if (xmlnode_is_named(xml_node, "client-cert-request")) {
if (cert_rq)
631
cert_rq->state |= CERT1_REQUESTED;
632
633
else {
vpn_progress(vpninfo, PRG_ERR,
634
_("Received <client-cert-request> when not expected.\n"));
635
636
ret = -EINVAL;
}
637
638
639
640
641
642
643
644
645
646
647
648
} else if (xmlnode_is_named(xml_node, "multiple-client-cert-request")) {
if (cert_rq) {
cert_rq->state |= CERT1_REQUESTED|CERT2_REQUESTED;
parse_multicert_request(vpninfo, xml_node, cert_rq);
} else {
vpn_progress(vpninfo, PRG_ERR,
_("Received <multiple-client-cert-request> when not expected.\n"));
ret = -EINVAL;
}
} else if (xmlnode_is_named(xml_node, "cert-authenticated")) {
/**
* cert-authenticated indicates that the certificate for the
649
* TLS session is valid.
650
651
652
*/
if (cert_rq)
cert_rq->state |= CERT1_AUTHENTICATED;
653
654
655
656
657
658
659
660
661
662
663
} else if (xmlnode_is_named(xml_node, "auth")) {
xmlnode_get_prop(xml_node, "id", &form->auth_id);
ret = parse_auth_node(vpninfo, xml_node, form);
} else if (xmlnode_is_named(xml_node, "opaque")) {
if (vpninfo->opaque_srvdata)
xmlFreeNode(vpninfo->opaque_srvdata);
vpninfo->opaque_srvdata = xmlCopyNode(xml_node, 1);
if (!vpninfo->opaque_srvdata)
ret = -ENOMEM;
} else if (xmlnode_is_named(xml_node, "host-scan")) {
ret = parse_host_scan_node(vpninfo, xml_node);
664
665
} else if (xmlnode_is_named(xml_node, "config")) {
parse_config_node(vpninfo, xml_node);
666
667
668
} else if (xmlnode_is_named(xml_node, "session-token")) {
http_add_cookie(vpninfo, "webvpn",
(const char *)xmlNodeGetContent(xml_node), 1);
669
670
671
672
673
674
675
676
677
} else {
xmlnode_get_text(xml_node, "error", &form->error);
}
if (ret)
goto out;
xml_node = xml_node->next;
}
678
if ((old_cert_rq_state & CERT2_REQUESTED) && form->error) {
679
680
681
682
683
684
685
vpn_progress(vpninfo, PRG_ERR,
_("Server reported certificate error: %s.\n"), form->error);
ret = -EINVAL;
goto out;
}
if (!form->auth_id && (!cert_rq || !cert_rq->state)) {
686
vpn_progress(vpninfo, PRG_ERR,
687
_("XML response has no \"auth\" node\n"));
688
ret = -EINVAL;
689
690
goto out;
}
691
692
693
694
*formp = form;
xmlFreeDoc(xml_doc);
return 0;
695
696
697
698
out:
xmlFreeDoc(xml_doc);
free_auth_form(form);
699
return ret;
700
701
702
703
}
/* Return value:
* < 0, on error
704
705
706
* = OC_FORM_RESULT_OK (0), when form parsed and POST required
* = OC_FORM_RESULT_CANCELLED, when response was cancelled by user
* = OC_FORM_RESULT_LOGGEDIN, when form indicates that login was already successful
707
*/
708
709
710
static int handle_auth_form(struct openconnect_info *vpninfo, struct oc_auth_form *form,
struct oc_text_buf *request_body, const char **method,
const char **request_body_type)
711
712
{
int ret;
713
struct oc_vpn_option *opt, *next;
714
715
if (!strcmp(form->auth_id, "success"))
716
return OC_FORM_RESULT_LOGGEDIN;
717
718
if (vpninfo->nopasswd) {
719
720
vpn_progress(vpninfo, PRG_ERR,
_("Asked for password but '--no-passwd' set\n"));
721
return -EPERM;
722
723
}
724
if (vpninfo->csd_token && vpninfo->csd_ticket && vpninfo->csd_starturl && vpninfo->csd_waiturl) {
725
726
727
728
729
730
731
732
733
/* AB: remove all cookies */
for (opt = vpninfo->cookies; opt; opt = next) {
next = opt->next;
free(opt->option);
free(opt->value);
free(opt);
}
vpninfo->cookies = NULL;
734
return OC_FORM_RESULT_OK;
735
}
736
if (!form->opts) {
737
if (form->message)
738
vpn_progress(vpninfo, PRG_INFO, "%s\n", form->message);
739
740
741
742
743
744
745
746
if (form->error) {
if (!strcmp(form->error, "Certificate Validation Failure")) {
/* XX: Cisco servers send this ambiguous error string when the CLIENT certificate
* is absent or incorrect. We rewrite it to make this clearer, while preserving
* the original error as a substring.
*/
free(form->error);
if (!(form->error = strdup(_("Client certificate missing or incorrect (Certificate Validation Failure)"))))
747
return -ENOMEM;
748
749
750
} else
vpn_progress(vpninfo, PRG_ERR, "%s\n", form->error);
}
751
752
if (!strcmp(form->auth_id, "openconnect_authentication_complete"))
goto justpost;
753
return -EPERM;
754
755
}
756
ret = process_auth_form(vpninfo, form);
757
if (ret)
758
return ret;
759
760
761
/* tokencode generation is deferred until after username prompts and CSD */
ret = do_gen_tokencode(vpninfo, form);
762
763
764
if (ret) {
vpn_progress(vpninfo, PRG_ERR, _("Failed to generate OTP tokencode; disabling token\n"));
vpninfo->token_bypassed = 1;
765
return ret;
766
}
767
justpost:
768
ret = vpninfo->xmlpost ?
769
770
xmlpost_append_form_opts(vpninfo, form, request_body) :
append_form_opts(vpninfo, form, request_body);
771
772
if (!ret) {
*method = "POST";
773
*request_body_type = vpninfo->xmlpost ? "application/xml; charset=utf-8" : "application/x-www-form-urlencoded";
774
}
775
776
777
return ret;
}
778
779
780
781
782
783
784
785
786
/*
* Old submission format is just an HTTP query string:
*
* password=12345678&username=joe
*
* New XML format is more complicated:
*
* <config-auth client="vpn" type="<!-- init or auth-reply -->">
* <version who="vpn"><!-- currently just the OpenConnect version --></version>
787
* <device-id><!-- linux, linux-64, win, ... --></device-id>
788
789
790
791
792
793
794
795
796
797
798
799
* <opaque is-for="<!-- some name -->">
* <!-- just copy this verbatim from whatever the gateway sent us -->
* </opaque>
*
* For init only, add:
* <group-access>https://<!-- insert hostname here --></group-access>
*
* For auth-reply only, add:
* <auth>
* <username><!-- same treatment as the old form options --></username>
* <password><!-- ditto -->
* </auth>
800
* <group-select><!-- name of selected authgroup --></group-select>
801
802
803
804
805
806
807
808
809
* <host-scan-token><!-- vpninfo->csd_ticket --></host-scan-token>
*/
#define XCAST(x) ((const xmlChar *)(x))
static xmlDocPtr xmlpost_new_query(struct openconnect_info *vpninfo, const char *type,
xmlNodePtr *rootp)
{
xmlDocPtr doc;
810
xmlNodePtr root, node, capabilities;
811
812
813
814
815
doc = xmlNewDoc(XCAST("1.0"));
if (!doc)
return NULL;
816
root = xmlNewNode(NULL, XCAST("config-auth"));
817
818
if (!root)
goto bad;
819
820
xmlDocSetRootElement(doc, root);
821
822
823
824
if (!xmlNewProp(root, XCAST("client"), XCAST("vpn")))
goto bad;
if (!xmlNewProp(root, XCAST("type"), XCAST(type)))
goto bad;
825
826
if (!xmlNewProp(root, XCAST("aggregate-auth-version"), XCAST("2")))
goto bad;
827
828
829
node = xmlNewTextChild(root, NULL, XCAST("version"),
XCAST(vpninfo->version_string ? : openconnect_version_str));
830
831
832
833
834
if (!node)
goto bad;
if (!xmlNewProp(node, XCAST("who"), XCAST("vpn")))
goto bad;
835
836
node = xmlNewTextChild(root, NULL, XCAST("device-id"), XCAST(vpninfo->platname));
if (!node)
837
goto bad;
838
839
840
841
842
843
if (vpninfo->mobile_platform_version) {
if (!xmlNewProp(node, XCAST("platform-version"), XCAST(vpninfo->mobile_platform_version)) ||
!xmlNewProp(node, XCAST("device-type"), XCAST(vpninfo->mobile_device_type)) ||
!xmlNewProp(node, XCAST("unique-id"), XCAST(vpninfo->mobile_device_uniqueid)))
goto bad;
}
844
845
846
847
848
849
850
851
capabilities = xmlNewNode(NULL, XCAST("capabilities"));
if (!capabilities)
goto bad;
capabilities = xmlAddChild(root, capabilities);
if (!capabilities)
goto bad;
852
853
854
855
if (!vpninfo->no_external_auth) {
node = xmlNewTextChild(capabilities, NULL, XCAST("auth-method"), XCAST("single-sign-on-v2"));
if (!node)
goto bad;
856
857
#ifdef HAVE_HPKE_SUPPORT
858
859
860
node = xmlNewTextChild(capabilities, NULL, XCAST("auth-method"), XCAST("single-sign-on-external-browser"));
if (!node)
goto bad;
861
#endif
862
}
863
864
865
866
867
868
869
if (vpninfo->certinfo[1].cert) {
node = xmlNewTextChild(capabilities, NULL, XCAST("auth-method"), XCAST("multiple-cert"));
if (!node)
goto bad;
}
870
*rootp = root;
871
872
873
874
875
876
877
return doc;
bad:
xmlFreeDoc(doc);
return NULL;
}
878
static int xmlpost_complete(xmlDocPtr doc, struct oc_text_buf *body)
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
{
xmlChar *mem = NULL;
int len, ret = 0;
if (!body) {
xmlFree(doc);
return 0;
}
xmlDocDumpMemoryEnc(doc, &mem, &len, "UTF-8");
if (!mem) {
xmlFreeDoc(doc);
return -ENOMEM;
}
894
buf_append_bytes(body, mem, len);
895
896
897
898
899
900
901
xmlFreeDoc(doc);
xmlFree(mem);
return ret;
}
902
903
static int xmlpost_initial_req(struct openconnect_info *vpninfo,
struct oc_text_buf *request_body, int cert_fail)
904
905
906
{
xmlNodePtr root, node;
xmlDocPtr doc = xmlpost_new_query(vpninfo, "init", &root);
907
char *url;
908
909
910
911
if (!doc)
return -ENOMEM;
912
913
url = internal_get_url(vpninfo);
if (!url)
914
goto bad;
915
916
node = xmlNewTextChild(root, NULL, XCAST("group-access"), XCAST(url));
917
918
if (!node)
goto bad;
919
920
921
922
923
924
if (cert_fail) {
node = xmlNewTextChild(root, NULL, XCAST("client-cert-fail"), NULL);
if (!node)
goto bad;
}
925
926
927
928
929
if (vpninfo->authgroup) {
node = xmlNewTextChild(root, NULL, XCAST("group-select"), XCAST(vpninfo->authgroup));
if (!node)
goto bad;
}
930
free(url);
931
return xmlpost_complete(doc, request_body);
932
933
bad:
934
xmlpost_complete(doc, NULL);
935
936
937
938
return -ENOMEM;
}
static int xmlpost_append_form_opts(struct openconnect_info *vpninfo,
939
struct oc_auth_form *form, struct oc_text_buf *body)
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
{
xmlNodePtr root, node;
xmlDocPtr doc = xmlpost_new_query(vpninfo, "auth-reply", &root);
struct oc_form_opt *opt;
if (!doc)
return -ENOMEM;
if (vpninfo->opaque_srvdata) {
node = xmlCopyNode(vpninfo->opaque_srvdata, 1);
if (!node)
goto bad;
if (!xmlAddChild(root, node))
goto bad;
}
node = xmlNewChild(root, NULL, XCAST("auth"), NULL);
if (!node)
goto bad;
for (opt = form->opts; opt; opt = opt->next) {
961
962
/* group_list: create a new <group-select> node under <config-auth> */
if (!strcmp(opt->name, "group_list")) {
963
if (!xmlNewTextChild(root, NULL, XCAST("group-select"), XCAST(opt->_value)))
964
965
966
967
goto bad;
continue;
}
968
969
970
971
/* answer,whichpin,new_password: rename to "password" */
if (!strcmp(opt->name, "answer") ||
!strcmp(opt->name, "whichpin") ||
!strcmp(opt->name, "new_password")) {
972
if (!xmlNewTextChild(node, NULL, XCAST("password"), XCAST(opt->_value)))
973
974
975
976
977
978
979
980
981
982
goto bad;
continue;
}
/* verify_pin,verify_password: ignore */
if (!strcmp(opt->name, "verify_pin") ||
!strcmp(opt->name, "verify_password")) {
continue;
}
983
/* everything else: create <foo>user_input</foo> under <auth> */
984
if (!xmlNewTextChild(node, NULL, XCAST(opt->name), XCAST(opt->_value)))
985
986
987
988
989
990
991
goto bad;
}
if (vpninfo->csd_token &&
!xmlNewTextChild(root, NULL, XCAST("host-scan-token"), XCAST(vpninfo->csd_token)))
goto bad;
992
return xmlpost_complete(doc, body);
993
994
bad:
995
xmlpost_complete(doc, NULL);
996
997
998
return -ENOMEM;
}
999
1000
/* Return value:
* < 0, if unable to generate a tokencode