mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
Migrate OpenConnect patches into GitHub submodule fork
Point openconnect at yuezk/openconnect globalprotect (d5c1925f) with GP patches 0001-0019 baked in. Point libxml2 at github.com/GNOME/libxml2 keeping the v2.9.9 pin. Remove compile-time patch application from build.rs and delete deps/patches/.
This commit is contained in:
23 files changed
+7
-5640
No files matched your search
+3
-2
@@ -1,6 +1,7 @@
|
||||
[submodule "crates/openconnect/deps/openconnect"]
|
||||
path = crates/openconnect/deps/openconnect
|
||||
url = https://gitlab.com/openconnect/openconnect.git
|
||||
url = https://github.com/yuezk/openconnect.git
|
||||
branch = globalprotect
|
||||
[submodule "crates/openconnect/deps/libxml2"]
|
||||
path = crates/openconnect/deps/libxml2
|
||||
url = https://gitlab.gnome.org/GNOME/libxml2.git
|
||||
url = https://github.com/GNOME/libxml2.git
|
||||
@@ -1,34 +1,4 @@
|
||||
use std::{env, path::PathBuf, process::Command};
|
||||
|
||||
fn apply_patches(patches_dir: &PathBuf, build_src: &PathBuf) {
|
||||
let patches = std::fs::read_dir(patches_dir)
|
||||
.expect("Failed to read patches directory")
|
||||
.filter_map(|entry| entry.ok())
|
||||
.filter(|entry| entry.path().extension().and_then(|s| s.to_str()) == Some("patch"))
|
||||
.map(|entry| entry.path())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
// Sort patches to ensure they are applied in order
|
||||
let mut patches = patches;
|
||||
patches.sort();
|
||||
|
||||
for patch in patches {
|
||||
println!("cargo:rerun-if-changed={}", patch.display());
|
||||
println!("Applying patch: {}", patch.display());
|
||||
|
||||
let status = Command::new("patch")
|
||||
.arg("-p1") // Strip one level of path (standard for git diffs)
|
||||
.arg("-i") // Input file
|
||||
.arg(&patch)
|
||||
.current_dir(build_src) // Run INSIDE the copied dir
|
||||
.status()
|
||||
.expect("Failed to execute patch command");
|
||||
|
||||
if !status.success() {
|
||||
panic!("Failed to apply patch file: {}", patch.display());
|
||||
}
|
||||
}
|
||||
}
|
||||
use std::{env, path::PathBuf};
|
||||
|
||||
fn build_libxml2(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
let libxml2_dir = deps_dir.join("libxml2");
|
||||
@@ -91,12 +61,11 @@ fn build_libxml2(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
|
||||
fn build_openconnect(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
let openconnect_dir = deps_dir.join("openconnect");
|
||||
let patches_dir = deps_dir.join("patches");
|
||||
|
||||
// The temporary location where we will build
|
||||
let build_src = out_dir.join("openconnect_build");
|
||||
|
||||
// Track changes so cargo rebuilds if patch or submodule changes
|
||||
// Track changes so cargo rebuilds if submodule changes
|
||||
println!("cargo:rerun-if-changed={}", openconnect_dir.display());
|
||||
|
||||
// Prepare the build directory
|
||||
@@ -114,9 +83,6 @@ fn build_openconnect(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
|
||||
fs_extra::dir::copy(&openconnect_dir, &build_src, &options).expect("Failed to copy C source code to OUT_DIR");
|
||||
|
||||
// Apply all patches from the patches directory
|
||||
apply_patches(&patches_dir, &build_src);
|
||||
|
||||
// Build the OpenConnect library using autotools
|
||||
// We explicitly enable static and disable shared to ensure we get a .a file.
|
||||
// .reconf("-ivf") is CRITICAL for git submodules because 'configure'
|
||||
@@ -215,4 +181,4 @@ fn main() {
|
||||
.include("src/ffi")
|
||||
.include(&oc_dst.join("include"))
|
||||
.compile("vpn");
|
||||
}
|
||||
}
|
||||
Submodule crates/openconnect/deps/openconnect updated: 0dcdff87db...d5c1925fe3.
-114
@@ -1,114 +0,0 @@
|
||||
From a8d5ec198ca9ae47a0e6b4f1ea244d2738acf055 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Sun, 14 Dec 2025 17:10:02 +0800
|
||||
Subject: [PATCH 1/4] Add support for GlobalProtect app version handling
|
||||
|
||||
- Introduced `gp_app_version` field in `openconnect_info` structure.
|
||||
- Implemented `openconnect_set_gp_app_version` and `openconnect_get_gp_app_version` functions.
|
||||
- Updated `gpst_get_config` to use the app version in requests.
|
||||
- Free `gp_app_version` in `openconnect_vpninfo_free` to prevent memory leaks.
|
||||
---
|
||||
gpst.c | 8 +++++---
|
||||
library.c | 15 +++++++++++++++
|
||||
openconnect-internal.h | 4 ++++
|
||||
openconnect.h | 2 ++
|
||||
4 files changed, 26 insertions(+), 3 deletions(-)
|
||||
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 244aaf04..5c24bbd2 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -650,8 +650,11 @@ static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
|
||||
|
||||
/* submit getconfig request */
|
||||
+ const char *app_version = openconnect_get_gp_app_version(vpninfo);
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG, _("Using GlobalProtect app version: %s\n"), app_version);
|
||||
+
|
||||
buf_append(request_body, "client-type=1&protocol-version=p1&internal=no");
|
||||
- append_opt(request_body, "app-version", vpninfo->csd_ticket ? : "6.3.0-33");
|
||||
+ append_opt(request_body, "app-version", app_version);
|
||||
append_opt(request_body, "ipv6-support", vpninfo->disable_ipv6 ? "no" : "yes");
|
||||
append_opt(request_body, "clientos", gpst_os_name(vpninfo));
|
||||
append_opt(request_body, "os-version", vpninfo->platname);
|
||||
@@ -1040,8 +1043,7 @@ static int run_hip_script(struct openconnect_info *vpninfo)
|
||||
* accept new ones.
|
||||
*/
|
||||
unsetenv("APP_VERSION");
|
||||
- if (vpninfo->csd_ticket)
|
||||
- if (setenv("APP_VERSION", vpninfo->csd_ticket, 1))
|
||||
+ if (setenv("APP_VERSION", openconnect_get_gp_app_version(vpninfo), 1))
|
||||
goto out;
|
||||
|
||||
execv(hip_argv[0], (char **)hip_argv);
|
||||
diff --git a/library.c b/library.c
|
||||
index b5e74e9b..18334c76 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -896,6 +896,7 @@ void openconnect_vpninfo_free(struct openconnect_info *vpninfo)
|
||||
|
||||
free(vpninfo->localname);
|
||||
free(vpninfo->useragent);
|
||||
+ free(vpninfo->gp_app_version);
|
||||
free(vpninfo->authgroup);
|
||||
#ifdef HAVE_LIBSTOKEN
|
||||
if (vpninfo->stoken_pin)
|
||||
@@ -1019,6 +1020,20 @@ int openconnect_set_useragent(struct openconnect_info *vpninfo,
|
||||
return 0;
|
||||
}
|
||||
|
||||
+int openconnect_set_gp_app_version(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_app_version)
|
||||
+{
|
||||
+ UTF8CHECK(gp_app_version);
|
||||
+
|
||||
+ STRDUP(vpninfo->gp_app_version, gp_app_version);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+const char *openconnect_get_gp_app_version(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->csd_ticket ?: (vpninfo->gp_app_version ?: "6.3.0-33");
|
||||
+}
|
||||
+
|
||||
int openconnect_set_urlpath(struct openconnect_info *vpninfo,
|
||||
const char *urlpath)
|
||||
{
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index abf45bbd..988f85f0 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -786,6 +786,7 @@ struct openconnect_info {
|
||||
int is_dyndns; /* Attempt to redo DNS lookup on each CSTP reconnect */
|
||||
char *useragent;
|
||||
char *version_string;
|
||||
+ char *gp_app_version;
|
||||
|
||||
const char *quit_reason;
|
||||
const char *delay_tunnel_reason; /* If non-null, provides a reason why protocol is not yet ready for tunnel setup */
|
||||
@@ -1677,6 +1678,9 @@ void openconnect_set_juniper(struct openconnect_info *vpninfo);
|
||||
/* hpke.c */
|
||||
int handle_external_browser(struct openconnect_info *vpninfo);
|
||||
|
||||
+/* Get the app version */
|
||||
+const char *openconnect_get_gp_app_version(struct openconnect_info *vpninfo);
|
||||
+
|
||||
/* version.c */
|
||||
extern const char openconnect_version_str[];
|
||||
|
||||
diff --git a/openconnect.h b/openconnect.h
|
||||
index 136f181a..7d4f3399 100644
|
||||
--- a/openconnect.h
|
||||
+++ b/openconnect.h
|
||||
@@ -470,6 +470,8 @@ int openconnect_set_http_proxy(struct openconnect_info *vpninfo,
|
||||
int openconnect_set_useragent(struct openconnect_info *vpninfo,
|
||||
const char *useragent);
|
||||
|
||||
+int openconnect_set_gp_app_version(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_app_version);
|
||||
int openconnect_passphrase_from_fsid(struct openconnect_info *vpninfo);
|
||||
int openconnect_obtain_cookie(struct openconnect_info *vpninfo);
|
||||
int openconnect_init_ssl(void);
|
||||
--
|
||||
2.50.1 (Apple Git-155)
|
||||
|
||||
-32
@@ -1,32 +0,0 @@
|
||||
From 8591eba702f52dae335601c997271786be50dff7 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Sun, 14 Dec 2025 17:10:52 +0800
|
||||
Subject: [PATCH 2/4] Update user agent for common headers in GlobalProtect
|
||||
authentication
|
||||
|
||||
---
|
||||
auth-globalprotect.c | 7 -------
|
||||
1 file changed, 7 deletions(-)
|
||||
|
||||
diff --git a/auth-globalprotect.c b/auth-globalprotect.c
|
||||
index 8d094273..27e41c2b 100644
|
||||
--- a/auth-globalprotect.c
|
||||
+++ b/auth-globalprotect.c
|
||||
@@ -34,14 +34,7 @@ struct login_context {
|
||||
void gpst_common_headers(struct openconnect_info *vpninfo,
|
||||
struct oc_text_buf *buf)
|
||||
{
|
||||
- char *orig_ua = vpninfo->useragent;
|
||||
-
|
||||
- /* XX: more recent servers don't appear to require this specific UA value,
|
||||
- * but we don't have any good way to detect them.
|
||||
- */
|
||||
- vpninfo->useragent = (char *)"PAN GlobalProtect";
|
||||
http_common_headers(vpninfo, buf);
|
||||
- vpninfo->useragent = orig_ua;
|
||||
}
|
||||
|
||||
/* Translate platform names (derived from AnyConnect) into the values
|
||||
--
|
||||
2.50.1 (Apple Git-155)
|
||||
|
||||
-121
@@ -1,121 +0,0 @@
|
||||
From dda2aceca7e614af65b968e632065ef223cb6612 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Sun, 14 Dec 2025 17:14:08 +0800
|
||||
Subject: [PATCH 3/4] Add support for OS version handling in GlobalProtect
|
||||
authentication
|
||||
|
||||
---
|
||||
auth-globalprotect.c | 2 +-
|
||||
gpst.c | 4 ++--
|
||||
library.c | 15 +++++++++++++++
|
||||
openconnect-internal.h | 4 ++++
|
||||
openconnect.h | 3 +++
|
||||
5 files changed, 25 insertions(+), 3 deletions(-)
|
||||
|
||||
diff --git a/auth-globalprotect.c b/auth-globalprotect.c
|
||||
index 27e41c2b..59d6de3b 100644
|
||||
--- a/auth-globalprotect.c
|
||||
+++ b/auth-globalprotect.c
|
||||
@@ -731,7 +731,7 @@ static int gpst_login(struct openconnect_info *vpninfo, int portal, struct login
|
||||
buf_append(request_body, "jnlpReady=jnlpReady&ok=Login&direct=yes&clientVer=4100&prot=https:&internal=no");
|
||||
append_opt(request_body, "ipv6-support", vpninfo->disable_ipv6 ? "no" : "yes");
|
||||
append_opt(request_body, "clientos", gpst_os_name(vpninfo));
|
||||
- append_opt(request_body, "os-version", vpninfo->platname);
|
||||
+ append_opt(request_body, "os-version", openconnect_get_gp_os_version(vpninfo));
|
||||
append_opt(request_body, "server", vpninfo->hostname);
|
||||
append_opt(request_body, "computer", vpninfo->localname);
|
||||
if (ctx->portal_userauthcookie)
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 5c24bbd2..0373fce0 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -657,7 +657,7 @@ static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
append_opt(request_body, "app-version", app_version);
|
||||
append_opt(request_body, "ipv6-support", vpninfo->disable_ipv6 ? "no" : "yes");
|
||||
append_opt(request_body, "clientos", gpst_os_name(vpninfo));
|
||||
- append_opt(request_body, "os-version", vpninfo->platname);
|
||||
+ append_opt(request_body, "os-version", openconnect_get_gp_os_version(vpninfo));
|
||||
append_opt(request_body, "hmac-algo", "sha1,md5,sha256");
|
||||
append_opt(request_body, "enc-algo", "aes-128-cbc,aes-256-cbc");
|
||||
if (old_addr || old_addr6) {
|
||||
@@ -1044,7 +1044,7 @@ static int run_hip_script(struct openconnect_info *vpninfo)
|
||||
*/
|
||||
unsetenv("APP_VERSION");
|
||||
if (setenv("APP_VERSION", openconnect_get_gp_app_version(vpninfo), 1))
|
||||
- goto out;
|
||||
+ goto out;
|
||||
|
||||
execv(hip_argv[0], (char **)hip_argv);
|
||||
|
||||
diff --git a/library.c b/library.c
|
||||
index 18334c76..e2169054 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -897,6 +897,7 @@ void openconnect_vpninfo_free(struct openconnect_info *vpninfo)
|
||||
free(vpninfo->localname);
|
||||
free(vpninfo->useragent);
|
||||
free(vpninfo->gp_app_version);
|
||||
+ free(vpninfo->gp_os_version);
|
||||
free(vpninfo->authgroup);
|
||||
#ifdef HAVE_LIBSTOKEN
|
||||
if (vpninfo->stoken_pin)
|
||||
@@ -1034,6 +1035,20 @@ const char *openconnect_get_gp_app_version(struct openconnect_info *vpninfo)
|
||||
return vpninfo->csd_ticket ?: (vpninfo->gp_app_version ?: "6.3.0-33");
|
||||
}
|
||||
|
||||
+int openconnect_set_gp_os_version(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_os_version)
|
||||
+{
|
||||
+ UTF8CHECK(gp_os_version);
|
||||
+
|
||||
+ STRDUP(vpninfo->gp_os_version, gp_os_version);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+const char *openconnect_get_gp_os_version(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_os_version ?: vpninfo->platname;
|
||||
+}
|
||||
+
|
||||
int openconnect_set_urlpath(struct openconnect_info *vpninfo,
|
||||
const char *urlpath)
|
||||
{
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index 988f85f0..5c8d2909 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -787,6 +787,7 @@ struct openconnect_info {
|
||||
char *useragent;
|
||||
char *version_string;
|
||||
char *gp_app_version;
|
||||
+ char *gp_os_version;
|
||||
|
||||
const char *quit_reason;
|
||||
const char *delay_tunnel_reason; /* If non-null, provides a reason why protocol is not yet ready for tunnel setup */
|
||||
@@ -1681,6 +1682,9 @@ int handle_external_browser(struct openconnect_info *vpninfo);
|
||||
/* Get the app version */
|
||||
const char *openconnect_get_gp_app_version(struct openconnect_info *vpninfo);
|
||||
|
||||
+/* Get the OS version string for GP */
|
||||
+const char *openconnect_get_gp_os_version(struct openconnect_info *vpninfo);
|
||||
+
|
||||
/* version.c */
|
||||
extern const char openconnect_version_str[];
|
||||
|
||||
diff --git a/openconnect.h b/openconnect.h
|
||||
index 7d4f3399..aa96a53b 100644
|
||||
--- a/openconnect.h
|
||||
+++ b/openconnect.h
|
||||
@@ -472,6 +472,9 @@ int openconnect_set_useragent(struct openconnect_info *vpninfo,
|
||||
|
||||
int openconnect_set_gp_app_version(struct openconnect_info *vpninfo,
|
||||
const char *gp_app_version);
|
||||
+int openconnect_set_gp_os_version(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_os_version);
|
||||
+
|
||||
int openconnect_passphrase_from_fsid(struct openconnect_info *vpninfo);
|
||||
int openconnect_obtain_cookie(struct openconnect_info *vpninfo);
|
||||
int openconnect_init_ssl(void);
|
||||
--
|
||||
2.50.1 (Apple Git-155)
|
||||
|
||||
-39
@@ -1,39 +0,0 @@
|
||||
From 3915a51c81831a1a9b087d82f0c760365682f23b Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Mon, 15 Dec 2025 19:20:44 +0800
|
||||
Subject: [PATCH 4/4] Add client version and OS information to HIP script
|
||||
arguments
|
||||
|
||||
---
|
||||
gpst.c | 8 ++++++--
|
||||
1 file changed, 6 insertions(+), 2 deletions(-)
|
||||
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 0373fce0..d04c42c2 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -1013,6 +1013,12 @@ static int run_hip_script(struct openconnect_info *vpninfo)
|
||||
exit(1);
|
||||
|
||||
hip_argv[i++] = openconnect_utf8_to_legacy(vpninfo, vpninfo->csd_wrapper);
|
||||
+ hip_argv[i++] = "--client-version";
|
||||
+ hip_argv[i++] = openconnect_get_gp_app_version(vpninfo);
|
||||
+ hip_argv[i++] = "--client-os";
|
||||
+ hip_argv[i++] = gpst_os_name(vpninfo);
|
||||
+ hip_argv[i++] = "--os-version";
|
||||
+ hip_argv[i++] = openconnect_get_gp_os_version(vpninfo);
|
||||
hip_argv[i++] = "--cookie";
|
||||
hip_argv[i++] = vpninfo->cookie;
|
||||
if (vpninfo->ip_info.addr) {
|
||||
@@ -1025,8 +1031,6 @@ static int run_hip_script(struct openconnect_info *vpninfo)
|
||||
}
|
||||
hip_argv[i++] = "--md5";
|
||||
hip_argv[i++] = vpninfo->csd_token;
|
||||
- hip_argv[i++] = "--client-os";
|
||||
- hip_argv[i++] = gpst_os_name(vpninfo);
|
||||
hip_argv[i++] = NULL;
|
||||
|
||||
/* XX: Sending the above parameters as --long-options was a mistake that was
|
||||
--
|
||||
2.50.1 (Apple Git-155)
|
||||
|
||||
@@ -1,124 +0,0 @@
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 244aaf04..78c16d1c 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -438,8 +438,19 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
new_ip_info.netmask = add_option_steal(&new_opts, "netmask", &s);
|
||||
} else if (!xmlnode_get_val(xml_node, "mtu", &s))
|
||||
new_ip_info.mtu = atoi(s);
|
||||
- else if (!xmlnode_get_val(xml_node, "lifetime", &s))
|
||||
+ else if (!xmlnode_get_val(xml_node, "lifetime", &s)) {
|
||||
+ vpninfo->gp_session_lifetime = atoi(s);
|
||||
vpninfo->auth_expiration = time(NULL) + atol(s);
|
||||
+ } else if (!xmlnode_get_val(xml_node, "user-expires", &s) ||
|
||||
+ !xmlnode_get_val(xml_node, "user_expires", &s)) {
|
||||
+ vpninfo->gp_user_expires = atol(s);
|
||||
+ } else if (!xmlnode_get_val(xml_node, "lifetime-notify-prior", &s)) {
|
||||
+ vpninfo->gp_lifetime_notify_prior = atoi(s);
|
||||
+ } else if (!xmlnode_get_val(xml_node, "lifetime-notify-message", &s)) {
|
||||
+ free(vpninfo->gp_lifetime_notify_message);
|
||||
+ vpninfo->gp_lifetime_notify_message = s;
|
||||
+ s = NULL;
|
||||
+ }
|
||||
else if (!xmlnode_get_val(xml_node, "quarantine", &s)) {
|
||||
if (strcmp(s, "no"))
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
diff --git a/libopenconnect.map.in b/libopenconnect.map.in
|
||||
index f036c071..44110486 100644
|
||||
--- a/libopenconnect.map.in
|
||||
+++ b/libopenconnect.map.in
|
||||
@@ -113,6 +113,10 @@ OPENCONNECT_5_7 {
|
||||
openconnect_set_cookie;
|
||||
openconnect_set_allow_insecure_crypto;
|
||||
openconnect_get_auth_expiration;
|
||||
+ openconnect_get_gp_session_lifetime;
|
||||
+ openconnect_get_gp_user_expires;
|
||||
+ openconnect_get_gp_lifetime_notify_prior;
|
||||
+ openconnect_get_gp_lifetime_notify_message;
|
||||
openconnect_disable_dtls;
|
||||
openconnect_get_connect_url;
|
||||
openconnect_set_webview_callback;
|
||||
diff --git a/libopenconnect5.symbols b/libopenconnect5.symbols
|
||||
index 7cb04d05..2c7af781 100644
|
||||
--- a/libopenconnect5.symbols
|
||||
+++ b/libopenconnect5.symbols
|
||||
@@ -94,6 +94,10 @@ libopenconnect.so.5 libopenconnect5 #MINVER#
|
||||
openconnect_set_cookie@OPENCONNECT_5_7 8.20
|
||||
openconnect_set_allow_insecure_crypto@OPENCONNECT_5_7 8.20
|
||||
openconnect_get_auth_expiration@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_session_lifetime@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_user_expires@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_lifetime_notify_prior@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_lifetime_notify_message@OPENCONNECT_5_7 8.20
|
||||
openconnect_disable_dtls@OPENCONNECT_5_7 8.20
|
||||
openconnect_get_connect_url@OPENCONNECT_5_7 8.20
|
||||
openconnect_set_webview_callback@OPENCONNECT_5_7 8.20
|
||||
diff --git a/library.c b/library.c
|
||||
index b5e74e9b..03f47004 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -838,6 +838,7 @@ void openconnect_vpninfo_free(struct openconnect_info *vpninfo)
|
||||
free(vpninfo->dtls_cipher);
|
||||
free(vpninfo->peer_cert_hash);
|
||||
free(vpninfo->ciphersuite_config);
|
||||
+ free(vpninfo->gp_lifetime_notify_message);
|
||||
#if defined(OPENCONNECT_OPENSSL)
|
||||
free(vpninfo->cstp_cipher);
|
||||
#if defined(HAVE_BIO_METH_FREE)
|
||||
@@ -1137,6 +1138,26 @@ time_t openconnect_get_auth_expiration(struct openconnect_info *vpninfo)
|
||||
return vpninfo->auth_expiration;
|
||||
}
|
||||
|
||||
+int openconnect_get_gp_session_lifetime(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_session_lifetime;
|
||||
+}
|
||||
+
|
||||
+time_t openconnect_get_gp_user_expires(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_user_expires;
|
||||
+}
|
||||
+
|
||||
+int openconnect_get_gp_lifetime_notify_prior(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_lifetime_notify_prior;
|
||||
+}
|
||||
+
|
||||
+const char *openconnect_get_gp_lifetime_notify_message(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_lifetime_notify_message;
|
||||
+}
|
||||
+
|
||||
int openconnect_get_ip_info(struct openconnect_info *vpninfo,
|
||||
const struct oc_ip_info **info,
|
||||
const struct oc_vpn_option **cstp_options,
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index abf45bbd..dd5507ca 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -647,6 +647,10 @@ struct openconnect_info {
|
||||
int dtls_attempt_period;
|
||||
int udp_probes_sent;
|
||||
time_t auth_expiration;
|
||||
+ int gp_session_lifetime;
|
||||
+ time_t gp_user_expires;
|
||||
+ int gp_lifetime_notify_prior;
|
||||
+ char *gp_lifetime_notify_message;
|
||||
time_t new_dtls_started;
|
||||
#if defined(OPENCONNECT_OPENSSL)
|
||||
SSL_CTX *dtls_ctx;
|
||||
diff --git a/openconnect.h b/openconnect.h
|
||||
index 136f181a..febf15cc 100644
|
||||
--- a/openconnect.h
|
||||
+++ b/openconnect.h
|
||||
@@ -655,6 +655,10 @@ void openconnect_set_dpd(struct openconnect_info *, int min_seconds);
|
||||
void openconnect_set_trojan_interval(struct openconnect_info *, int seconds);
|
||||
int openconnect_get_idle_timeout(struct openconnect_info *);
|
||||
time_t openconnect_get_auth_expiration(struct openconnect_info *);
|
||||
+int openconnect_get_gp_session_lifetime(struct openconnect_info *);
|
||||
+time_t openconnect_get_gp_user_expires(struct openconnect_info *);
|
||||
+int openconnect_get_gp_lifetime_notify_prior(struct openconnect_info *);
|
||||
+const char *openconnect_get_gp_lifetime_notify_message(struct openconnect_info *);
|
||||
|
||||
/* The returned structures are owned by the library and may be freed/replaced
|
||||
due to rekey or reconnect. Assume that once the mainloop starts, the
|
||||
@@ -1,101 +0,0 @@
|
||||
From 78078b21f53801b31fef352ec0de40d319edcae9 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Sat, 13 Jun 2026 12:00:00 +0800
|
||||
Subject: [PATCH 6/6] Add host ID to GlobalProtect HIP script arguments
|
||||
|
||||
---
|
||||
gpst.c | 4 ++++
|
||||
library.c | 15 +++++++++++++++
|
||||
openconnect-internal.h | 4 ++++
|
||||
openconnect.h | 3 +++
|
||||
4 files changed, 26 insertions(+)
|
||||
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 78c16d1c..f1e1f6bb 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -1019,6 +1019,10 @@ static int run_hip_script(struct openconnect_info *vpninfo)
|
||||
hip_argv[i++] = "--client-os";
|
||||
hip_argv[i++] = gpst_os_name(vpninfo);
|
||||
hip_argv[i++] = "--os-version";
|
||||
hip_argv[i++] = openconnect_get_gp_os_version(vpninfo);
|
||||
+ if (openconnect_get_gp_host_id(vpninfo)) {
|
||||
+ hip_argv[i++] = "--host-id";
|
||||
+ hip_argv[i++] = openconnect_get_gp_host_id(vpninfo);
|
||||
+ }
|
||||
hip_argv[i++] = "--cookie";
|
||||
hip_argv[i++] = vpninfo->cookie;
|
||||
if (vpninfo->ip_info.addr) {
|
||||
diff --git a/library.c b/library.c
|
||||
index 03f47004..9e585119 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -900,6 +900,7 @@ void openconnect_vpninfo_free(struct openconnect_info *vpninfo)
|
||||
free(vpninfo->useragent);
|
||||
free(vpninfo->gp_app_version);
|
||||
free(vpninfo->gp_os_version);
|
||||
+ free(vpninfo->gp_host_id);
|
||||
free(vpninfo->authgroup);
|
||||
#ifdef HAVE_LIBSTOKEN
|
||||
if (vpninfo->stoken_pin)
|
||||
@@ -1049,6 +1050,20 @@ const char *openconnect_get_gp_os_version(struct openconnect_info *vpninfo)
|
||||
return vpninfo->gp_os_version ?: vpninfo->platname;
|
||||
}
|
||||
|
||||
+int openconnect_set_gp_host_id(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_host_id)
|
||||
+{
|
||||
+ UTF8CHECK(gp_host_id);
|
||||
+
|
||||
+ STRDUP(vpninfo->gp_host_id, gp_host_id);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+const char *openconnect_get_gp_host_id(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_host_id;
|
||||
+}
|
||||
+
|
||||
int openconnect_set_urlpath(struct openconnect_info *vpninfo,
|
||||
const char *urlpath)
|
||||
{
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index a7e80659..76034fbd 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -788,6 +788,7 @@ struct openconnect_info {
|
||||
char *version_string;
|
||||
char *gp_app_version;
|
||||
char *gp_os_version;
|
||||
+ char *gp_host_id;
|
||||
|
||||
const char *quit_reason;
|
||||
const char *delay_tunnel_reason; /* If non-null, provides a reason why protocol is not yet ready for tunnel setup */
|
||||
@@ -1684,6 +1685,9 @@ const char *openconnect_get_gp_app_version(struct openconnect_info *vpninfo);
|
||||
/* Get the OS version string for GP */
|
||||
const char *openconnect_get_gp_os_version(struct openconnect_info *vpninfo);
|
||||
|
||||
+/* Get the host ID string for GP */
|
||||
+const char *openconnect_get_gp_host_id(struct openconnect_info *vpninfo);
|
||||
+
|
||||
/* version.c */
|
||||
extern const char openconnect_version_str[];
|
||||
|
||||
diff --git a/openconnect.h b/openconnect.h
|
||||
index 40de2811..3c65c090 100644
|
||||
--- a/openconnect.h
|
||||
+++ b/openconnect.h
|
||||
@@ -472,8 +472,11 @@ int openconnect_set_useragent(struct openconnect_info *vpninfo,
|
||||
int openconnect_set_gp_app_version(struct openconnect_info *vpninfo,
|
||||
const char *gp_app_version);
|
||||
int openconnect_set_gp_os_version(struct openconnect_info *vpninfo,
|
||||
const char *gp_os_version);
|
||||
+int openconnect_set_gp_host_id(struct openconnect_info *vpninfo,
|
||||
+ const char *gp_host_id);
|
||||
+
|
||||
|
||||
int openconnect_passphrase_from_fsid(struct openconnect_info *vpninfo);
|
||||
int openconnect_obtain_cookie(struct openconnect_info *vpninfo);
|
||||
int openconnect_init_ssl(void);
|
||||
--
|
||||
2.50.1 (Apple Git-155)
|
||||
@@ -1,15 +0,0 @@
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index 244aaf04..fb8d945d 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -669,6 +669,10 @@ static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
result = do_https_request(vpninfo, "POST", "application/x-www-form-urlencoded", request_body, &xml_buf, NULL, HTTP_NO_FLAGS);
|
||||
free(vpninfo->urlpath);
|
||||
vpninfo->urlpath = orig_path;
|
||||
+ if (result >= 0 && xml_buf)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ "GlobalProtect getconfig.esp response:\n%s\n",
|
||||
+ xml_buf);
|
||||
|
||||
/* parse getconfig result */
|
||||
if (result >= 0)
|
||||
@@ -1,238 +0,0 @@
|
||||
From 0000000000000000000000000000000000000001 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 18:00:00 +0800
|
||||
Subject: [PATCH 7/7] Support GlobalProtect NLB config
|
||||
|
||||
Parse NLB fields from getconfig.esp XML, store them in vpninfo, and
|
||||
align the getconfig request with the official GlobalProtect client.
|
||||
---
|
||||
gpst.c | 58 ++++++++++++++++++++++++++++++++++++++--
|
||||
libopenconnect.map.in | 2 ++
|
||||
libopenconnect5.symbols | 2 ++
|
||||
library.c | 16 +++++++++++
|
||||
openconnect-internal.h | 15 ++++++++++
|
||||
openconnect.h | 2 ++
|
||||
6 files changed, 93 insertions(+), 2 deletions(-)
|
||||
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index f1e1f6bb..a8b3c4d5 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -477,6 +477,10 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
* gateway is meaningless." See esp_send_probes_gp for the
|
||||
* gory details of what this field actually means.
|
||||
*/
|
||||
+ if (!strcmp(s, "127.127.127.127")) {
|
||||
+ free(vpninfo->gp_nlb.tunnel_vip);
|
||||
+ vpninfo->gp_nlb.tunnel_vip = strdup(s);
|
||||
+ }
|
||||
if (vpninfo->peer_addr->sa_family == IPPROTO_IP &&
|
||||
vpninfo->ip_info.gateway_addr && strcmp(s, vpninfo->ip_info.gateway_addr))
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
@@ -495,12 +499,17 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
inet_pton(AF_INET6, s, &esp_magic_v6);
|
||||
#endif /* HAVE_ESP */
|
||||
} else if (!xmlnode_get_val(xml_node, "connected-gw-ip", &s)) {
|
||||
- if (vpninfo->ip_info.gateway_addr && strcmp(s, vpninfo->ip_info.gateway_addr))
|
||||
+ free(vpninfo->gp_nlb.connected_gw_ip);
|
||||
+ vpninfo->gp_nlb.connected_gw_ip = s;
|
||||
+ s = NULL;
|
||||
+ if (vpninfo->ip_info.gateway_addr &&
|
||||
+ strcmp(vpninfo->gp_nlb.connected_gw_ip, vpninfo->ip_info.gateway_addr))
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Config XML <connected-gw-ip> address (%s) differs from external\n"
|
||||
"gateway address (%s). Please report this to\n"
|
||||
"<%s>, including any problems\n"
|
||||
"with ESP or other apparent loss of connectivity or performance.\n"),
|
||||
- s, vpninfo->ip_info.gateway_addr, "[email protected]");
|
||||
+ vpninfo->gp_nlb.connected_gw_ip, vpninfo->ip_info.gateway_addr,
|
||||
+ "[email protected]");
|
||||
} else if (xmlnode_is_named(xml_node, "dns-v6") ||
|
||||
xmlnode_is_named(xml_node, "dns")) {
|
||||
for (member = xml_node->children; member && n_dns<3; member=member->next) {
|
||||
@@ -575,6 +584,36 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
#else
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Ignoring ESP keys since ESP support not available in this build\n"));
|
||||
#endif
|
||||
+ } else if (xmlnode_is_named(xml_node, "hs-key")) {
|
||||
+#ifdef HAVE_ESP
|
||||
+ int keylen = xml_to_key(xml_node, vpninfo->gp_nlb.hs_key, sizeof(vpninfo->gp_nlb.hs_key));
|
||||
+ if (keylen > 0) {
|
||||
+ vpninfo->gp_nlb.hs_key_len = keylen;
|
||||
+ vpninfo->gp_nlb.hs_key_bits = keylen * 8;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ }
|
||||
+#endif /* HAVE_ESP */
|
||||
+ } else if (!xmlnode_get_val(xml_node, "enc-hs-key", &s)) {
|
||||
+ free(vpninfo->gp_nlb.enc_hs_key);
|
||||
+ vpninfo->gp_nlb.enc_hs_key = s;
|
||||
+ s = NULL;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ } else if (xmlnode_is_named(xml_node, "tunnel-opaque")) {
|
||||
+ if (!xmlnode_get_val(xml_node, "val", &s)) {
|
||||
+ free(vpninfo->gp_nlb.tunnel_opaque);
|
||||
+ vpninfo->gp_nlb.tunnel_opaque = s;
|
||||
+ s = NULL;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ }
|
||||
+ if (!xmlnode_get_val(xml_node, "valid-period", &s)) {
|
||||
+ vpninfo->gp_nlb.opaque_valid_until = time(NULL) + atol(s);
|
||||
+ }
|
||||
+ } else if (!xmlnode_get_val(xml_node, "valid-period", &s)) {
|
||||
+ vpninfo->gp_nlb.opaque_valid_until = time(NULL) + atol(s);
|
||||
+ } else if (!xmlnode_get_val(xml_node, "in-tunnel-gw-cert-chksum", &s)) {
|
||||
+ free(vpninfo->gp_nlb.in_tunnel_gw_cert_chksum);
|
||||
+ vpninfo->gp_nlb.in_tunnel_gw_cert_chksum = s;
|
||||
+ s = NULL;
|
||||
} else if (xmlnode_is_named(xml_node, "need-tunnel")
|
||||
|| xmlnode_is_named(xml_node, "bw-c2s")
|
||||
|| xmlnode_is_named(xml_node, "bw-s2c")
|
||||
@@ -585,7 +624,8 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
|| xmlnode_is_named(xml_node, "ip-address-v6-preferred")
|
||||
|| xmlnode_is_named(xml_node, "ipv6-connection")
|
||||
|| xmlnode_is_named(xml_node, "portal")
|
||||
- || xmlnode_is_named(xml_node, "user")) {
|
||||
+ || xmlnode_is_named(xml_node, "user")
|
||||
+ || xmlnode_is_named(xml_node, "use-ssl-tunnel")) {
|
||||
/* XX: Do these have any potential value at all for routing configuration or diagnostics? */
|
||||
} else if (xml_node->type == XML_ELEMENT_NODE) {
|
||||
free(s);
|
||||
@@ -597,6 +637,15 @@ static int gpst_parse_config_xml(struct openconnect_info *vpninfo, xmlNode *xml_
|
||||
}
|
||||
}
|
||||
|
||||
+ if (vpninfo->gp_nlb.tunnel_opaque)
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+
|
||||
+ if (vpninfo->gp_nlb.enabled)
|
||||
+ vpn_progress(vpninfo, PRG_INFO, _("NLB enabled\n"));
|
||||
+ else
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("hs-key section is not specified. Non-nlb\n"));
|
||||
+
|
||||
/* Set 10-second DPD/keepalive (same as Windows client) unless
|
||||
* overridden with --force-dpd */
|
||||
if (!vpninfo->ssl_times.dpd)
|
||||
@@ -670,13 +719,17 @@ static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
append_opt(request_body, "clientos", gpst_os_name(vpninfo));
|
||||
append_opt(request_body, "os-version", openconnect_get_gp_os_version(vpninfo));
|
||||
append_opt(request_body, "hmac-algo", "sha1,md5,sha256");
|
||||
- append_opt(request_body, "enc-algo", "aes-128-cbc,aes-256-cbc");
|
||||
+ append_opt(request_body, "enc-algo", "aes-256-gcm,aes-128-gcm,aes-128-cbc");
|
||||
+ append_opt(request_body, "clientgpversion", app_version);
|
||||
+ if (openconnect_get_gp_host_id(vpninfo))
|
||||
+ append_opt(request_body, "host-id", openconnect_get_gp_host_id(vpninfo));
|
||||
if (old_addr || old_addr6) {
|
||||
append_opt(request_body, "preferred-ip", old_addr);
|
||||
append_opt(request_body, "preferred-ipv6", old_addr6);
|
||||
filter_opts(request_body, vpninfo->cookie, "preferred-ip,preferred-ipv6", 0);
|
||||
} else
|
||||
buf_append(request_body, "&%s", vpninfo->cookie);
|
||||
+ filter_opts(request_body, vpninfo->cookie, "serialno,clientgpversion,host-id", 1);
|
||||
if ((result = buf_error(request_body)))
|
||||
goto out;
|
||||
|
||||
diff --git a/libopenconnect.map.in b/libopenconnect.map.in
|
||||
index 44110486..8c2f1a3b 100644
|
||||
--- a/libopenconnect.map.in
|
||||
+++ b/libopenconnect.map.in
|
||||
@@ -117,6 +117,8 @@ OPENCONNECT_5_7 {
|
||||
openconnect_get_gp_user_expires;
|
||||
openconnect_get_gp_lifetime_notify_prior;
|
||||
openconnect_get_gp_lifetime_notify_message;
|
||||
+ openconnect_get_gp_nlb_enabled;
|
||||
+ openconnect_get_gp_nlb_connected_gw_ip;
|
||||
openconnect_disable_dtls;
|
||||
openconnect_get_connect_url;
|
||||
openconnect_set_webview_callback;
|
||||
diff --git a/libopenconnect5.symbols b/libopenconnect5.symbols
|
||||
index 2c7af781..b4e8d9a2 100644
|
||||
--- a/libopenconnect5.symbols
|
||||
+++ b/libopenconnect5.symbols
|
||||
@@ -98,6 +98,8 @@ libopenconnect.so.5 libopenconnect5 #MINVER#
|
||||
openconnect_get_gp_user_expires@OPENCONNECT_5_7 8.20
|
||||
openconnect_get_gp_lifetime_notify_prior@OPENCONNECT_5_7 8.20
|
||||
openconnect_get_gp_lifetime_notify_message@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_nlb_enabled@OPENCONNECT_5_7 8.20
|
||||
+ openconnect_get_gp_nlb_connected_gw_ip@OPENCONNECT_5_7 8.20
|
||||
openconnect_disable_dtls@OPENCONNECT_5_7 8.20
|
||||
openconnect_get_connect_url@OPENCONNECT_5_7 8.20
|
||||
openconnect_set_webview_callback@OPENCONNECT_5_7 8.20
|
||||
diff --git a/library.c b/library.c
|
||||
index 9e585119..c3d4e5f6 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -839,6 +839,12 @@ void openconnect_vpninfo_free(struct openconnect_info *vpninfo)
|
||||
free(vpninfo->peer_cert_hash);
|
||||
free(vpninfo->ciphersuite_config);
|
||||
free(vpninfo->gp_lifetime_notify_message);
|
||||
+ free(vpninfo->gp_nlb.enc_hs_key);
|
||||
+ free(vpninfo->gp_nlb.tunnel_opaque);
|
||||
+ free(vpninfo->gp_nlb.inner_gw_ip);
|
||||
+ free(vpninfo->gp_nlb.tunnel_vip);
|
||||
+ free(vpninfo->gp_nlb.connected_gw_ip);
|
||||
+ free(vpninfo->gp_nlb.in_tunnel_gw_cert_chksum);
|
||||
#if defined(OPENCONNECT_OPENSSL)
|
||||
free(vpninfo->cstp_cipher);
|
||||
#if defined(HAVE_BIO_METH_FREE)
|
||||
@@ -1201,6 +1207,16 @@ const char *openconnect_get_gp_lifetime_notify_message(struct openconnect_info *v
|
||||
return vpninfo->gp_lifetime_notify_message;
|
||||
}
|
||||
|
||||
+int openconnect_get_gp_nlb_enabled(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_nlb.enabled;
|
||||
+}
|
||||
+
|
||||
+const char *openconnect_get_gp_nlb_connected_gw_ip(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_nlb.connected_gw_ip;
|
||||
+}
|
||||
+
|
||||
int openconnect_get_ip_info(struct openconnect_info *vpninfo,
|
||||
const struct oc_ip_info **info,
|
||||
const struct oc_vpn_option **cstp_options,
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index 76034fbd..91a2b3c4 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -391,6 +391,20 @@ struct oc_ip_info {
|
||||
|
||||
struct openconnect_info;
|
||||
|
||||
+struct gp_nlb_config {
|
||||
+ int enabled;
|
||||
+ unsigned char hs_key[32];
|
||||
+ int hs_key_bits;
|
||||
+ int hs_key_len;
|
||||
+ char *enc_hs_key;
|
||||
+ char *tunnel_opaque;
|
||||
+ time_t opaque_valid_until;
|
||||
+ char *inner_gw_ip;
|
||||
+ char *tunnel_vip;
|
||||
+ char *connected_gw_ip;
|
||||
+ char *in_tunnel_gw_cert_chksum;
|
||||
+};
|
||||
+
|
||||
struct cert_info {
|
||||
struct openconnect_info *vpninfo;
|
||||
char *cert;
|
||||
@@ -651,6 +665,7 @@ struct openconnect_info {
|
||||
time_t gp_user_expires;
|
||||
int gp_lifetime_notify_prior;
|
||||
char *gp_lifetime_notify_message;
|
||||
+ struct gp_nlb_config gp_nlb;
|
||||
time_t new_dtls_started;
|
||||
#if defined(OPENCONNECT_OPENSSL)
|
||||
SSL_CTX *dtls_ctx;
|
||||
diff --git a/openconnect.h b/openconnect.h
|
||||
index febf15cc..d7e8f9a0 100644
|
||||
--- a/openconnect.h
|
||||
+++ b/openconnect.h
|
||||
@@ -667,6 +667,8 @@ time_t openconnect_get_gp_user_expires(struct openconnect_info *);
|
||||
int openconnect_get_gp_lifetime_notify_prior(struct openconnect_info *);
|
||||
const char *openconnect_get_gp_lifetime_notify_message(struct openconnect_info *);
|
||||
+int openconnect_get_gp_nlb_enabled(struct openconnect_info *);
|
||||
+const char *openconnect_get_gp_nlb_connected_gw_ip(struct openconnect_info *);
|
||||
|
||||
/* The returned structures are owned by the library and may be freed/replaced
|
||||
due to rekey or reconnect. Assume that once the mainloop starts, the
|
||||
@@ -1,459 +0,0 @@
|
||||
From 0000000000000000000000000000000000000002 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 18:30:00 +0800
|
||||
Subject: [PATCH 8/8] Add GlobalProtect NLB module skeleton
|
||||
|
||||
Add gpst_nlb.c with PanGPS 6.3.3.1 RE notes, SSL response parser,
|
||||
opaque blob decoding, and stub ESP encap/decap for Phase 3.
|
||||
---
|
||||
Makefile.am | 2 +-
|
||||
gpst.c | 4 +
|
||||
gpst_nlb.c | 271 +
|
||||
tests/gp-nlb-ssl-parse | 90 +++++++++++++++++++++++++++++++++++++++++
|
||||
library.c | 4 +
|
||||
openconnect-internal.h | 8 ++
|
||||
6 files changed, 378 insertions(+), 1 deletion(-)
|
||||
create mode 100644 gpst_nlb.c
|
||||
|
||||
diff --git a/Makefile.am b/Makefile.am
|
||||
index 12345678..abcdef01 100644
|
||||
--- a/Makefile.am
|
||||
+++ b/Makefile.am
|
||||
@@ -45,7 +45,7 @@
|
||||
lib_srcs_cisco = auth.c cstp.c hpke.c multicert.c
|
||||
lib_srcs_juniper = oncp.c lzo.c auth-juniper.c
|
||||
lib_srcs_pulse = pulse.c
|
||||
-lib_srcs_globalprotect = gpst.c win32-ipicmp.h auth-globalprotect.c
|
||||
+lib_srcs_globalprotect = gpst.c gpst_nlb.c win32-ipicmp.h auth-globalprotect.c
|
||||
lib_srcs_array = array.c
|
||||
lib_srcs_oath = oath.c
|
||||
lib_srcs_oidc = oidc.c
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index a8b3c4d5..b9c4d5e6 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -1162,6 +1162,10 @@
|
||||
if (ret)
|
||||
goto out;
|
||||
|
||||
+ ret = gpst_nlb_prepare(vpninfo);
|
||||
+ if (ret)
|
||||
+ goto out;
|
||||
+
|
||||
/* Always check HIP after getting configuration */
|
||||
ret = check_and_maybe_submit_hip_report(vpninfo);
|
||||
if (ret)
|
||||
diff --git a/gpst_nlb.c b/gpst_nlb.c
|
||||
new file mode 100644
|
||||
index 00000000..c0ffee00 100644
|
||||
--- /dev/null
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -0,0 +1,271 @@
|
||||
+/*
|
||||
+ * GlobalProtect NLB (Network Load Balancer) tunnel support
|
||||
+ *
|
||||
+ * Reverse-engineering notes from PanGPS 6.3.3.1 (GlobalProtect_UI_deb-6.3.3.1-619):
|
||||
+ *
|
||||
+ * Detection (ClientConfig.cpp):
|
||||
+ * - NLB gateways return <hs-key>, <enc-hs-key>, <tunnel-opaque>, <valid-period>
|
||||
+ * - Non-NLB logs: "hs-key section is not specified. Non-nlb"
|
||||
+ *
|
||||
+ * Config field usage:
|
||||
+ * hs-key Handshake key (<bits> + <val> hex); fed to pan_esp_encap
|
||||
+ * enc-hs-key Base64 encrypted auxiliary key; likely decrypts tunnel-opaque
|
||||
+ * tunnel-opaque Base64 blob stored internally as opaqueBlob
|
||||
+ * valid-period Seconds until tunnel-opaque must be refreshed via getconfig.esp
|
||||
+ * gw-address ESP magic / VIP; NLB gateways use 127.127.127.127
|
||||
+ * connected-gw-ip NLB frontend address (may differ from DNS peer)
|
||||
+ *
|
||||
+ * ESP path (pan_esp_encap.cpp, PanNATTunnelVPN.cpp):
|
||||
+ * - Standard ESP keys from <ipsec> XML are installed via pan_esp_encap_init
|
||||
+ * - Outbound UDP payloads wrapped by EncapSendData using opaqueBlob + pan_hmac
|
||||
+ * - Inbound unwrapped by DecapRecvData; failures log:
|
||||
+ * "invalid tunnel packet len %u magic 0x%x type %u"
|
||||
+ * - ESP probes use 56-byte ICMP payload (not openconnect's 16-byte minimum):
|
||||
+ * "monitor\\0\\0pan ha 0123456789:;<=>? !\"#$%&'()*+,-./" + 0x10..0x17
|
||||
+ * - Probes target tunnel VIP (<gw-address>), UDP still sent to public peer_addr
|
||||
+ * - NLB keepalive sent before data: "Send keepalive first for NLB tunnel restoration"
|
||||
+ *
|
||||
+ * SSL failover path (PanSslVpn.cpp):
|
||||
+ * - SendTunnelRequest: user=%s&authcookie=%s&install=yes&preferred-ip=%s&preferred-ipv6=%s
|
||||
+ * - Response is raw line protocol, not an HTTP status line. NLB format (issue #526):
|
||||
+ * "110 <vip><inner_gw_ip> <40-hex-sha1> START_TUNNEL"
|
||||
+ * Example: "110 127.127.127.127192.168.255.43 c057fc7f... START_TUNNEL"
|
||||
+ * - vip and inner_gw_ip are concatenated without a separator
|
||||
+ *
|
||||
+ * Post-handshake (HandleNLB in PanNATTunnelVPN.cpp):
|
||||
+ * - getNlbRealGwIp() resolves inner gateway IP
|
||||
+ * - "NLB: add an access route for NLB private ip: %s."
|
||||
+ *
|
||||
+ * Crypto RE status: opaque envelope magic/type constants and enc-hs-key
|
||||
+ * decipherment are not yet recovered from stripped ELF; encap/decap remain stubs.
|
||||
+ */
|
||||
+
|
||||
+#include <config.h>
|
||||
+#include <errno.h>
|
||||
+#include <stdlib.h>
|
||||
+#include <string.h>
|
||||
+#include <stdio.h>
|
||||
+#include <ctype.h>
|
||||
+
|
||||
+#include "openconnect-internal.h"
|
||||
+
|
||||
+/* Official 56-byte ESP probe payload (PanGPS / Windows client) */
|
||||
+static const unsigned char gp_nlb_probe_template[56] =
|
||||
+ "monitor\x00\x00pan ha 0123456789:;<=>? !\"#$%&'()*+,-./"
|
||||
+ "\x10\x11\x12\x13\x14\x15\x16\x17";
|
||||
+
|
||||
+#define GP_NLB_SSL_PROTO_VERSION 110
|
||||
+
|
||||
+static int gp_nlb_is_ipv4(const char *s)
|
||||
+{
|
||||
+ struct in_addr a;
|
||||
+ return s && inet_pton(AF_INET, s, &a) == 1;
|
||||
+}
|
||||
+
|
||||
+static int gp_nlb_split_concat_ips(const char *concat, const char *hint_vip,
|
||||
+ char **vip, char **inner)
|
||||
+{
|
||||
+ const char *split;
|
||||
+ size_t vip_len;
|
||||
+
|
||||
+ if (!concat || !*concat)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (hint_vip && !strncmp(concat, hint_vip, strlen(hint_vip))) {
|
||||
+ vip_len = strlen(hint_vip);
|
||||
+ if (concat[vip_len] && gp_nlb_is_ipv4(concat + vip_len)) {
|
||||
+ STRDUP(*vip, hint_vip);
|
||||
+ STRDUP(*inner, concat + vip_len);
|
||||
+ return 0;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ for (split = concat; *split; split++) {
|
||||
+ if (*split != '.' && !isdigit((unsigned char)*split))
|
||||
+ continue;
|
||||
+ if (!gp_nlb_is_ipv4(concat) || !gp_nlb_is_ipv4(split))
|
||||
+ continue;
|
||||
+ vip_len = split - concat;
|
||||
+ if (!vip_len)
|
||||
+ continue;
|
||||
+ *vip = strndup(concat, vip_len);
|
||||
+ *inner = strdup(split);
|
||||
+ if (!*vip || !*inner) {
|
||||
+ free(*vip);
|
||||
+ free(*inner);
|
||||
+ *vip = *inner = NULL;
|
||||
+ return -ENOMEM;
|
||||
+ }
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ return -EINVAL;
|
||||
+}
|
||||
+
|
||||
+static void gp_nlb_clear_opaque_blob(struct gp_nlb_config *nlb)
|
||||
+{
|
||||
+ if (nlb->opaque_blob) {
|
||||
+ memset(nlb->opaque_blob, 0, nlb->opaque_blob_len);
|
||||
+ free(nlb->opaque_blob);
|
||||
+ nlb->opaque_blob = NULL;
|
||||
+ }
|
||||
+ nlb->opaque_blob_len = 0;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_prepare(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+ int len;
|
||||
+
|
||||
+ if (!nlb->enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ if (!nlb->tunnel_vip && nlb->tunnel_opaque)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB enabled but no tunnel VIP yet; expecting 127.127.127.127 from <gw-address>\n"));
|
||||
+
|
||||
+ gp_nlb_clear_opaque_blob(nlb);
|
||||
+ if (nlb->tunnel_opaque) {
|
||||
+ nlb->opaque_blob = openconnect_base64_decode(&len, nlb->tunnel_opaque);
|
||||
+ if (!nlb->opaque_blob || len <= 0) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("Failed to base64-decode tunnel-opaque\n"));
|
||||
+ free(nlb->opaque_blob);
|
||||
+ nlb->opaque_blob = NULL;
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ nlb->opaque_blob_len = len;
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("Decoded tunnel-opaque (%d bytes); enc-hs-key decipherment not yet implemented\n"),
|
||||
+ len);
|
||||
+ }
|
||||
+
|
||||
+ if (nlb->enc_hs_key)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("enc-hs-key present (%zu chars); crypto RE pending\n"),
|
||||
+ strlen(nlb->enc_hs_key));
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+const unsigned char *gpst_nlb_probe_payload(size_t *len)
|
||||
+{
|
||||
+ if (len)
|
||||
+ *len = sizeof(gp_nlb_probe_template);
|
||||
+ return gp_nlb_probe_template;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt)
|
||||
+{
|
||||
+ if (!vpninfo->gp_nlb.enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ /* Phase 3: wrap pkt with NLB opaque envelope via hs-key + opaque_blob */
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("gpst_nlb_esp_encap: stub (opaque envelope RE incomplete)\n"));
|
||||
+ return -ENOTSUP;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt)
|
||||
+{
|
||||
+ if (!vpninfo->gp_nlb.enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("gpst_nlb_esp_decap: stub (opaque envelope RE incomplete)\n"));
|
||||
+ return -ENOTSUP;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb)
|
||||
+{
|
||||
+ char *line, *vip = NULL, *inner = NULL, *hash, *start, *concat;
|
||||
+ const char *hint_vip;
|
||||
+ long version;
|
||||
+ int ret = -EINVAL;
|
||||
+
|
||||
+ if (!buf || len <= 0 || !nlb)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ line = strndup(buf, len);
|
||||
+ if (!line)
|
||||
+ return -ENOMEM;
|
||||
+
|
||||
+ /* Trim trailing CR/LF */
|
||||
+ for (char *p = line + strlen(line); p > line; p--) {
|
||||
+ if (p[-1] == '\r' || p[-1] == '\n')
|
||||
+ p[-1] = '\0';
|
||||
+ else
|
||||
+ break;
|
||||
+ }
|
||||
+
|
||||
+ if (!strncmp(line, "START_TUNNEL", 12)) {
|
||||
+ ret = 0;
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ start = strstr(line, " START_TUNNEL");
|
||||
+ if (!start) {
|
||||
+ ret = -EINVAL;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ *start = '\0';
|
||||
+ hash = strrchr(line, ' ');
|
||||
+ if (!hash || strlen(hash + 1) != 40) {
|
||||
+ ret = -EINVAL;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ *hash++ = '\0';
|
||||
+
|
||||
+ if (sscanf(line, "%ld", &version) != 1 || version != GP_NLB_SSL_PROTO_VERSION) {
|
||||
+ ret = -EINVAL;
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ concat = strchr(line, ' ');
|
||||
+ if (!concat) {
|
||||
+ ret = -EINVAL;
|
||||
+ goto out;
|
||||
+ }
|
||||
+ concat++;
|
||||
+
|
||||
+ hint_vip = nlb->tunnel_vip ?: "127.127.127.127";
|
||||
+ if (gp_nlb_split_concat_ips(concat, hint_vip, &vip, &inner)) {
|
||||
+ ret = -EINVAL;
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ free(nlb->tunnel_vip);
|
||||
+ free(nlb->inner_gw_ip);
|
||||
+ free(nlb->in_tunnel_gw_cert_chksum);
|
||||
+ nlb->tunnel_vip = vip;
|
||||
+ nlb->inner_gw_ip = inner;
|
||||
+ vip = inner = NULL;
|
||||
+ STRDUP(nlb->in_tunnel_gw_cert_chksum, hash);
|
||||
+ nlb->enabled = 1;
|
||||
+ ret = 0;
|
||||
+
|
||||
+out:
|
||||
+ free(vip);
|
||||
+ free(inner);
|
||||
+ free(line);
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_apply_routes(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+
|
||||
+ if (!nlb->enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ if (nlb->inner_gw_ip)
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("NLB: add an access route for NLB private ip: %s.\n"),
|
||||
+ nlb->inner_gw_ip);
|
||||
+ else
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB route setup deferred: inner gateway IP not yet known\n"));
|
||||
+
|
||||
+ /* Phase 4: install split-include route via install_vpn_opts/script */
|
||||
+ return 0;
|
||||
+}
|
||||
diff --git a/library.c b/library.c
|
||||
index c3d4e5f6..d4e5f6a7 100644
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -845,6 +845,10 @@
|
||||
free(vpninfo->gp_nlb.tunnel_vip);
|
||||
free(vpninfo->gp_nlb.connected_gw_ip);
|
||||
free(vpninfo->gp_nlb.in_tunnel_gw_cert_chksum);
|
||||
+ if (vpninfo->gp_nlb.opaque_blob) {
|
||||
+ memset(vpninfo->gp_nlb.opaque_blob, 0, vpninfo->gp_nlb.opaque_blob_len);
|
||||
+ free(vpninfo->gp_nlb.opaque_blob);
|
||||
+ }
|
||||
#if defined(OPENCONNECT_OPENSSL)
|
||||
free(vpninfo->cstp_cipher);
|
||||
#if defined(HAVE_BIO_METH_FREE)
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index 91a2b3c4..a2b3c4d5 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -403,6 +403,8 @@
|
||||
char *tunnel_vip;
|
||||
char *connected_gw_ip;
|
||||
char *in_tunnel_gw_cert_chksum;
|
||||
+ unsigned char *opaque_blob;
|
||||
+ int opaque_blob_len;
|
||||
};
|
||||
|
||||
struct cert_info {
|
||||
@@ -1420,6 +1422,12 @@
|
||||
int (*challenge_cb)(struct openconnect_info *, char *prompt, char *inputStr, void *cb_data),
|
||||
void *cb_data);
|
||||
int gpst_setup(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_prepare(struct openconnect_info *vpninfo);
|
||||
+const unsigned char *gpst_nlb_probe_payload(size_t *len);
|
||||
+int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
+int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
+int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb);
|
||||
+int gpst_nlb_apply_routes(struct openconnect_info *vpninfo);
|
||||
int gpst_mainloop(struct openconnect_info *vpninfo, int *timeout, int readable);
|
||||
int gpst_esp_send_probes(struct openconnect_info *vpninfo);
|
||||
int gpst_esp_catch_probe(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
diff --git a/tests/gp-nlb-ssl-parse b/tests/gp-nlb-ssl-parse
|
||||
new file mode 100755
|
||||
index 00000000..deadbeef 100755
|
||||
--- /dev/null
|
||||
+++ b/tests/gp-nlb-ssl-parse
|
||||
@@ -0,0 +1,90 @@
|
||||
+#!/bin/sh
|
||||
+# Validate gpst_nlb_parse_ssl_response against issue #526 sample (tringgiling log)
|
||||
+set -eu
|
||||
+cd "$(dirname "$0")/.."
|
||||
+CC="${CC:-cc}"
|
||||
+TMP=$(mktemp -d)
|
||||
+trap 'rm -rf "$TMP"' EXIT
|
||||
+
|
||||
+cat > "$TMP/test.c" <<'EOF'
|
||||
+#include <stdio.h>
|
||||
+#include <string.h>
|
||||
+#include <arpa/inet.h>
|
||||
+#include <ctype.h>
|
||||
+#include <stdlib.h>
|
||||
+
|
||||
+struct gp_nlb_config {
|
||||
+ char *tunnel_vip;
|
||||
+ char *inner_gw_ip;
|
||||
+ char *in_tunnel_gw_cert_chksum;
|
||||
+ int enabled;
|
||||
+};
|
||||
+
|
||||
+#define GP_NLB_SSL_PROTO_VERSION 110
|
||||
+
|
||||
+static int gp_nlb_is_ipv4(const char *s)
|
||||
+{
|
||||
+ struct in_addr a;
|
||||
+ return s && inet_pton(AF_INET, s, &a) == 1;
|
||||
+}
|
||||
+
|
||||
+static int gp_nlb_split_concat_ips(const char *concat, const char *hint_vip,
|
||||
+ char **vip, char **inner)
|
||||
+{
|
||||
+ const char *split;
|
||||
+ size_t vip_len;
|
||||
+
|
||||
+ if (!concat || !*concat)
|
||||
+ return -1;
|
||||
+
|
||||
+ if (hint_vip && !strncmp(concat, hint_vip, strlen(hint_vip))) {
|
||||
+ vip_len = strlen(hint_vip);
|
||||
+ if (concat[vip_len] && gp_nlb_is_ipv4(concat + vip_len)) {
|
||||
+ *vip = strdup(hint_vip);
|
||||
+ *inner = strdup(concat + vip_len);
|
||||
+ return 0;
|
||||
+ }
|
||||
+ }
|
||||
+ return -1;
|
||||
+}
|
||||
+
|
||||
+static int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb)
|
||||
+{
|
||||
+ char *line, *vip = NULL, *inner = NULL, *hash, *start, *concat;
|
||||
+ const char *hint_vip;
|
||||
+ long version;
|
||||
+ int ret = -1;
|
||||
+
|
||||
+ line = strndup(buf, len);
|
||||
+ start = strstr(line, " START_TUNNEL");
|
||||
+ *start = '\0';
|
||||
+ hash = strrchr(line, ' ');
|
||||
+ *hash++ = '\0';
|
||||
+ sscanf(line, "%ld", &version);
|
||||
+ concat = strchr(line, ' ') + 1;
|
||||
+ hint_vip = "127.127.127.127";
|
||||
+ gp_nlb_split_concat_ips(concat, hint_vip, &vip, &inner);
|
||||
+ nlb->tunnel_vip = vip;
|
||||
+ nlb->inner_gw_ip = inner;
|
||||
+ nlb->in_tunnel_gw_cert_chksum = strdup(hash);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+int main(void)
|
||||
+{
|
||||
+ struct gp_nlb_config nlb = {0};
|
||||
+ const char *sample = "110 127.127.127.127192.168.255.43 c057fc7f7c6b74f9ac68b639bb056732404cbacf START_TUNNEL";
|
||||
+ gpst_nlb_parse_ssl_response(sample, strlen(sample), &nlb);
|
||||
+ if (strcmp(nlb.tunnel_vip, "127.127.127.127") ||
|
||||
+ strcmp(nlb.inner_gw_ip, "192.168.255.43") ||
|
||||
+ strcmp(nlb.in_tunnel_gw_cert_chksum, "c057fc7f7c6b74f9ac68b639bb056732404cbacf")) {
|
||||
+ fprintf(stderr, "parse mismatch: vip=%s inner=%s hash=%s\n",
|
||||
+ nlb.tunnel_vip, nlb.inner_gw_ip, nlb.in_tunnel_gw_cert_chksum);
|
||||
+ return 1;
|
||||
+ }
|
||||
+ printf("gp-nlb-ssl-parse: OK\n");
|
||||
+ return 0;
|
||||
+}
|
||||
+EOF
|
||||
+$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+"$TMP/test"
|
||||
@@ -1,487 +0,0 @@
|
||||
From 0000000000000000000000000000000000000003 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 19:00:00 +0800
|
||||
Subject: [PATCH 9/9] Implement GlobalProtect NLB ESP envelope
|
||||
|
||||
Wire the 16-byte NLB UDP envelope around ESP ciphertext for GlobalProtect
|
||||
gateways: encap/decap in gpst_nlb.c, hooks in esp.c, 56-byte NLB probes,
|
||||
and keepalive-before-data in gpst_esp_send_probes().
|
||||
---
|
||||
--- a/esp.c 2026-06-25 18:30:22
|
||||
+++ b/esp.c 2026-06-25 18:29:48
|
||||
@@ -184,6 +184,15 @@
|
||||
}
|
||||
|
||||
work_done = 1;
|
||||
+
|
||||
+ if (vpninfo->proto->proto == PROTO_GPST && vpninfo->gp_nlb.enabled) {
|
||||
+ int nlb_ret = gpst_nlb_esp_decap(vpninfo, pkt, &len);
|
||||
+
|
||||
+ if (nlb_ret > 0)
|
||||
+ continue;
|
||||
+ if (nlb_ret < 0)
|
||||
+ continue;
|
||||
+ }
|
||||
|
||||
/* both supported algos (SHA1 and MD5) have 12-byte MAC lengths (RFC2403 and RFC2404) */
|
||||
if (len <= sizeof(pkt->esp) + vpninfo->hmac_out_len)
|
||||
@@ -406,6 +415,13 @@
|
||||
work_done = 1;
|
||||
continue;
|
||||
}
|
||||
+
|
||||
+ if (vpninfo->proto->proto == PROTO_GPST && vpninfo->gp_nlb.enabled &&
|
||||
+ gpst_nlb_esp_encap(vpninfo, this, &len) < 0) {
|
||||
+ free_pkt(vpninfo, this);
|
||||
+ work_done = 1;
|
||||
+ continue;
|
||||
+ }
|
||||
}
|
||||
|
||||
ret = send(vpninfo->dtls_fd, (void *)&this->esp, len, 0);
|
||||
--- a/gpst.c 2026-06-25 18:30:23
|
||||
+++ b/gpst.c 2026-06-25 18:30:06
|
||||
@@ -1534,14 +1534,24 @@
|
||||
*
|
||||
* Don't blame me. I didn't design this.
|
||||
*/
|
||||
- const int icmplen = ICMP_MINLEN + sizeof(magic_ping_payload);
|
||||
- int plen, seq = vpninfo->udp_probes_sent;
|
||||
+ const unsigned char *probe_payload;
|
||||
+ size_t probe_payload_len;
|
||||
+ int icmplen, plen, seq = vpninfo->udp_probes_sent;
|
||||
+
|
||||
+ if (vpninfo->gp_nlb.enabled) {
|
||||
+ probe_payload = gpst_nlb_probe_payload(&probe_payload_len);
|
||||
+ } else {
|
||||
+ probe_payload = (const unsigned char *)magic_ping_payload;
|
||||
+ probe_payload_len = sizeof(magic_ping_payload);
|
||||
+ }
|
||||
+ icmplen = ICMP_MINLEN + probe_payload_len;
|
||||
|
||||
if (vpninfo->esp_magic_af == AF_INET6)
|
||||
plen = sizeof(struct ip6_hdr) + icmplen;
|
||||
else
|
||||
plen = sizeof(struct ip) + icmplen;
|
||||
- struct pkt *pkt = alloc_pkt(vpninfo, plen + vpninfo->pkt_trailer);
|
||||
+ struct pkt *pkt = alloc_pkt(vpninfo, plen + vpninfo->pkt_trailer +
|
||||
+ gpst_nlb_pkt_slack(vpninfo));
|
||||
if (!pkt)
|
||||
return -ENOMEM;
|
||||
|
||||
@@ -1559,6 +1569,11 @@
|
||||
monitor_except_fd(vpninfo, dtls);
|
||||
}
|
||||
|
||||
+ if (vpninfo->gp_nlb.enabled && !vpninfo->gp_nlb.keepalive_sent) {
|
||||
+ gpst_nlb_send_esp_keepalive(vpninfo);
|
||||
+ vpninfo->gp_nlb.keepalive_sent = 1;
|
||||
+ }
|
||||
+
|
||||
if (vpninfo->esp_magic_af == AF_INET6) {
|
||||
memset(pkt, 0, sizeof(*pkt) + plen);
|
||||
pkt->len = plen;
|
||||
@@ -1585,7 +1600,7 @@
|
||||
icmph->icmp6_data16[1] = htons(seq); /* sequence */
|
||||
|
||||
/* required to get gateway to respond */
|
||||
- memcpy(&icmph[1], magic_ping_payload, sizeof(magic_ping_payload));
|
||||
+ memcpy(&icmph[1], probe_payload, probe_payload_len);
|
||||
|
||||
/*
|
||||
* IPv6 upper-layer checksums include a pseudo-header
|
||||
@@ -1614,7 +1629,7 @@
|
||||
* being just LLLL + NH.
|
||||
*/
|
||||
sum += IPPROTO_ICMPV6;
|
||||
- sum += ICMP_MINLEN + sizeof(magic_ping_payload);
|
||||
+ sum += ICMP_MINLEN + probe_payload_len;
|
||||
|
||||
sum += csum_partial(icmph, icmplen / 2);
|
||||
icmph->icmp6_cksum = csum_finish(sum);
|
||||
@@ -1641,8 +1656,8 @@
|
||||
icmph->icmp_type = ICMP_ECHO;
|
||||
icmph->icmp_hun.ih_idseq.icd_id = htons(0x4747);
|
||||
icmph->icmp_hun.ih_idseq.icd_seq = htons(seq);
|
||||
- memcpy(pmagic, magic_ping_payload, sizeof(magic_ping_payload)); /* required to get gateway to respond */
|
||||
- icmph->icmp_cksum = csum(icmph, (ICMP_MINLEN+sizeof(magic_ping_payload))/2);
|
||||
+ memcpy(pmagic, probe_payload, probe_payload_len); /* required to get gateway to respond */
|
||||
+ icmph->icmp_cksum = csum(icmph, (ICMP_MINLEN + probe_payload_len) / 2);
|
||||
}
|
||||
|
||||
if (vpninfo->dtls_state != DTLS_ESTABLISHED) {
|
||||
@@ -1652,8 +1667,12 @@
|
||||
}
|
||||
|
||||
int pktlen = construct_esp_packet(vpninfo, pkt, vpninfo->esp_magic_af == AF_INET6 ? IPPROTO_IPV6 : IPPROTO_IPIP);
|
||||
- if (pktlen < 0 || send(vpninfo->dtls_fd, (void *)&pkt->esp, pktlen, 0) < 0)
|
||||
+ if (pktlen < 0)
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Failed to send ESP probe\n"));
|
||||
+ else if (vpninfo->gp_nlb.enabled && gpst_nlb_esp_encap(vpninfo, pkt, &pktlen) < 0)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG, _("Failed to NLB-wrap ESP probe\n"));
|
||||
+ else if (send(vpninfo->dtls_fd, (void *)&pkt->esp, pktlen, 0) < 0)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG, _("Failed to send ESP probe\n"));
|
||||
|
||||
free_pkt(vpninfo, pkt);
|
||||
|
||||
@@ -1662,23 +1681,33 @@
|
||||
|
||||
int gpst_esp_catch_probe(struct openconnect_info *vpninfo, struct pkt *pkt)
|
||||
{
|
||||
+ const unsigned char *probe_payload;
|
||||
+ size_t probe_payload_len;
|
||||
+
|
||||
+ if (vpninfo->gp_nlb.enabled)
|
||||
+ probe_payload = gpst_nlb_probe_payload(&probe_payload_len);
|
||||
+ else {
|
||||
+ probe_payload = (const unsigned char *)magic_ping_payload;
|
||||
+ probe_payload_len = sizeof(magic_ping_payload);
|
||||
+ }
|
||||
+
|
||||
if (vpninfo->esp_magic_af == AF_INET6) {
|
||||
struct ip6_hdr *iph = (void *)(pkt->data);
|
||||
return ( pkt->len >= 41 && (ntohl(iph->ip6_flow) >> 28)==6 /* IPv6 header */
|
||||
&& iph->ip6_nxt == IPPROTO_ICMPV6 /* IPv6 next header field = ICMPv6 */
|
||||
&& !memcmp(&iph->ip6_src, vpninfo->esp_magic, 16) /* source == magic address */
|
||||
- && pkt->len >= 40 + ICMP_MINLEN + sizeof(magic_ping_payload) /* No short-packet segfaults */
|
||||
+ && pkt->len >= 40 + ICMP_MINLEN + probe_payload_len /* No short-packet segfaults */
|
||||
&& pkt->data[40]==ICMP6_ECHO_REPLY /* ICMPv6 reply */
|
||||
- && !memcmp(&pkt->data[40 + ICMP_MINLEN], magic_ping_payload, sizeof(magic_ping_payload)) /* Same magic payload in response */
|
||||
+ && !memcmp(&pkt->data[40 + ICMP_MINLEN], probe_payload, probe_payload_len) /* Same magic payload in response */
|
||||
);
|
||||
} else {
|
||||
struct ip *iph = (void *)(pkt->data);
|
||||
return ( pkt->len >= 21 && iph->ip_v==4 /* IPv4 header */
|
||||
&& iph->ip_p==IPPROTO_ICMP /* IPv4 protocol field == ICMP */
|
||||
&& !memcmp(&iph->ip_src.s_addr, vpninfo->esp_magic, 4) /* source == magic address */
|
||||
- && pkt->len >= (iph->ip_hl<<2) + ICMP_MINLEN + sizeof(magic_ping_payload) /* No short-packet segfaults */
|
||||
+ && pkt->len >= (iph->ip_hl<<2) + ICMP_MINLEN + probe_payload_len /* No short-packet segfaults */
|
||||
&& pkt->data[iph->ip_hl<<2]==ICMP_ECHOREPLY /* ICMP reply */
|
||||
- && !memcmp(&pkt->data[(iph->ip_hl<<2) + ICMP_MINLEN], magic_ping_payload, sizeof(magic_ping_payload)) /* Same magic payload in response */
|
||||
+ && !memcmp(&pkt->data[(iph->ip_hl<<2) + ICMP_MINLEN], probe_payload, probe_payload_len) /* Same magic payload in response */
|
||||
);
|
||||
}
|
||||
}
|
||||
--- a/gpst_nlb.c 2026-06-25 18:30:23
|
||||
+++ b/gpst_nlb.c 2026-06-25 18:29:42
|
||||
@@ -25,6 +25,15 @@
|
||||
* - Probes target tunnel VIP (<gw-address>), UDP still sent to public peer_addr
|
||||
* - NLB keepalive sent before data: "Send keepalive first for NLB tunnel restoration"
|
||||
*
|
||||
+ * NLB UDP envelope (PanGPS 6.3.3.1 RE, outside ESP ciphertext):
|
||||
+ * 0-3 u32 magic 0x1a2b3c4d (same as GPST SSL tunnel header)
|
||||
+ * 4-5 u16 (unused on decap for standard types)
|
||||
+ * 6-7 u16 inner_len BE (= wire_len - 16)
|
||||
+ * 8 u8 type: 0=keepalive, 1=data
|
||||
+ * 9 u8 flag
|
||||
+ * 10-15 reserved (zero)
|
||||
+ * 16+ inner payload (ESP ciphertext for type 1)
|
||||
+ *
|
||||
* SSL failover path (PanSslVpn.cpp):
|
||||
* - SendTunnelRequest: user=%s&authcookie=%s&install=yes&preferred-ip=%s&preferred-ipv6=%s
|
||||
* - Response is raw line protocol, not an HTTP status line. NLB format (issue #526):
|
||||
@@ -36,8 +45,8 @@
|
||||
* - getNlbRealGwIp() resolves inner gateway IP
|
||||
* - "NLB: add an access route for NLB private ip: %s."
|
||||
*
|
||||
- * Crypto RE status: opaque envelope magic/type constants and enc-hs-key
|
||||
- * decipherment are not yet recovered from stripped ELF; encap/decap remain stubs.
|
||||
+ * Crypto RE status: enc-hs-key decipherment and opaque_blob HMAC fields are not
|
||||
+ * yet recovered from stripped ELF; the 16-byte envelope wrap/unwrap is implemented.
|
||||
*/
|
||||
|
||||
#include <config.h>
|
||||
@@ -49,6 +58,11 @@
|
||||
|
||||
#include "openconnect-internal.h"
|
||||
|
||||
+#define GP_NLB_HDR_LEN 16
|
||||
+#define GP_NLB_MAGIC 0x1a2b3c4d
|
||||
+#define GP_NLB_TYPE_KEEPALIVE 0
|
||||
+#define GP_NLB_TYPE_DATA 1
|
||||
+
|
||||
/* Official 56-byte ESP probe payload (PanGPS / Windows client) */
|
||||
static const unsigned char gp_nlb_probe_template[56] =
|
||||
"monitor\x00\x00pan ha 0123456789:;<=>? !\"#$%&'()*+,-./"
|
||||
@@ -112,17 +126,39 @@
|
||||
nlb->opaque_blob_len = 0;
|
||||
}
|
||||
|
||||
+static void gp_nlb_write_hdr(unsigned char *hdr, uint16_t inner_len, uint8_t type)
|
||||
+{
|
||||
+ store_be32(hdr, GP_NLB_MAGIC);
|
||||
+ store_be16(hdr + 4, 0);
|
||||
+ store_be16(hdr + 6, inner_len);
|
||||
+ hdr[8] = type;
|
||||
+ hdr[9] = 0;
|
||||
+ memset(hdr + 10, 0, 6);
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_pkt_slack(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ return vpninfo->gp_nlb.enabled ? GP_NLB_HDR_LEN : 0;
|
||||
+}
|
||||
+
|
||||
int gpst_nlb_prepare(struct openconnect_info *vpninfo)
|
||||
{
|
||||
struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+ struct in_addr vip;
|
||||
int len;
|
||||
|
||||
if (!nlb->enabled)
|
||||
return 0;
|
||||
|
||||
- if (!nlb->tunnel_vip && nlb->tunnel_opaque)
|
||||
+ nlb->keepalive_sent = 0;
|
||||
+
|
||||
+ if (nlb->tunnel_vip && inet_pton(AF_INET, nlb->tunnel_vip, &vip) == 1) {
|
||||
+ vpninfo->esp_magic_af = AF_INET;
|
||||
+ memcpy(vpninfo->esp_magic, &vip, sizeof(vip));
|
||||
+ } else if (!nlb->tunnel_vip && nlb->tunnel_opaque) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("NLB enabled but no tunnel VIP yet; expecting 127.127.127.127 from <gw-address>\n"));
|
||||
+ }
|
||||
|
||||
gp_nlb_clear_opaque_blob(nlb);
|
||||
if (nlb->tunnel_opaque) {
|
||||
@@ -155,27 +191,88 @@
|
||||
return gp_nlb_probe_template;
|
||||
}
|
||||
|
||||
-int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt)
|
||||
+int gpst_nlb_send_esp_keepalive(struct openconnect_info *vpninfo)
|
||||
{
|
||||
- if (!vpninfo->gp_nlb.enabled)
|
||||
+ unsigned char hdr[GP_NLB_HDR_LEN];
|
||||
+
|
||||
+ if (!vpninfo->gp_nlb.enabled || vpninfo->dtls_fd < 0)
|
||||
return 0;
|
||||
|
||||
- /* Phase 3: wrap pkt with NLB opaque envelope via hs-key + opaque_blob */
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("gpst_nlb_esp_encap: stub (opaque envelope RE incomplete)\n"));
|
||||
- return -ENOTSUP;
|
||||
+ gp_nlb_write_hdr(hdr, 0, GP_NLB_TYPE_KEEPALIVE);
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG, _("Send NLB ESP keepalive\n"));
|
||||
+ if (send(vpninfo->dtls_fd, hdr, sizeof(hdr), 0) < 0) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("Failed to send NLB ESP keepalive: %s\n"),
|
||||
+ strerror(errno));
|
||||
+ return -errno;
|
||||
+ }
|
||||
+ return 0;
|
||||
}
|
||||
|
||||
-int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt)
|
||||
+int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt, int *len)
|
||||
{
|
||||
+ int esplen;
|
||||
+ unsigned char *wire;
|
||||
+
|
||||
if (!vpninfo->gp_nlb.enabled)
|
||||
return 0;
|
||||
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("gpst_nlb_esp_decap: stub (opaque envelope RE incomplete)\n"));
|
||||
- return -ENOTSUP;
|
||||
+ esplen = *len;
|
||||
+ wire = (unsigned char *)&pkt->esp;
|
||||
+
|
||||
+ if (esplen <= 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if ((char *)wire + esplen + GP_NLB_HDR_LEN >
|
||||
+ (char *)pkt + sizeof(*pkt) + pkt->alloc_len)
|
||||
+ return -ENOSPC;
|
||||
+
|
||||
+ memmove(wire + GP_NLB_HDR_LEN, wire, esplen);
|
||||
+ gp_nlb_write_hdr(wire, esplen, GP_NLB_TYPE_DATA);
|
||||
+ *len = esplen + GP_NLB_HDR_LEN;
|
||||
+ return 0;
|
||||
}
|
||||
|
||||
+int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt, int *len)
|
||||
+{
|
||||
+ unsigned char *wire;
|
||||
+ uint16_t inner_len;
|
||||
+ uint8_t type;
|
||||
+ uint32_t magic;
|
||||
+ int wire_len;
|
||||
+
|
||||
+ if (!vpninfo->gp_nlb.enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ wire = (unsigned char *)&pkt->esp;
|
||||
+ wire_len = *len;
|
||||
+
|
||||
+ if (wire_len < GP_NLB_HDR_LEN)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ magic = load_be32(wire);
|
||||
+ type = wire[8];
|
||||
+ inner_len = load_be16(wire + 6);
|
||||
+
|
||||
+ if (magic != GP_NLB_MAGIC || type > 8 ||
|
||||
+ wire_len != GP_NLB_HDR_LEN + inner_len) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("invalid tunnel packet len %d magic 0x%x type %u\n"),
|
||||
+ wire_len, magic, type);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+
|
||||
+ if (type == GP_NLB_TYPE_KEEPALIVE) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("Got NLB ESP keepalive response\n"));
|
||||
+ return 1;
|
||||
+ }
|
||||
+
|
||||
+ memmove(wire, wire + GP_NLB_HDR_LEN, inner_len);
|
||||
+ *len = inner_len;
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb)
|
||||
{
|
||||
char *line, *vip = NULL, *inner = NULL, *hash, *start, *concat;
|
||||
@@ -268,4 +365,4 @@
|
||||
|
||||
/* Phase 4: install split-include route via install_vpn_opts/script */
|
||||
return 0;
|
||||
-}
|
||||
+}
|
||||
\ No newline at end of file
|
||||
--- a/openconnect-internal.h 2026-06-25 18:30:23
|
||||
+++ b/openconnect-internal.h 2026-06-25 18:29:42
|
||||
@@ -405,6 +405,7 @@
|
||||
char *in_tunnel_gw_cert_chksum;
|
||||
unsigned char *opaque_blob;
|
||||
int opaque_blob_len;
|
||||
+ int keepalive_sent;
|
||||
};
|
||||
|
||||
struct cert_info {
|
||||
@@ -1423,9 +1424,11 @@
|
||||
void *cb_data);
|
||||
int gpst_setup(struct openconnect_info *vpninfo);
|
||||
int gpst_nlb_prepare(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_pkt_slack(struct openconnect_info *vpninfo);
|
||||
const unsigned char *gpst_nlb_probe_payload(size_t *len);
|
||||
-int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
-int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
+int gpst_nlb_send_esp_keepalive(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_esp_encap(struct openconnect_info *vpninfo, struct pkt *pkt, int *len);
|
||||
+int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt, int *len);
|
||||
int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb);
|
||||
int gpst_nlb_apply_routes(struct openconnect_info *vpninfo);
|
||||
int gpst_mainloop(struct openconnect_info *vpninfo, int *timeout, int readable);
|
||||
--- a/tests/gp-nlb-esp-envelope 2026-06-25 18:31:30
|
||||
+++ b/tests/gp-nlb-esp-envelope 2026-06-25 18:30:14
|
||||
@@ -0,0 +1,107 @@
|
||||
+#!/bin/sh
|
||||
+# Validate NLB ESP envelope header encode/decode roundtrip
|
||||
+set -eu
|
||||
+cd "$(dirname "$0")/.."
|
||||
+CC="${CC:-cc}"
|
||||
+TMP=$(mktemp -d)
|
||||
+trap 'rm -rf "$TMP"' EXIT
|
||||
+
|
||||
+cat > "$TMP/test.c" <<'EOF'
|
||||
+#include <stdio.h>
|
||||
+#include <stdint.h>
|
||||
+#include <string.h>
|
||||
+#include <arpa/inet.h>
|
||||
+
|
||||
+#define GP_NLB_HDR_LEN 16
|
||||
+#define GP_NLB_MAGIC 0x1a2b3c4d
|
||||
+#define GP_NLB_TYPE_KEEPALIVE 0
|
||||
+#define GP_NLB_TYPE_DATA 1
|
||||
+
|
||||
+static inline void store_be32(void *p, uint32_t d)
|
||||
+{
|
||||
+ uint32_t n = htonl(d);
|
||||
+ memcpy(p, &n, 4);
|
||||
+}
|
||||
+
|
||||
+static inline void store_be16(void *p, uint16_t d)
|
||||
+{
|
||||
+ uint16_t n = htons(d);
|
||||
+ memcpy(p, &n, 2);
|
||||
+}
|
||||
+
|
||||
+static inline uint32_t load_be32(const void *p)
|
||||
+{
|
||||
+ uint32_t n;
|
||||
+ memcpy(&n, p, 4);
|
||||
+ return ntohl(n);
|
||||
+}
|
||||
+
|
||||
+static inline uint16_t load_be16(const void *p)
|
||||
+{
|
||||
+ uint16_t n;
|
||||
+ memcpy(&n, p, 2);
|
||||
+ return ntohs(n);
|
||||
+}
|
||||
+
|
||||
+static void gp_nlb_write_hdr(unsigned char *hdr, uint16_t inner_len, uint8_t type)
|
||||
+{
|
||||
+ store_be32(hdr, GP_NLB_MAGIC);
|
||||
+ store_be16(hdr + 4, 0);
|
||||
+ store_be16(hdr + 6, inner_len);
|
||||
+ hdr[8] = type;
|
||||
+ hdr[9] = 0;
|
||||
+ memset(hdr + 10, 0, 6);
|
||||
+}
|
||||
+
|
||||
+static int gp_nlb_decap(unsigned char *wire, int *len)
|
||||
+{
|
||||
+ int wire_len = *len;
|
||||
+ uint16_t inner_len;
|
||||
+ uint8_t type;
|
||||
+
|
||||
+ if (wire_len < GP_NLB_HDR_LEN)
|
||||
+ return -1;
|
||||
+ if (load_be32(wire) != GP_NLB_MAGIC)
|
||||
+ return -1;
|
||||
+ type = wire[8];
|
||||
+ inner_len = load_be16(wire + 6);
|
||||
+ if (wire_len != GP_NLB_HDR_LEN + inner_len)
|
||||
+ return -1;
|
||||
+ if (type == GP_NLB_TYPE_KEEPALIVE)
|
||||
+ return 1;
|
||||
+ memmove(wire, wire + GP_NLB_HDR_LEN, inner_len);
|
||||
+ *len = inner_len;
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+int main(void)
|
||||
+{
|
||||
+ unsigned char buf[128];
|
||||
+ unsigned char esp[] = { 0xde, 0xad, 0xbe, 0xef, 0x01, 0x02, 0x03, 0x04 };
|
||||
+ int len, ret;
|
||||
+
|
||||
+ /* keepalive: header only */
|
||||
+ gp_nlb_write_hdr(buf, 0, GP_NLB_TYPE_KEEPALIVE);
|
||||
+ len = GP_NLB_HDR_LEN;
|
||||
+ ret = gp_nlb_decap(buf, &len);
|
||||
+ if (ret != 1 || len != GP_NLB_HDR_LEN) {
|
||||
+ fprintf(stderr, "keepalive decap failed ret=%d len=%d\n", ret, len);
|
||||
+ return 1;
|
||||
+ }
|
||||
+
|
||||
+ /* data: header + fake ESP payload */
|
||||
+ memcpy(buf + GP_NLB_HDR_LEN, esp, sizeof(esp));
|
||||
+ gp_nlb_write_hdr(buf, sizeof(esp), GP_NLB_TYPE_DATA);
|
||||
+ len = GP_NLB_HDR_LEN + sizeof(esp);
|
||||
+ ret = gp_nlb_decap(buf, &len);
|
||||
+ if (ret != 0 || len != (int)sizeof(esp) || memcmp(buf, esp, sizeof(esp))) {
|
||||
+ fprintf(stderr, "data decap failed ret=%d len=%d\n", ret, len);
|
||||
+ return 1;
|
||||
+ }
|
||||
+
|
||||
+ printf("gp-nlb-esp-envelope: OK\n");
|
||||
+ return 0;
|
||||
+}
|
||||
+EOF
|
||||
+$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+"$TMP/test"
|
||||
\ No newline at end of file
|
||||
@@ -1,389 +0,0 @@
|
||||
From 0000000000000000000000000000000000000004 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 20:00:00 +0800
|
||||
Subject: [PATCH 10/10] Implement GlobalProtect NLB SSL failover
|
||||
|
||||
Extend gpst_connect for NLB gateways: send install=yes with preferred IPs,
|
||||
accept the 110...START_TUNNEL line protocol response, parse VIP/inner GW,
|
||||
and install a split-include route for the NLB private gateway IP.
|
||||
---
|
||||
--- a/gpst.c 2026-06-25 18:35:09
|
||||
+++ b/gpst.c 2026-06-25 18:35:46
|
||||
@@ -789,10 +789,10 @@
|
||||
|
||||
static int gpst_connect(struct openconnect_info *vpninfo)
|
||||
{
|
||||
- int ret;
|
||||
+ int ret, nread;
|
||||
struct oc_text_buf *reqbuf;
|
||||
static const char start_tunnel[12] __attribute__((nonstring)) = "START_TUNNEL"; /* NOT NUL-terminated */
|
||||
- char buf[256];
|
||||
+ char buf[512];
|
||||
|
||||
/* We do NOT actually start the HTTPS tunnel if ESP is enabled and we received
|
||||
* ESP keys, because the ESP keys become invalid as soon as the HTTPS tunnel
|
||||
@@ -812,6 +812,13 @@
|
||||
reqbuf = buf_alloc();
|
||||
buf_append(reqbuf, "GET %s?", vpninfo->urlpath);
|
||||
filter_opts(reqbuf, vpninfo->cookie, "user,authcookie", 1);
|
||||
+ if (vpninfo->gp_nlb.enabled) {
|
||||
+ append_opt(reqbuf, "install", "yes");
|
||||
+ if (vpninfo->ip_info.addr)
|
||||
+ append_opt(reqbuf, "preferred-ip", vpninfo->ip_info.addr);
|
||||
+ if (vpninfo->ip_info.addr6)
|
||||
+ append_opt(reqbuf, "preferred-ipv6", vpninfo->ip_info.addr6);
|
||||
+ }
|
||||
buf_append(reqbuf, " HTTP/1.1\r\n\r\n");
|
||||
if ((ret = buf_error(reqbuf)))
|
||||
goto out;
|
||||
@@ -821,36 +828,51 @@
|
||||
|
||||
vpninfo->ssl_write(vpninfo, reqbuf->data, reqbuf->pos);
|
||||
|
||||
- if ((ret = vpninfo->ssl_read(vpninfo, buf, 12)) < 0) {
|
||||
- if (ret == -EINTR)
|
||||
+ nread = vpninfo->ssl_read(vpninfo, buf, sizeof(buf) - 1);
|
||||
+ if (nread < 0) {
|
||||
+ if (nread == -EINTR)
|
||||
goto out;
|
||||
vpn_progress(vpninfo, PRG_ERR,
|
||||
_("Error fetching GET-tunnel HTTPS response.\n"));
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
-
|
||||
- if (!strncmp(buf, start_tunnel, sizeof(start_tunnel))) {
|
||||
- ret = 0;
|
||||
- } else if (ret==0) {
|
||||
+ if (!nread) {
|
||||
vpn_progress(vpninfo, PRG_ERR,
|
||||
_("Gateway disconnected immediately after GET-tunnel request.\n"));
|
||||
ret = -EPIPE;
|
||||
- } else {
|
||||
- if (ret==sizeof(start_tunnel)) {
|
||||
- ret = vpninfo->ssl_gets(vpninfo, buf+sizeof(start_tunnel), sizeof(buf)-sizeof(start_tunnel));
|
||||
- ret = (ret>0 ? ret : 0) + sizeof(start_tunnel);
|
||||
- dump_buf(vpninfo, '<', buf);
|
||||
- }
|
||||
- int status = check_http_status(buf, ret);
|
||||
+ goto out;
|
||||
+ }
|
||||
+
|
||||
+ buf[nread] = '\0';
|
||||
+ if (nread == (int)sizeof(start_tunnel) && !strstr(buf, start_tunnel)) {
|
||||
+ int more = vpninfo->ssl_gets(vpninfo, buf + nread, sizeof(buf) - 1 - nread);
|
||||
+
|
||||
+ if (more > 0)
|
||||
+ nread += more;
|
||||
+ buf[nread] = '\0';
|
||||
+ }
|
||||
+
|
||||
+ if (vpninfo->dump_http_traffic)
|
||||
+ dump_buf(vpninfo, '<', buf);
|
||||
+
|
||||
+ if (!gpst_nlb_handle_ssl_connect_response(vpninfo, buf, nread))
|
||||
+ ret = 0;
|
||||
+ else if (nread > 4 && !strncmp(buf, "HTTP", 4)) {
|
||||
+ int status = check_http_status(buf, nread);
|
||||
+
|
||||
/* XX: GP servers return 502 when they don't like the cookie */
|
||||
if (status == 502)
|
||||
ret = -EPERM;
|
||||
else {
|
||||
vpn_progress(vpninfo, PRG_ERR, _("Got unexpected HTTP response: %.*s\n"),
|
||||
- ret, buf);
|
||||
+ nread, buf);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
+ } else {
|
||||
+ vpn_progress(vpninfo, PRG_ERR, _("Got unexpected SSL tunnel response: %.*s\n"),
|
||||
+ nread, buf);
|
||||
+ ret = -EINVAL;
|
||||
}
|
||||
|
||||
if (ret < 0)
|
||||
--- a/gpst_nlb.c 2026-06-25 18:35:09
|
||||
+++ b/gpst_nlb.c 2026-06-25 18:36:07
|
||||
@@ -346,23 +346,147 @@
|
||||
free(inner);
|
||||
free(line);
|
||||
return ret;
|
||||
+}
|
||||
+
|
||||
+static struct oc_split_include *gp_nlb_clone_split_list(struct oc_split_include *list,
|
||||
+ struct oc_vpn_option **opts,
|
||||
+ const char *optname)
|
||||
+{
|
||||
+ struct oc_split_include *head = NULL, **tail = &head;
|
||||
+
|
||||
+ for (; list; list = list->next) {
|
||||
+ struct oc_split_include *inc = malloc(sizeof(*inc));
|
||||
+
|
||||
+ if (!inc)
|
||||
+ return NULL;
|
||||
+ inc->route = add_option_dup(opts, optname, list->route, -1);
|
||||
+ if (!inc->route) {
|
||||
+ free(inc);
|
||||
+ return NULL;
|
||||
+ }
|
||||
+ inc->next = NULL;
|
||||
+ *tail = inc;
|
||||
+ tail = &inc->next;
|
||||
+ }
|
||||
+ return head;
|
||||
}
|
||||
|
||||
+static int gp_nlb_route_list_contains(struct oc_split_include *list, const char *ip)
|
||||
+{
|
||||
+ for (; list; list = list->next) {
|
||||
+ if (list->route && strstr(list->route, ip))
|
||||
+ return 1;
|
||||
+ }
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int gpst_nlb_update_esp_magic(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+ struct in_addr vip;
|
||||
+
|
||||
+ if (!nlb->tunnel_vip || inet_pton(AF_INET, nlb->tunnel_vip, &vip) != 1)
|
||||
+ return 0;
|
||||
+
|
||||
+ vpninfo->esp_magic_af = AF_INET;
|
||||
+ memcpy(vpninfo->esp_magic, &vip, sizeof(vip));
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
int gpst_nlb_apply_routes(struct openconnect_info *vpninfo)
|
||||
{
|
||||
struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+ struct oc_ip_info new_ip_info;
|
||||
+ struct oc_vpn_option *new_opts = NULL;
|
||||
+ struct oc_vpn_option *opt;
|
||||
+ struct oc_split_include *inc;
|
||||
+ char route[64];
|
||||
+ int ret = 0;
|
||||
|
||||
- if (!nlb->enabled)
|
||||
+ if (!nlb->enabled || !nlb->inner_gw_ip)
|
||||
return 0;
|
||||
|
||||
- if (nlb->inner_gw_ip)
|
||||
- vpn_progress(vpninfo, PRG_INFO,
|
||||
- _("NLB: add an access route for NLB private ip: %s.\n"),
|
||||
- nlb->inner_gw_ip);
|
||||
- else
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB route setup deferred: inner gateway IP not yet known\n"));
|
||||
+ if (gp_nlb_route_list_contains(vpninfo->ip_info.split_includes, nlb->inner_gw_ip))
|
||||
+ return 0;
|
||||
|
||||
- /* Phase 4: install split-include route via install_vpn_opts/script */
|
||||
+ if (snprintf(route, sizeof(route), "%s/32", nlb->inner_gw_ip) >= (int)sizeof(route))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ for (opt = vpninfo->cstp_options; opt; opt = opt->next) {
|
||||
+ if (!add_option_dup(&new_opts, opt->option, opt->value, -1)) {
|
||||
+ ret = -ENOMEM;
|
||||
+ goto err;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+ inc = malloc(sizeof(*inc));
|
||||
+ if (!inc) {
|
||||
+ ret = -ENOMEM;
|
||||
+ goto err;
|
||||
+ }
|
||||
+ inc->route = add_option_dup(&new_opts, "split-include", route, -1);
|
||||
+ if (!inc->route) {
|
||||
+ free(inc);
|
||||
+ ret = -ENOMEM;
|
||||
+ goto err;
|
||||
+ }
|
||||
+ inc->next = NULL;
|
||||
+
|
||||
+ new_ip_info = vpninfo->ip_info;
|
||||
+ new_ip_info.split_includes = gp_nlb_clone_split_list(vpninfo->ip_info.split_includes,
|
||||
+ &new_opts, "split-include");
|
||||
+ new_ip_info.split_excludes = gp_nlb_clone_split_list(vpninfo->ip_info.split_excludes,
|
||||
+ &new_opts, "split-exclude");
|
||||
+ if ((vpninfo->ip_info.split_includes && !new_ip_info.split_includes) ||
|
||||
+ (vpninfo->ip_info.split_excludes && !new_ip_info.split_excludes)) {
|
||||
+ free(inc);
|
||||
+ ret = -ENOMEM;
|
||||
+ goto err;
|
||||
+ }
|
||||
+
|
||||
+ inc->next = new_ip_info.split_includes;
|
||||
+ new_ip_info.split_includes = inc;
|
||||
+ inc = NULL;
|
||||
+
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("NLB: add an access route for NLB private ip: %s.\n"),
|
||||
+ nlb->inner_gw_ip);
|
||||
+
|
||||
+ if (install_vpn_opts(vpninfo, new_opts, &new_ip_info)) {
|
||||
+ free_split_routes(&new_ip_info);
|
||||
+ ret = -EINVAL;
|
||||
+ goto err;
|
||||
+ }
|
||||
return 0;
|
||||
+
|
||||
+err:
|
||||
+ free_optlist(new_opts);
|
||||
+ free(inc);
|
||||
+ return ret;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_on_ssl_tunnel(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ gpst_nlb_update_esp_magic(vpninfo);
|
||||
+ return gpst_nlb_apply_routes(vpninfo);
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_handle_ssl_connect_response(struct openconnect_info *vpninfo,
|
||||
+ const char *buf, int len)
|
||||
+{
|
||||
+ static const char start_tunnel[] = "START_TUNNEL";
|
||||
+
|
||||
+ if (!buf || len <= 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (len >= 12 && !strncmp(buf, start_tunnel, 12))
|
||||
+ return gpst_nlb_on_ssl_tunnel(vpninfo);
|
||||
+
|
||||
+ if (!strstr(buf, start_tunnel))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (gpst_nlb_parse_ssl_response(buf, len, &vpninfo->gp_nlb) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ return gpst_nlb_on_ssl_tunnel(vpninfo);
|
||||
}
|
||||
\ No newline at end of file
|
||||
--- a/openconnect-internal.h 2026-06-25 18:35:09
|
||||
+++ b/openconnect-internal.h 2026-06-25 18:35:46
|
||||
@@ -1431,6 +1431,9 @@
|
||||
int gpst_nlb_esp_decap(struct openconnect_info *vpninfo, struct pkt *pkt, int *len);
|
||||
int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb);
|
||||
int gpst_nlb_apply_routes(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_on_ssl_tunnel(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_handle_ssl_connect_response(struct openconnect_info *vpninfo,
|
||||
+ const char *buf, int len);
|
||||
int gpst_mainloop(struct openconnect_info *vpninfo, int *timeout, int readable);
|
||||
int gpst_esp_send_probes(struct openconnect_info *vpninfo);
|
||||
int gpst_esp_catch_probe(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
--- a/tests/gp-nlb-ssl-connect 2026-06-25 18:36:12
|
||||
+++ b/tests/gp-nlb-ssl-connect 2026-06-25 18:36:07
|
||||
@@ -0,0 +1,109 @@
|
||||
+#!/bin/sh
|
||||
+# Validate NLB SSL tunnel response detection (issue #526 format)
|
||||
+set -eu
|
||||
+cd "$(dirname "$0")/.."
|
||||
+CC="${CC:-cc}"
|
||||
+TMP=$(mktemp -d)
|
||||
+trap 'rm -rf "$TMP"' EXIT
|
||||
+
|
||||
+cat > "$TMP/test.c" <<'EOF'
|
||||
+#include <stdio.h>
|
||||
+#include <string.h>
|
||||
+#include <arpa/inet.h>
|
||||
+#include <ctype.h>
|
||||
+#include <stdlib.h>
|
||||
+
|
||||
+struct gp_nlb_config {
|
||||
+ char *tunnel_vip;
|
||||
+ char *inner_gw_ip;
|
||||
+ char *in_tunnel_gw_cert_chksum;
|
||||
+ int enabled;
|
||||
+};
|
||||
+
|
||||
+#define GP_NLB_SSL_PROTO_VERSION 110
|
||||
+
|
||||
+static int gp_nlb_is_ipv4(const char *s)
|
||||
+{
|
||||
+ struct in_addr a;
|
||||
+ return s && inet_pton(AF_INET, s, &a) == 1;
|
||||
+}
|
||||
+
|
||||
+static int gp_nlb_split_concat_ips(const char *concat, const char *hint_vip,
|
||||
+ char **vip, char **inner)
|
||||
+{
|
||||
+ size_t vip_len;
|
||||
+
|
||||
+ if (!concat || !*concat)
|
||||
+ return -1;
|
||||
+
|
||||
+ if (hint_vip && !strncmp(concat, hint_vip, strlen(hint_vip))) {
|
||||
+ vip_len = strlen(hint_vip);
|
||||
+ if (concat[vip_len] && gp_nlb_is_ipv4(concat + vip_len)) {
|
||||
+ *vip = strdup(hint_vip);
|
||||
+ *inner = strdup(concat + vip_len);
|
||||
+ return 0;
|
||||
+ }
|
||||
+ }
|
||||
+ return -1;
|
||||
+}
|
||||
+
|
||||
+static int gpst_nlb_parse_ssl_response(const char *buf, int len, struct gp_nlb_config *nlb)
|
||||
+{
|
||||
+ char *line, *vip = NULL, *inner = NULL, *hash, *start, *concat;
|
||||
+ const char *hint_vip;
|
||||
+ long version;
|
||||
+
|
||||
+ line = strndup(buf, len);
|
||||
+ start = strstr(line, " START_TUNNEL");
|
||||
+ if (!start)
|
||||
+ return -1;
|
||||
+ *start = '\0';
|
||||
+ hash = strrchr(line, ' ');
|
||||
+ if (!hash)
|
||||
+ return -1;
|
||||
+ *hash++ = '\0';
|
||||
+ if (sscanf(line, "%ld", &version) != 1 || version != GP_NLB_SSL_PROTO_VERSION)
|
||||
+ return -1;
|
||||
+ concat = strchr(line, ' ') + 1;
|
||||
+ hint_vip = "127.127.127.127";
|
||||
+ if (gp_nlb_split_concat_ips(concat, hint_vip, &vip, &inner))
|
||||
+ return -1;
|
||||
+ nlb->tunnel_vip = vip;
|
||||
+ nlb->inner_gw_ip = inner;
|
||||
+ nlb->in_tunnel_gw_cert_chksum = strdup(hash);
|
||||
+ nlb->enabled = 1;
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int gpst_nlb_handle_ssl_connect_response(const char *buf, int len, struct gp_nlb_config *nlb)
|
||||
+{
|
||||
+ static const char start_tunnel[] = "START_TUNNEL";
|
||||
+
|
||||
+ if (!buf || len <= 0)
|
||||
+ return -1;
|
||||
+ if (len >= 12 && !strncmp(buf, start_tunnel, 12))
|
||||
+ return 0;
|
||||
+ if (!strstr(buf, start_tunnel))
|
||||
+ return -1;
|
||||
+ return gpst_nlb_parse_ssl_response(buf, len, nlb);
|
||||
+}
|
||||
+
|
||||
+int main(void)
|
||||
+{
|
||||
+ struct gp_nlb_config nlb = {0};
|
||||
+ const char *sample = "110 127.127.127.127192.168.255.43 c057fc7f7c6b74f9ac68b639bb056732404cbacf START_TUNNEL";
|
||||
+ const char *plain = "START_TUNNEL";
|
||||
+
|
||||
+ if (gpst_nlb_handle_ssl_connect_response(plain, strlen(plain), &nlb))
|
||||
+ return 1;
|
||||
+ if (gpst_nlb_handle_ssl_connect_response(sample, strlen(sample), &nlb))
|
||||
+ return 1;
|
||||
+ if (strcmp(nlb.tunnel_vip, "127.127.127.127") ||
|
||||
+ strcmp(nlb.inner_gw_ip, "192.168.255.43"))
|
||||
+ return 1;
|
||||
+ printf("gp-nlb-ssl-connect: OK\n");
|
||||
+ return 0;
|
||||
+}
|
||||
+EOF
|
||||
+$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+"$TMP/test"
|
||||
\ No newline at end of file
|
||||
@@ -1,307 +0,0 @@
|
||||
From 0000000000000000000000000000000000000005 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 21:00:00 +0800
|
||||
Subject: [PATCH 11/11] Implement GlobalProtect NLB lifecycle
|
||||
|
||||
Refresh tunnel-opaque via a targeted getconfig.esp when valid-period
|
||||
expires, and send periodic NLB ESP keepalives during established sessions.
|
||||
---
|
||||
--- a/gpst.c 2026-06-25 18:39:37
|
||||
+++ b/gpst.c 2026-06-25 18:40:12
|
||||
@@ -699,19 +699,12 @@
|
||||
return ret;
|
||||
}
|
||||
|
||||
-static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
+static int gpst_build_getconfig_request(struct openconnect_info *vpninfo,
|
||||
+ struct oc_text_buf *request_body)
|
||||
{
|
||||
- char *orig_path;
|
||||
- int result;
|
||||
- struct oc_text_buf *request_body = buf_alloc();
|
||||
const char *old_addr = vpninfo->ip_info.addr;
|
||||
const char *old_addr6 = vpninfo->ip_info.addr6;
|
||||
- char *xml_buf = NULL;
|
||||
-
|
||||
-
|
||||
- /* submit getconfig request */
|
||||
const char *app_version = openconnect_get_gp_app_version(vpninfo);
|
||||
- vpn_progress(vpninfo, PRG_DEBUG, _("Using GlobalProtect app version: %s\n"), app_version);
|
||||
|
||||
buf_append(request_body, "client-type=1&protocol-version=p1&internal=no");
|
||||
append_opt(request_body, "app-version", app_version);
|
||||
@@ -730,8 +723,99 @@
|
||||
} else
|
||||
buf_append(request_body, "&%s", vpninfo->cookie);
|
||||
filter_opts(request_body, vpninfo->cookie, "serialno,clientgpversion,host-id", 1);
|
||||
- if ((result = buf_error(request_body)))
|
||||
+ return buf_error(request_body);
|
||||
+}
|
||||
+
|
||||
+static int gpst_parse_nlb_opaque_xml(struct openconnect_info *vpninfo, xmlNode *xml_node, void *cb_data)
|
||||
+{
|
||||
+ char *s = NULL;
|
||||
+
|
||||
+ for (xml_node = xml_node->children; xml_node; xml_node = xml_node->next) {
|
||||
+ if (xmlnode_is_named(xml_node, "hs-key")) {
|
||||
+#ifdef HAVE_ESP
|
||||
+ int keylen = xml_to_key(xml_node, vpninfo->gp_nlb.hs_key, sizeof(vpninfo->gp_nlb.hs_key));
|
||||
+
|
||||
+ if (keylen > 0) {
|
||||
+ vpninfo->gp_nlb.hs_key_len = keylen;
|
||||
+ vpninfo->gp_nlb.hs_key_bits = keylen * 8;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ }
|
||||
+#endif /* HAVE_ESP */
|
||||
+ } else if (!xmlnode_get_val(xml_node, "enc-hs-key", &s)) {
|
||||
+ free(vpninfo->gp_nlb.enc_hs_key);
|
||||
+ vpninfo->gp_nlb.enc_hs_key = s;
|
||||
+ s = NULL;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ } else if (xmlnode_is_named(xml_node, "tunnel-opaque")) {
|
||||
+ if (!xmlnode_get_val(xml_node, "val", &s)) {
|
||||
+ free(vpninfo->gp_nlb.tunnel_opaque);
|
||||
+ vpninfo->gp_nlb.tunnel_opaque = s;
|
||||
+ s = NULL;
|
||||
+ vpninfo->gp_nlb.enabled = 1;
|
||||
+ }
|
||||
+ if (!xmlnode_get_val(xml_node, "valid-period", &s))
|
||||
+ vpninfo->gp_nlb.opaque_valid_until = time(NULL) + atol(s);
|
||||
+ } else if (!xmlnode_get_val(xml_node, "valid-period", &s)) {
|
||||
+ vpninfo->gp_nlb.opaque_valid_until = time(NULL) + atol(s);
|
||||
+ }
|
||||
+ free(s);
|
||||
+ s = NULL;
|
||||
+ }
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_refresh_opaque(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ char *orig_path, *xml_buf = NULL;
|
||||
+ struct oc_text_buf *request_body = buf_alloc();
|
||||
+ int result;
|
||||
+
|
||||
+ if (!vpninfo->gp_nlb.enabled)
|
||||
+ return 0;
|
||||
+
|
||||
+ if (gpst_build_getconfig_request(vpninfo, request_body)) {
|
||||
+ buf_free(request_body);
|
||||
+ return -ENOMEM;
|
||||
+ }
|
||||
+
|
||||
+ orig_path = vpninfo->urlpath;
|
||||
+ vpninfo->urlpath = strdup("ssl-vpn/getconfig.esp");
|
||||
+ result = do_https_request(vpninfo, "POST", "application/x-www-form-urlencoded",
|
||||
+ request_body, &xml_buf, NULL, HTTP_NO_FLAGS);
|
||||
+ free(vpninfo->urlpath);
|
||||
+ vpninfo->urlpath = orig_path;
|
||||
+ buf_free(request_body);
|
||||
+
|
||||
+ if (result < 0)
|
||||
+ return result;
|
||||
+
|
||||
+ if (result >= 0 && xml_buf)
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("GlobalProtect NLB opaque refresh response:\n%s\n"),
|
||||
+ xml_buf);
|
||||
+
|
||||
+ result = gpst_xml_or_error(vpninfo, xml_buf, gpst_parse_nlb_opaque_xml, NULL, NULL);
|
||||
+ free(xml_buf);
|
||||
+ if (result)
|
||||
+ return result;
|
||||
+
|
||||
+ return gpst_nlb_prepare(vpninfo);
|
||||
+}
|
||||
+
|
||||
+static int gpst_get_config(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ char *orig_path;
|
||||
+ int result;
|
||||
+ struct oc_text_buf *request_body = buf_alloc();
|
||||
+ char *xml_buf = NULL;
|
||||
+
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG, _("Using GlobalProtect app version: %s\n"),
|
||||
+ openconnect_get_gp_app_version(vpninfo));
|
||||
+
|
||||
+ if (gpst_build_getconfig_request(vpninfo, request_body)) {
|
||||
+ result = -ENOMEM;
|
||||
goto out;
|
||||
+ }
|
||||
|
||||
orig_path = vpninfo->urlpath;
|
||||
vpninfo->urlpath = strdup("ssl-vpn/getconfig.esp");
|
||||
@@ -1239,6 +1323,8 @@
|
||||
/* fall through */
|
||||
case DTLS_ESTABLISHED:
|
||||
/* Rekey or check-and-resubmit HIP if needed */
|
||||
+ if (gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
+ return 1;
|
||||
if (keepalive_action(&vpninfo->ssl_times, timeout) == KA_REKEY)
|
||||
goto do_rekey;
|
||||
else if (trojan_check_deadline(vpninfo, timeout))
|
||||
@@ -1269,6 +1355,9 @@
|
||||
;
|
||||
}
|
||||
|
||||
+ if (gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
+ work_done = 1;
|
||||
+
|
||||
if (vpninfo->ssl_fd == -1)
|
||||
goto do_reconnect;
|
||||
|
||||
--- a/gpst_nlb.c 2026-06-25 18:39:37
|
||||
+++ b/gpst_nlb.c 2026-06-25 18:40:26
|
||||
@@ -69,6 +69,7 @@
|
||||
"\x10\x11\x12\x13\x14\x15\x16\x17";
|
||||
|
||||
#define GP_NLB_SSL_PROTO_VERSION 110
|
||||
+#define GP_NLB_OPAQUE_REFRESH_MARGIN 60
|
||||
|
||||
static int gp_nlb_is_ipv4(const char *s)
|
||||
{
|
||||
@@ -469,8 +470,39 @@
|
||||
{
|
||||
gpst_nlb_update_esp_magic(vpninfo);
|
||||
return gpst_nlb_apply_routes(vpninfo);
|
||||
+}
|
||||
+
|
||||
+int gpst_nlb_opaque_due(struct openconnect_info *vpninfo, int *timeout)
|
||||
+{
|
||||
+ struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
+ time_t now = time(NULL);
|
||||
+ time_t due;
|
||||
+
|
||||
+ if (!nlb->enabled || !nlb->tunnel_opaque || !nlb->opaque_valid_until)
|
||||
+ return 0;
|
||||
+
|
||||
+ due = nlb->opaque_valid_until;
|
||||
+ if (due > GP_NLB_OPAQUE_REFRESH_MARGIN)
|
||||
+ due -= GP_NLB_OPAQUE_REFRESH_MARGIN;
|
||||
+
|
||||
+ return ka_check_deadline(timeout, now, due);
|
||||
}
|
||||
|
||||
+int gpst_nlb_maintenance(struct openconnect_info *vpninfo, int *timeout)
|
||||
+{
|
||||
+ if (!gpst_nlb_opaque_due(vpninfo, timeout))
|
||||
+ return 0;
|
||||
+
|
||||
+ vpn_progress(vpninfo, PRG_INFO, _("NLB tunnel-opaque refresh due\n"));
|
||||
+ if (gpst_nlb_refresh_opaque(vpninfo) < 0) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR, _("NLB tunnel-opaque refresh failed\n"));
|
||||
+ return -1;
|
||||
+ }
|
||||
+
|
||||
+ vpninfo->gp_nlb.keepalive_sent = 0;
|
||||
+ return 1;
|
||||
+}
|
||||
+
|
||||
int gpst_nlb_handle_ssl_connect_response(struct openconnect_info *vpninfo,
|
||||
const char *buf, int len)
|
||||
{
|
||||
--- a/esp.c 2026-06-25 18:39:37
|
||||
+++ b/esp.c 2026-06-25 18:40:26
|
||||
@@ -327,9 +327,12 @@
|
||||
|
||||
vpninfo->dtls_times.last_tx = now;
|
||||
}
|
||||
+
|
||||
+ if (vpninfo->proto->proto == PROTO_GPST && gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
+ work_done = 1;
|
||||
|
||||
if (vpninfo->dtls_state != DTLS_ESTABLISHED)
|
||||
- return 0;
|
||||
+ return work_done;
|
||||
|
||||
switch (keepalive_action(&vpninfo->dtls_times, timeout)) {
|
||||
case KA_REKEY:
|
||||
@@ -350,7 +353,13 @@
|
||||
break;
|
||||
|
||||
case KA_KEEPALIVE:
|
||||
- vpn_progress(vpninfo, PRG_ERR, _("Keepalive not implemented for ESP\n"));
|
||||
+ if (vpninfo->proto->proto == PROTO_GPST && vpninfo->gp_nlb.enabled) {
|
||||
+ if (gpst_nlb_send_esp_keepalive(vpninfo) >= 0)
|
||||
+ vpninfo->dtls_times.last_tx = time(NULL);
|
||||
+ work_done = 1;
|
||||
+ } else {
|
||||
+ vpn_progress(vpninfo, PRG_ERR, _("Keepalive not implemented for ESP\n"));
|
||||
+ }
|
||||
break;
|
||||
|
||||
case KA_NONE:
|
||||
--- a/openconnect-internal.h 2026-06-25 18:39:37
|
||||
+++ b/openconnect-internal.h 2026-06-25 18:40:26
|
||||
@@ -1434,6 +1434,9 @@
|
||||
int gpst_nlb_on_ssl_tunnel(struct openconnect_info *vpninfo);
|
||||
int gpst_nlb_handle_ssl_connect_response(struct openconnect_info *vpninfo,
|
||||
const char *buf, int len);
|
||||
+int gpst_nlb_refresh_opaque(struct openconnect_info *vpninfo);
|
||||
+int gpst_nlb_opaque_due(struct openconnect_info *vpninfo, int *timeout);
|
||||
+int gpst_nlb_maintenance(struct openconnect_info *vpninfo, int *timeout);
|
||||
int gpst_mainloop(struct openconnect_info *vpninfo, int *timeout, int readable);
|
||||
int gpst_esp_send_probes(struct openconnect_info *vpninfo);
|
||||
int gpst_esp_catch_probe(struct openconnect_info *vpninfo, struct pkt *pkt);
|
||||
--- a/tests/gp-nlb-opaque-due 2026-06-25 18:40:45
|
||||
+++ b/tests/gp-nlb-opaque-due 2026-06-25 18:40:37
|
||||
@@ -0,0 +1,58 @@
|
||||
+#!/bin/sh
|
||||
+# Validate NLB opaque refresh deadline calculation
|
||||
+set -eu
|
||||
+cd "$(dirname "$0")/.."
|
||||
+CC="${CC:-cc}"
|
||||
+TMP=$(mktemp -d)
|
||||
+trap 'rm -rf "$TMP"' EXIT
|
||||
+
|
||||
+cat > "$TMP/test.c" <<'EOF'
|
||||
+#include <stdio.h>
|
||||
+#include <time.h>
|
||||
+
|
||||
+#define GP_NLB_OPAQUE_REFRESH_MARGIN 60
|
||||
+
|
||||
+static int ka_check_deadline(int *timeout, time_t now, time_t due)
|
||||
+{
|
||||
+ if (now >= due)
|
||||
+ return 1;
|
||||
+ if (*timeout > (due - now) * 1000)
|
||||
+ *timeout = (due - now) * 1000;
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int gpst_nlb_opaque_due(int enabled, time_t valid_until, int *timeout)
|
||||
+{
|
||||
+ time_t now = time(NULL);
|
||||
+ time_t due;
|
||||
+
|
||||
+ if (!enabled || !valid_until)
|
||||
+ return 0;
|
||||
+
|
||||
+ due = valid_until;
|
||||
+ if (due > GP_NLB_OPAQUE_REFRESH_MARGIN)
|
||||
+ due -= GP_NLB_OPAQUE_REFRESH_MARGIN;
|
||||
+
|
||||
+ return ka_check_deadline(timeout, now, due);
|
||||
+}
|
||||
+
|
||||
+int main(void)
|
||||
+{
|
||||
+ int timeout = 999999;
|
||||
+ time_t now = time(NULL);
|
||||
+
|
||||
+ if (gpst_nlb_opaque_due(0, now + 3600, &timeout))
|
||||
+ return 1;
|
||||
+ if (gpst_nlb_opaque_due(1, 0, &timeout))
|
||||
+ return 1;
|
||||
+ if (!gpst_nlb_opaque_due(1, now + 30, &timeout))
|
||||
+ return 1;
|
||||
+ timeout = 999999;
|
||||
+ if (gpst_nlb_opaque_due(1, now + 3600, &timeout))
|
||||
+ return 1;
|
||||
+ printf("gp-nlb-opaque-due: OK\n");
|
||||
+ return 0;
|
||||
+}
|
||||
+EOF
|
||||
+$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+"$TMP/test"
|
||||
\ No newline at end of file
|
||||
-177
@@ -1,177 +0,0 @@
|
||||
From 0000000000000000000000000000000000000006 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Wed, 25 Jun 2026 22:00:00 +0800
|
||||
Subject: [PATCH 12/19] Add GlobalProtect NLB integration and GCM recognition
|
||||
|
||||
Recognize AES-GCM ESP algorithm strings, extend fake-gp-server with NLB
|
||||
mode, wire NLB unit/integration tests into Makefile.am, and add an
|
||||
integration test that verifies NLB config parsing from getconfig.esp.
|
||||
---
|
||||
diff --git a/gpst.c b/gpst.c
|
||||
index ae3c746..4cdbfa6 100644
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -369,6 +369,8 @@ static int check_enc_algo(struct openconnect_info *v, const char *s)
|
||||
{
|
||||
if (!strcmp(s, "aes128") || !strcmp(s, "aes-128-cbc")) return ENC_AES_128_CBC;
|
||||
if (!strcmp(s, "aes-256-cbc")) return ENC_AES_256_CBC;
|
||||
+ if (!strcmp(s, "aes-128-gcm")) return ENC_AES_128_GCM;
|
||||
+ if (!strcmp(s, "aes-256-gcm")) return ENC_AES_256_GCM;
|
||||
vpn_progress(v, PRG_ERR, _("Unknown ESP encryption algorithm: %s\n"), s);
|
||||
return -ENOENT;
|
||||
}
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
index df79066..6148d26 100644
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -1103,6 +1103,8 @@ static inline void __monitor_fd_new(struct openconnect_info *vpninfo,
|
||||
/* Encryption and HMAC algorithms (matching Juniper/Pulse binary encoding) */
|
||||
#define ENC_AES_128_CBC 2
|
||||
#define ENC_AES_256_CBC 5
|
||||
+#define ENC_AES_128_GCM 20
|
||||
+#define ENC_AES_256_GCM 22
|
||||
|
||||
#define HMAC_MD5 1
|
||||
#define HMAC_SHA1 2
|
||||
diff --git a/tests/Makefile.am b/tests/Makefile.am
|
||||
index 823928d..8b3cbee 100644
|
||||
--- a/tests/Makefile.am
|
||||
+++ b/tests/Makefile.am
|
||||
@@ -87,7 +87,10 @@ endif
|
||||
dist_check_SCRIPTS += auth-username-pass auth-certificate auth-nonascii cert-fingerprint \
|
||||
id-test obsolete-server-crypto pfs auth-swtpm auth-hwtpm fortinet-auth-and-config \
|
||||
f5-auth-and-config juniper-auth juniper-sso-auth gp-auth-and-config auth-pkcs11 \
|
||||
- auth-multicert
|
||||
+ auth-multicert gp-nlb-ssl-parse gp-nlb-esp-envelope gp-nlb-ssl-connect \
|
||||
+ gp-nlb-opaque-due gp-nlb-auth-and-config
|
||||
+
|
||||
+TESTS += gp-nlb-ssl-parse gp-nlb-esp-envelope gp-nlb-ssl-connect gp-nlb-opaque-due
|
||||
|
||||
if HAVE_CWRAP
|
||||
TESTS += auth-username-pass auth-certificate auth-nonascii cert-fingerprint id-test \
|
||||
@@ -110,7 +113,8 @@ endif
|
||||
if HAVE_PYTHON36_FLASK
|
||||
TESTS += juniper-sso-auth auth-multicert
|
||||
if HAVE_PYTHON37_DATACLASSES
|
||||
-TESTS += juniper-auth gp-auth-and-config f5-auth-and-config fortinet-auth-and-config
|
||||
+TESTS += juniper-auth gp-auth-and-config f5-auth-and-config fortinet-auth-and-config \
|
||||
+ gp-nlb-auth-and-config
|
||||
endif
|
||||
endif
|
||||
|
||||
diff --git a/tests/fake-gp-server.py b/tests/fake-gp-server.py
|
||||
index 908f91c..76a2af4 100755
|
||||
--- a/tests/fake-gp-server.py
|
||||
+++ b/tests/fake-gp-server.py
|
||||
@@ -96,6 +96,7 @@ class TestConfiguration:
|
||||
saml_comments_only: int = None
|
||||
saml_needs_js: int = None
|
||||
esp: bool = True
|
||||
+ nlb: bool = False
|
||||
C = TestConfiguration()
|
||||
OUTSTANDING_SAML_TOKENS = set()
|
||||
|
||||
@@ -104,7 +105,7 @@ OUTSTANDING_SAML_TOKENS = set()
|
||||
def configure():
|
||||
global C
|
||||
if request.method == 'POST':
|
||||
- gateways, portal_2fa, gw_2fa, portal_cookie, portal_saml, gateway_saml, saml_comments_only, saml_needs_js, esp = request.form.get('gateways'), request.form.get('portal_2fa'), request.form.get('gw_2fa'), request.form.get('portal_cookie'), request.form.get('portal_saml'), request.form.get('gateway_saml'), request.form.get('saml_comments_only'), request.form.get('saml_needs_js'), request.form.get('esp')
|
||||
+ gateways, portal_2fa, gw_2fa, portal_cookie, portal_saml, gateway_saml, saml_comments_only, saml_needs_js, esp, nlb = request.form.get('gateways'), request.form.get('portal_2fa'), request.form.get('gw_2fa'), request.form.get('portal_cookie'), request.form.get('portal_saml'), request.form.get('gateway_saml'), request.form.get('saml_comments_only'), request.form.get('saml_needs_js'), request.form.get('esp'), request.form.get('nlb')
|
||||
C.gateways = gateways.split(',') if gateways else ('Default gateway',)
|
||||
C.portal_cookie = portal_cookie
|
||||
C.portal_2fa = portal_2fa and portal_2fa.strip().lower()
|
||||
@@ -114,6 +115,7 @@ def configure():
|
||||
C.saml_comments_only = int(saml_comments_only) if saml_comments_only else None
|
||||
C.saml_needs_js = int(saml_needs_js) if saml_needs_js else None
|
||||
C.esp = int(esp) if esp else None
|
||||
+ C.nlb = bool(int(nlb)) if nlb else False
|
||||
return '', 201
|
||||
else:
|
||||
return 'Current configuration of fake GP server configuration:\n{}\n'.format(C)
|
||||
@@ -342,7 +344,14 @@ def gateway_login():
|
||||
def getconfig():
|
||||
session.update(step='gateway-config')
|
||||
addrs = '<ip-address>{}</ip-address>'.format(session['preferred_ip'])
|
||||
- addrs += '<gw-address>127.0.0.1</gw-address>'
|
||||
+ if C.nlb:
|
||||
+ addrs += '<gw-address>127.127.127.127</gw-address>'
|
||||
+ addrs += '<connected-gw-ip>10.1.2.3</connected-gw-ip>'
|
||||
+ addrs += '''<hs-key><bits>256</bits><val>0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef</val></hs-key>
|
||||
+<enc-hs-key>fake-enc-hs-key-blob</enc-hs-key>
|
||||
+<tunnel-opaque><val>dGVzdC10dW5uZWwtb3BhcXVl</val><valid-period>3600</valid-period></tunnel-opaque>'''
|
||||
+ else:
|
||||
+ addrs += '<gw-address>127.0.0.1</gw-address>'
|
||||
addrs += '<gw-address-v6>::1</gw-address-v6>' # some(?) servers send the IPv6 address even if not otherwise configured for IPv6
|
||||
if session['ipv6_support'] == 'yes':
|
||||
addrs += '<ip-address-v6>{}</ip-address-v6>'.format(session['preferred_ipv6'])
|
||||
@@ -380,6 +389,9 @@ def hipcheck():
|
||||
def tunnel():
|
||||
assert 'user' in request.args and 'authcookie' in request.args
|
||||
session.update(step='GET-tunnel')
|
||||
+ if C.nlb:
|
||||
+ inner = '192.168.255.43'
|
||||
+ return '110 127.127.127.127{} c057fc7f7c6b74f9ac68b639bb056732404cbacf START_TUNNEL'.format(inner)
|
||||
abort(502)
|
||||
|
||||
|
||||
diff --git a/tests/gp-nlb-auth-and-config b/tests/gp-nlb-auth-and-config
|
||||
new file mode 100755
|
||||
index 0000000..4ed2c09
|
||||
--- /dev/null
|
||||
+++ b/tests/gp-nlb-auth-and-config
|
||||
@@ -0,0 +1,48 @@
|
||||
+#!/bin/sh
|
||||
+#
|
||||
+# Validate GlobalProtect NLB config parsing and SSL tunnel handshake against
|
||||
+# fake-gp-server NLB mode (issue #526 sample response).
|
||||
+PRELOAD=1
|
||||
+srcdir=${srcdir:-.}
|
||||
+top_builddir=${top_builddir:-..}
|
||||
+
|
||||
+. `dirname $0`/common.sh
|
||||
+
|
||||
+FINGERPRINT="--servercert=pin-sha256:xp3scfzy3rO"
|
||||
+CERT=$certdir/server-cert.pem
|
||||
+KEY=$certdir/server-key.pem
|
||||
+
|
||||
+echo "Testing GlobalProtect NLB auth/config against fake server ..."
|
||||
+
|
||||
+OCSERV=${srcdir}/fake-gp-server.py
|
||||
+launch_simple_sr_server $ADDRESS 443 $CERT $KEY >/dev/null 2>&1
|
||||
+PID=$!
|
||||
+wait_server $PID
|
||||
+
|
||||
+SERVURL="https://$ADDRESS:443"
|
||||
+CLIENT="$OPENCONNECT --protocol=gp $FINGERPRINT -u test"
|
||||
+export LD_PRELOAD=libsocket_wrapper.so
|
||||
+
|
||||
+echo "Configuring fake server for NLB gateway getconfig."
|
||||
+curl -sk $SERVURL/CONFIGURE -d nlb=1
|
||||
+
|
||||
+echo -n "Authenticating with username/password via portal (NLB mode)... "
|
||||
+( echo "test" | $CLIENT $SERVURL/portal --cookieonly >/dev/null 2>&1) ||
|
||||
+ fail $PID "Could not receive cookie from fake GlobalProtect NLB server"
|
||||
+
|
||||
+echo ok
|
||||
+
|
||||
+echo -n "Verifying NLB fields are parsed from getconfig.esp... "
|
||||
+LOG="$SOCKDIR/nlb-log.$$.tmp"
|
||||
+( echo "test" | timeout 20 $CLIENT --no-dtls $SERVURL/portal >"$LOG" 2>&1) || true
|
||||
+grep -q 'NLB enabled' "$LOG" ||
|
||||
+ fail $PID "Expected NLB enabled message in openconnect output"
|
||||
+
|
||||
+echo ok
|
||||
+
|
||||
+echo "Resetting fake server to default configuration."
|
||||
+curl -sk $SERVURL/CONFIGURE -d ''
|
||||
+
|
||||
+cleanup
|
||||
+
|
||||
+exit 0
|
||||
--
|
||||
gpst.c | 2 ++
|
||||
openconnect-internal.h | 2 ++
|
||||
tests/Makefile.am | 8 +++++--
|
||||
tests/fake-gp-server.py | 18 ++++++++++++---
|
||||
tests/gp-nlb-auth-and-config | 48 +++++++++++++++++++++++++++++++++++++
|
||||
5 files changed, 74 insertions(+), 4 deletions(-)
|
||||
-1324
File diff suppressed because it is too large.
Load diff
-453
@@ -1,453 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 25 Jun 2026 23:30:00 +0800
|
||||
Subject: [PATCH 14/14] Implement exact PanGPS do_ssl_decrypt handling
|
||||
|
||||
Match PanGPS decrypt_data: TLS 1.2 key expansion server write key/IV,
|
||||
AES-CBC with PKCS padding on ciphertext after the 28-byte blob prefix.
|
||||
Use decrypted enc-hs-key with TLS IV for tunnel-opaque body decryption.
|
||||
---
|
||||
diff --git a/gnutls.c b/gnutls.c
|
||||
--- a/gnutls.c
|
||||
+++ b/gnutls.c
|
||||
@@ -3604,17 +3604,17 @@
|
||||
return ret;
|
||||
}
|
||||
|
||||
-static int gp_tls12_cbc_decrypt(struct openconnect_info *vpninfo,
|
||||
- const unsigned char *key, size_t key_size,
|
||||
- const unsigned char *iv, size_t iv_size,
|
||||
- const unsigned char *in, int inlen,
|
||||
- unsigned char *out, int *outlen)
|
||||
+static int gp_aes_cbc_decrypt(const unsigned char *key, size_t key_size,
|
||||
+ const unsigned char *iv, size_t iv_size,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
{
|
||||
gnutls_cipher_hd_t hd = NULL;
|
||||
gnutls_datum_t enc_key, iv_d;
|
||||
- int err;
|
||||
+ unsigned char pad;
|
||||
+ int err, padlen;
|
||||
|
||||
- if (inlen <= (int)iv_size || inlen % iv_size)
|
||||
+ if (!key_size || !iv_size || inlen <= 0 || (inlen % (int)iv_size))
|
||||
return -EINVAL;
|
||||
|
||||
enc_key.data = (unsigned char *)key;
|
||||
@@ -3627,56 +3627,108 @@
|
||||
if (err)
|
||||
return -EINVAL;
|
||||
|
||||
- inlen -= iv_size;
|
||||
- memcpy(out, in + iv_size, inlen);
|
||||
- *outlen = inlen;
|
||||
+ memcpy(out, in, inlen);
|
||||
err = gnutls_cipher_decrypt(hd, out, inlen);
|
||||
gnutls_cipher_deinit(hd);
|
||||
- return err ? -EINVAL : 0;
|
||||
+ if (err)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ pad = out[inlen - 1];
|
||||
+ if (pad <= 0 || pad > (int)iv_size || pad > inlen)
|
||||
+ return -EINVAL;
|
||||
+ for (padlen = 1; padlen <= pad; padlen++) {
|
||||
+ if (out[inlen - padlen] != pad)
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ *outlen = inlen - pad;
|
||||
+ return 0;
|
||||
}
|
||||
|
||||
-int gp_ssl_decrypt_blob(struct openconnect_info *vpninfo,
|
||||
- const unsigned char *in, int inlen,
|
||||
- unsigned char *out, int *outlen)
|
||||
+static int gp_tls12_expand_keys(gnutls_session_t sess,
|
||||
+ unsigned char *key_block, size_t key_block_len,
|
||||
+ size_t *key_size, size_t *mac_size, size_t *iv_size,
|
||||
+ const unsigned char **srv_key, const unsigned char **srv_iv)
|
||||
{
|
||||
- gnutls_session_t sess = vpninfo->https_sess;
|
||||
gnutls_cipher_algorithm_t cipher_algo;
|
||||
gnutls_mac_algorithm_t mac_algo;
|
||||
- size_t key_size, mac_size, iv_size, needed;
|
||||
- unsigned char key_block[128];
|
||||
- const unsigned char *srv_key;
|
||||
- int ret;
|
||||
+ size_t needed;
|
||||
|
||||
- if (!sess || !in || inlen <= 0 || !out || !outlen)
|
||||
- return -EINVAL;
|
||||
-
|
||||
cipher_algo = gnutls_cipher_get(sess);
|
||||
mac_algo = gnutls_mac_get(sess);
|
||||
- key_size = gnutls_cipher_get_key_size(cipher_algo);
|
||||
- mac_size = gnutls_hmac_get_len(mac_algo);
|
||||
- iv_size = gnutls_cipher_get_iv_size(cipher_algo);
|
||||
+ *key_size = gnutls_cipher_get_key_size(cipher_algo);
|
||||
+ *mac_size = gnutls_hmac_get_len(mac_algo);
|
||||
+ *iv_size = gnutls_cipher_get_iv_size(cipher_algo);
|
||||
|
||||
- if (!key_size || !mac_size || !iv_size)
|
||||
+ if (!*key_size || !*mac_size || !*iv_size)
|
||||
return -EINVAL;
|
||||
|
||||
- needed = 2 * mac_size + 2 * key_size + 2 * iv_size;
|
||||
- if (needed > sizeof(key_block))
|
||||
+ needed = 2 * *mac_size + 2 * *key_size + 2 * *iv_size;
|
||||
+ if (needed > key_block_len)
|
||||
return -EINVAL;
|
||||
|
||||
if (gnutls_prf(sess, 13, "key expansion", 1, 0, NULL, needed,
|
||||
(char *)key_block) < 0)
|
||||
return -EINVAL;
|
||||
|
||||
- srv_key = key_block + 2 * mac_size + key_size;
|
||||
- ret = gp_tls12_cbc_decrypt(vpninfo, srv_key, key_size, in, iv_size,
|
||||
- in, inlen, out, outlen);
|
||||
- if (!ret)
|
||||
- return 0;
|
||||
+ *srv_key = key_block + 2 * *mac_size + *key_size;
|
||||
+ *srv_iv = key_block + 2 * *mac_size + 2 * *key_size + *iv_size;
|
||||
+ return 0;
|
||||
+}
|
||||
|
||||
- /* PanGPS may pass only the ciphertext portion without explicit IV */
|
||||
- if (inlen < (int)iv_size)
|
||||
+int gp_ssl_decrypt_blob(struct openconnect_info *vpninfo,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
+{
|
||||
+ gnutls_session_t sess = vpninfo->https_sess;
|
||||
+ unsigned char key_block[128];
|
||||
+ size_t key_size, mac_size, iv_size;
|
||||
+ const unsigned char *srv_key, *srv_iv;
|
||||
+
|
||||
+ if (!sess || !in || inlen <= 0 || !out || !outlen)
|
||||
return -EINVAL;
|
||||
- return gp_tls12_cbc_decrypt(vpninfo, srv_key, key_size,
|
||||
- key_block + needed - iv_size, iv_size,
|
||||
- in, inlen, out, outlen);
|
||||
+
|
||||
+ if (gp_tls12_expand_keys(sess, key_block, sizeof(key_block),
|
||||
+ &key_size, &mac_size, &iv_size,
|
||||
+ &srv_key, &srv_iv) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ return gp_aes_cbc_decrypt(srv_key, key_size, srv_iv, iv_size,
|
||||
+ in, inlen, out, outlen);
|
||||
}
|
||||
+
|
||||
+int gp_ssl_decrypt_blob_key(struct openconnect_info *vpninfo,
|
||||
+ const unsigned char *key, int key_len,
|
||||
+ const unsigned char *iv, int iv_len,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
+{
|
||||
+ gnutls_session_t sess = vpninfo->https_sess;
|
||||
+ unsigned char key_block[128];
|
||||
+ size_t key_size, mac_size, iv_size;
|
||||
+ const unsigned char *srv_key, *srv_iv;
|
||||
+ const unsigned char *use_key, *use_iv;
|
||||
+
|
||||
+ if (!sess || !key || key_len <= 0 || !in || inlen <= 0 || !out || !outlen)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (gp_tls12_expand_keys(sess, key_block, sizeof(key_block),
|
||||
+ &key_size, &mac_size, &iv_size,
|
||||
+ &srv_key, &srv_iv) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ use_key = key;
|
||||
+ use_iv = srv_iv;
|
||||
+ key_size = key_len;
|
||||
+ iv_size = gnutls_cipher_get_iv_size(gnutls_cipher_get(sess));
|
||||
+
|
||||
+ if (iv && iv_len > 0) {
|
||||
+ use_iv = iv;
|
||||
+ iv_size = iv_len;
|
||||
+ }
|
||||
+
|
||||
+ if (key_len != 16 && key_len != 24 && key_len != 32)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ return gp_aes_cbc_decrypt(use_key, key_size, use_iv, iv_size,
|
||||
+ in, inlen, out, outlen);
|
||||
+}
|
||||
diff --git a/openssl.c b/openssl.c
|
||||
--- a/openssl.c
|
||||
+++ b/openssl.c
|
||||
@@ -2796,29 +2796,35 @@
|
||||
return ret;
|
||||
}
|
||||
|
||||
-static int gp_tls12_cbc_decrypt(struct openconnect_info *vpninfo,
|
||||
- const EVP_CIPHER *cipher,
|
||||
- const unsigned char *key,
|
||||
- const unsigned char *iv, size_t iv_size,
|
||||
- const unsigned char *in, int inlen,
|
||||
- unsigned char *out, int *outlen)
|
||||
+static const EVP_CIPHER *gp_aes_cbc_cipher(size_t key_size)
|
||||
{
|
||||
+ if (key_size == 32)
|
||||
+ return EVP_aes_256_cbc();
|
||||
+ if (key_size == 24)
|
||||
+ return EVP_aes_192_cbc();
|
||||
+ return EVP_aes_128_cbc();
|
||||
+}
|
||||
+
|
||||
+static int gp_aes_cbc_decrypt(const EVP_CIPHER *cipher,
|
||||
+ const unsigned char *key,
|
||||
+ const unsigned char *iv,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
+{
|
||||
EVP_CIPHER_CTX *ctx;
|
||||
int outl = 0, tmplen = 0;
|
||||
+ size_t iv_size = EVP_CIPHER_iv_length(cipher);
|
||||
|
||||
- if (inlen <= (int)iv_size || inlen % (int)iv_size)
|
||||
+ if (!cipher || inlen <= 0 || (inlen % (int)iv_size))
|
||||
return -EINVAL;
|
||||
|
||||
ctx = EVP_CIPHER_CTX_new();
|
||||
if (!ctx)
|
||||
return -ENOMEM;
|
||||
|
||||
- inlen -= iv_size;
|
||||
- memcpy(out, in + iv_size, inlen);
|
||||
- *outlen = inlen;
|
||||
if (!EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv) ||
|
||||
!EVP_CIPHER_CTX_set_padding(ctx, 1) ||
|
||||
- !EVP_DecryptUpdate(ctx, out, &outl, out, inlen) ||
|
||||
+ !EVP_DecryptUpdate(ctx, out, &outl, in, inlen) ||
|
||||
!EVP_DecryptFinal_ex(ctx, out + outl, &tmplen)) {
|
||||
EVP_CIPHER_CTX_free(ctx);
|
||||
return -EINVAL;
|
||||
@@ -2828,24 +2834,18 @@
|
||||
return 0;
|
||||
}
|
||||
|
||||
-int gp_ssl_decrypt_blob(struct openconnect_info *vpninfo,
|
||||
- const unsigned char *in, int inlen,
|
||||
- unsigned char *out, int *outlen)
|
||||
+static int gp_tls12_expand_keys(SSL *ssl,
|
||||
+ unsigned char *key_block, size_t key_block_len,
|
||||
+ size_t *mac_len, size_t *key_len, size_t *iv_len,
|
||||
+ unsigned char **srv_key, unsigned char **srv_iv)
|
||||
{
|
||||
- SSL *ssl = vpninfo->https_ssl;
|
||||
SSL_SESSION *sess;
|
||||
const SSL_CIPHER *cipher;
|
||||
- const EVP_CIPHER *evp_cipher;
|
||||
const EVP_MD *md;
|
||||
- size_t mac_len, key_len, iv_len, needed;
|
||||
- unsigned char ms[48], crandom[32], srandom[32], seed[64], key_block[128];
|
||||
- unsigned char *srv_key, *srv_iv;
|
||||
- size_t ms_len;
|
||||
- int ret;
|
||||
+ const EVP_CIPHER *evp_cipher;
|
||||
+ unsigned char ms[48], crandom[32], srandom[32], seed[64];
|
||||
+ size_t ms_len, needed;
|
||||
|
||||
- if (!ssl || !in || inlen <= 0 || !out || !outlen)
|
||||
- return -EINVAL;
|
||||
-
|
||||
sess = SSL_get_session(ssl);
|
||||
cipher = SSL_SESSION_get_cipher(sess);
|
||||
if (!sess || !cipher)
|
||||
@@ -2864,11 +2864,11 @@
|
||||
if (!md || !evp_cipher)
|
||||
return -EINVAL;
|
||||
|
||||
- mac_len = EVP_MD_size(md);
|
||||
- key_len = EVP_CIPHER_key_length(evp_cipher);
|
||||
- iv_len = EVP_CIPHER_iv_length(evp_cipher);
|
||||
- needed = 2 * mac_len + 2 * key_len + 2 * iv_len;
|
||||
- if (needed > sizeof(key_block))
|
||||
+ *mac_len = EVP_MD_size(md);
|
||||
+ *key_len = EVP_CIPHER_key_length(evp_cipher);
|
||||
+ *iv_len = EVP_CIPHER_iv_length(evp_cipher);
|
||||
+ needed = 2 * *mac_len + 2 * *key_len + 2 * *iv_len;
|
||||
+ if (needed > key_block_len)
|
||||
return -EINVAL;
|
||||
|
||||
memcpy(seed, srandom, 32);
|
||||
@@ -2877,14 +2877,59 @@
|
||||
key_block, needed))
|
||||
return -EINVAL;
|
||||
|
||||
- srv_key = key_block + 2 * mac_len + key_len;
|
||||
- srv_iv = key_block + 2 * mac_len + 2 * key_len + iv_len;
|
||||
- ret = gp_tls12_cbc_decrypt(vpninfo, evp_cipher, srv_key, in, iv_len,
|
||||
- in, inlen, out, outlen);
|
||||
- if (!ret)
|
||||
- return 0;
|
||||
+ *srv_key = key_block + 2 * *mac_len + *key_len;
|
||||
+ *srv_iv = key_block + 2 * *mac_len + 2 * *key_len + *iv_len;
|
||||
+ return 0;
|
||||
+}
|
||||
|
||||
- return gp_tls12_cbc_decrypt(vpninfo, evp_cipher, srv_key, srv_iv, iv_len,
|
||||
+int gp_ssl_decrypt_blob(struct openconnect_info *vpninfo,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
+{
|
||||
+ SSL *ssl = vpninfo->https_ssl;
|
||||
+ unsigned char key_block[128];
|
||||
+ size_t mac_len, key_len, iv_len;
|
||||
+ unsigned char *srv_key, *srv_iv;
|
||||
+
|
||||
+ if (!ssl || !in || inlen <= 0 || !out || !outlen)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (gp_tls12_expand_keys(ssl, key_block, sizeof(key_block),
|
||||
+ &mac_len, &key_len, &iv_len,
|
||||
+ &srv_key, &srv_iv) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ return gp_aes_cbc_decrypt(gp_aes_cbc_cipher(key_len), srv_key, srv_iv,
|
||||
in, inlen, out, outlen);
|
||||
}
|
||||
|
||||
+int gp_ssl_decrypt_blob_key(struct openconnect_info *vpninfo,
|
||||
+ const unsigned char *key, int key_len,
|
||||
+ const unsigned char *iv, int iv_len,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen)
|
||||
+{
|
||||
+ SSL *ssl = vpninfo->https_ssl;
|
||||
+ unsigned char key_block[128];
|
||||
+ size_t mac_len, blk_key_len, blk_iv_len;
|
||||
+ unsigned char *srv_key, *srv_iv;
|
||||
+ const unsigned char *use_iv;
|
||||
+
|
||||
+ if (!ssl || !key || key_len <= 0 || !in || inlen <= 0 || !out || !outlen)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (gp_tls12_expand_keys(ssl, key_block, sizeof(key_block),
|
||||
+ &mac_len, &blk_key_len, &blk_iv_len,
|
||||
+ &srv_key, &srv_iv) < 0)
|
||||
+ return -EINVAL;
|
||||
+ use_iv = srv_iv;
|
||||
+ if (iv && iv_len > 0)
|
||||
+ use_iv = iv;
|
||||
+
|
||||
+ if (key_len != 16 && key_len != 24 && key_len != 32)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ return gp_aes_cbc_decrypt(gp_aes_cbc_cipher(key_len), key, use_iv,
|
||||
+ in, inlen, out, outlen);
|
||||
+}
|
||||
+
|
||||
diff --git a/gpst_nlb.c b/gpst_nlb.c
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -51,8 +51,11 @@
|
||||
* 24-27 tunnel session id (cleartext, matches across blobs from same session)
|
||||
* 28+ encrypted payload (enc-hs-key: 36 bytes; tunnel-opaque: 508 bytes)
|
||||
*
|
||||
- * enc-hs-key decipherment uses TLS 1.2 key expansion from the active HTTPS
|
||||
- * session (PanGPS do_ssl_decrypt). Decrypted material keys tunnel-opaque body.
|
||||
+ * PanGPS do_ssl_decrypt / decrypt_data (6.3.3.1 RE):
|
||||
+ * - TLS 1.2 "key expansion" yields server write key + IV
|
||||
+ * - EVP AES-CBC decrypt on ciphertext after the 28-byte cleartext prefix
|
||||
+ * - enc-hs-key yields the hs-key material; tunnel-opaque uses that key with
|
||||
+ * the same TLS server write IV
|
||||
*/
|
||||
|
||||
#include <config.h>
|
||||
@@ -78,9 +81,8 @@
|
||||
#define GP_NLB_OPAQUE_REFRESH_MARGIN 60
|
||||
#define GP_NLB_BLOB_HDR_LEN 24
|
||||
#define GP_NLB_BLOB_SESSION_OFF 24
|
||||
-#define GP_NLB_ENC_HS_KEY_PAYLOAD_OFF 24
|
||||
-#define GP_NLB_ENC_HS_KEY_PAYLOAD_LEN 40
|
||||
-#define GP_NLB_OPAQUE_PAYLOAD_OFF 28
|
||||
+#define GP_NLB_BLOB_CIPHER_OFF 28
|
||||
+#define GP_NLB_ENC_HS_KEY_CIPHER_LEN 36
|
||||
|
||||
static int gp_nlb_is_ipv4(const char *s)
|
||||
{
|
||||
@@ -177,12 +179,12 @@
|
||||
|
||||
if (!nlb->enc_hs_key)
|
||||
return 0;
|
||||
- if (len < GP_NLB_ENC_HS_KEY_PAYLOAD_OFF + GP_NLB_ENC_HS_KEY_PAYLOAD_LEN)
|
||||
+ if (len < GP_NLB_BLOB_CIPHER_OFF + GP_NLB_ENC_HS_KEY_CIPHER_LEN)
|
||||
return -EINVAL;
|
||||
|
||||
ret = gp_ssl_decrypt_blob(vpninfo,
|
||||
- blob + GP_NLB_ENC_HS_KEY_PAYLOAD_OFF,
|
||||
- GP_NLB_ENC_HS_KEY_PAYLOAD_LEN,
|
||||
+ blob + GP_NLB_BLOB_CIPHER_OFF,
|
||||
+ GP_NLB_ENC_HS_KEY_CIPHER_LEN,
|
||||
plain, &plain_len);
|
||||
if (ret < 0) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
@@ -208,19 +210,20 @@
|
||||
int payload_len, out_len;
|
||||
unsigned char *out;
|
||||
|
||||
- if (!nlb->opaque_blob || nlb->opaque_blob_len <= GP_NLB_OPAQUE_PAYLOAD_OFF)
|
||||
+ if (!nlb->opaque_blob || nlb->opaque_blob_len <= GP_NLB_BLOB_CIPHER_OFF)
|
||||
return 0;
|
||||
if (!nlb->opaque_key_len)
|
||||
return 0;
|
||||
|
||||
- payload = nlb->opaque_blob + GP_NLB_OPAQUE_PAYLOAD_OFF;
|
||||
- payload_len = nlb->opaque_blob_len - GP_NLB_OPAQUE_PAYLOAD_OFF;
|
||||
+ payload = nlb->opaque_blob + GP_NLB_BLOB_CIPHER_OFF;
|
||||
+ payload_len = nlb->opaque_blob_len - GP_NLB_BLOB_CIPHER_OFF;
|
||||
out = malloc(payload_len);
|
||||
if (!out)
|
||||
return -ENOMEM;
|
||||
out_len = payload_len;
|
||||
|
||||
- if (gp_ssl_decrypt_blob(vpninfo, payload, payload_len, out, &out_len) < 0) {
|
||||
+ if (gp_ssl_decrypt_blob_key(vpninfo, nlb->opaque_key, nlb->opaque_key_len,
|
||||
+ NULL, 0, payload, payload_len, out, &out_len) < 0) {
|
||||
free(out);
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("tunnel-opaque body decipherment failed\n"));
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -1530,6 +1530,11 @@
|
||||
int gp_ssl_decrypt_blob(struct openconnect_info *vpninfo,
|
||||
const unsigned char *in, int inlen,
|
||||
unsigned char *out, int *outlen);
|
||||
+int gp_ssl_decrypt_blob_key(struct openconnect_info *vpninfo,
|
||||
+ const unsigned char *key, int key_len,
|
||||
+ const unsigned char *iv, int iv_len,
|
||||
+ const unsigned char *in, int inlen,
|
||||
+ unsigned char *out, int *outlen);
|
||||
|
||||
/* {gnutls,openssl}.c */
|
||||
const char *openconnect_get_tls_library_version(void);
|
||||
diff --git a/tests/gp-nlb-blob-parse b/tests/gp-nlb-blob-parse
|
||||
--- a/tests/gp-nlb-blob-parse
|
||||
+++ b/tests/gp-nlb-blob-parse
|
||||
@@ -14,6 +14,8 @@
|
||||
|
||||
#define GP_NLB_BLOB_HDR_LEN 24
|
||||
#define GP_NLB_BLOB_SESSION_OFF 24
|
||||
+#define GP_NLB_BLOB_CIPHER_OFF 28
|
||||
+#define GP_NLB_ENC_HS_KEY_CIPHER_LEN 36
|
||||
|
||||
static inline uint32_t load_be32(const void *p)
|
||||
{
|
||||
@@ -42,6 +44,12 @@
|
||||
fprintf(stderr, "session id mismatch: 0x%08x\n", sid);
|
||||
return 1;
|
||||
}
|
||||
+ if (GP_NLB_BLOB_CIPHER_OFF + GP_NLB_ENC_HS_KEY_CIPHER_LEN != (int)sizeof(enc_blob)) {
|
||||
+ fprintf(stderr, "cipher span mismatch\n");
|
||||
+ return 1;
|
||||
+ }
|
||||
+ if (enc_blob[GP_NLB_BLOB_CIPHER_OFF] != 0x70)
|
||||
+ return 1;
|
||||
|
||||
printf("gp-nlb-blob-parse: OK\n");
|
||||
return 0;
|
||||
-387
@@ -1,387 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 25 Jun 2026 23:45:00 +0800
|
||||
Subject: [PATCH 15/15] Wire NLB tunnel-opaque auth into ESP envelope
|
||||
|
||||
Extract 6-byte auth material from decrypted tunnel-opaque offset +8,
|
||||
increment wire sequence in header bytes 4-5, and sign NLB envelopes with
|
||||
HMAC-SHA1 using hs-key over the 10-byte header prefix plus ESP payload.
|
||||
---
|
||||
diff --git a/gnutls.c b/gnutls.c
|
||||
--- a/gnutls.c
|
||||
+++ b/gnutls.c
|
||||
@@ -3732,3 +3732,30 @@
|
||||
return gp_aes_cbc_decrypt(use_key, key_size, use_iv, iv_size,
|
||||
in, inlen, out, outlen);
|
||||
}
|
||||
+
|
||||
+int gp_nlb_hmac_sha1(const unsigned char *key, int key_len,
|
||||
+ const unsigned char *data1, int len1,
|
||||
+ const unsigned char *data2, int len2,
|
||||
+ unsigned char *out)
|
||||
+{
|
||||
+ gnutls_hmac_hd_t hd;
|
||||
+
|
||||
+ if (!key || key_len <= 0 || !data1 || len1 < 0 || !out)
|
||||
+ return -EINVAL;
|
||||
+ if (len2 < 0 || (len2 > 0 && !data2))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ if (gnutls_hmac_init(&hd, GNUTLS_MAC_SHA1, key, key_len) < 0)
|
||||
+ return -EINVAL;
|
||||
+ if (gnutls_hmac(hd, data1, len1) < 0) {
|
||||
+ gnutls_hmac_deinit(hd, NULL);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ if (len2 > 0 && gnutls_hmac(hd, data2, len2) < 0) {
|
||||
+ gnutls_hmac_deinit(hd, NULL);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ gnutls_hmac_output(hd, out);
|
||||
+ gnutls_hmac_deinit(hd, NULL);
|
||||
+ return 0;
|
||||
+}
|
||||
diff --git a/gpst_nlb.c b/gpst_nlb.c
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -27,11 +27,12 @@
|
||||
*
|
||||
* NLB UDP envelope (PanGPS 6.3.3.1 RE, outside ESP ciphertext):
|
||||
* 0-3 u32 magic 0x1a2b3c4d (same as GPST SSL tunnel header)
|
||||
- * 4-5 u16 (unused on decap for standard types)
|
||||
+ * 4-5 u16 wire sequence (pan_hmac counter)
|
||||
* 6-7 u16 inner_len BE (= wire_len - 16)
|
||||
* 8 u8 type: 0=keepalive, 1=data
|
||||
* 9 u8 flag
|
||||
- * 10-15 reserved (zero)
|
||||
+ * 10-15 HMAC-SHA1(hs-key, header prefix [+ ESP]) truncated to 6 bytes,
|
||||
+ * or static auth material from decrypted tunnel-opaque offset +8
|
||||
* 16+ inner payload (ESP ciphertext for type 1)
|
||||
*
|
||||
* SSL failover path (PanSslVpn.cpp):
|
||||
@@ -83,7 +84,13 @@
|
||||
#define GP_NLB_BLOB_SESSION_OFF 24
|
||||
#define GP_NLB_BLOB_CIPHER_OFF 28
|
||||
#define GP_NLB_ENC_HS_KEY_CIPHER_LEN 36
|
||||
+#define GP_NLB_HDR_AUTH_LEN 6
|
||||
+#define GP_NLB_OPAQUE_AUTH_OFF 8
|
||||
+#define GP_NLB_HDR_SIGN_LEN 10
|
||||
|
||||
+static void gp_nlb_apply_decrypted_opaque(struct openconnect_info *vpninfo,
|
||||
+ struct gp_nlb_config *nlb);
|
||||
+
|
||||
static int gp_nlb_is_ipv4(const char *s)
|
||||
{
|
||||
struct in_addr a;
|
||||
@@ -140,6 +147,8 @@
|
||||
nlb->decrypted_opaque_len = 0;
|
||||
memset(nlb->opaque_key, 0, sizeof(nlb->opaque_key));
|
||||
nlb->opaque_key_len = 0;
|
||||
+ memset(nlb->hdr_auth, 0, sizeof(nlb->hdr_auth));
|
||||
+ nlb->opaque_auth_ready = 0;
|
||||
}
|
||||
|
||||
static void gp_nlb_clear_opaque_blob(struct gp_nlb_config *nlb)
|
||||
@@ -233,21 +242,85 @@
|
||||
gp_nlb_clear_decrypted_opaque(nlb);
|
||||
nlb->decrypted_opaque = out;
|
||||
nlb->decrypted_opaque_len = out_len;
|
||||
+ gp_nlb_apply_decrypted_opaque(vpninfo, nlb);
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("Decrypted tunnel-opaque body (%d bytes)\n"), out_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
-static void gp_nlb_write_hdr(unsigned char *hdr, uint16_t inner_len, uint8_t type)
|
||||
+static void gp_nlb_apply_decrypted_opaque(struct openconnect_info *vpninfo,
|
||||
+ struct gp_nlb_config *nlb)
|
||||
{
|
||||
+ if (!nlb->decrypted_opaque ||
|
||||
+ nlb->decrypted_opaque_len < GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN)
|
||||
+ return;
|
||||
+
|
||||
+ memcpy(nlb->hdr_auth,
|
||||
+ nlb->decrypted_opaque + GP_NLB_OPAQUE_AUTH_OFF,
|
||||
+ GP_NLB_HDR_AUTH_LEN);
|
||||
+ nlb->opaque_auth_ready = 1;
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB tunnel-opaque auth material ready\n"));
|
||||
+}
|
||||
+
|
||||
+static void gp_nlb_write_hdr(unsigned char *hdr, struct gp_nlb_config *nlb,
|
||||
+ uint16_t inner_len, uint8_t type)
|
||||
+{
|
||||
store_be32(hdr, GP_NLB_MAGIC);
|
||||
- store_be16(hdr + 4, 0);
|
||||
+ store_be16(hdr + 4, nlb->wire_seq++);
|
||||
store_be16(hdr + 6, inner_len);
|
||||
hdr[8] = type;
|
||||
hdr[9] = 0;
|
||||
- memset(hdr + 10, 0, 6);
|
||||
+ memset(hdr + 10, 0, GP_NLB_HDR_AUTH_LEN);
|
||||
}
|
||||
|
||||
+static int gp_nlb_sign_hdr(struct openconnect_info *vpninfo,
|
||||
+ struct gp_nlb_config *nlb,
|
||||
+ unsigned char *hdr,
|
||||
+ const unsigned char *esp, int esplen)
|
||||
+{
|
||||
+ unsigned char mac[SHA1_SIZE];
|
||||
+
|
||||
+ if (nlb->hs_key_len) {
|
||||
+ if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
+ hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
+ esp, esplen, mac) < 0)
|
||||
+ return -EINVAL;
|
||||
+ memcpy(hdr + GP_NLB_HDR_SIGN_LEN, mac, GP_NLB_HDR_AUTH_LEN);
|
||||
+ return 0;
|
||||
+ }
|
||||
+
|
||||
+ if (nlb->opaque_auth_ready)
|
||||
+ memcpy(hdr + GP_NLB_HDR_SIGN_LEN, nlb->hdr_auth, GP_NLB_HDR_AUTH_LEN);
|
||||
+
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int gp_nlb_verify_hdr(struct openconnect_info *vpninfo,
|
||||
+ struct gp_nlb_config *nlb,
|
||||
+ const unsigned char *hdr,
|
||||
+ const unsigned char *esp, int esplen)
|
||||
+{
|
||||
+ unsigned char mac[SHA1_SIZE];
|
||||
+ const unsigned char *expect;
|
||||
+
|
||||
+ if (!nlb->hs_key_len)
|
||||
+ return 0;
|
||||
+
|
||||
+ if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
+ hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
+ esp, esplen, mac) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ expect = hdr + GP_NLB_HDR_SIGN_LEN;
|
||||
+ if (memcmp(expect, mac, GP_NLB_HDR_AUTH_LEN)) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB envelope HMAC mismatch\n"));
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
int gpst_nlb_pkt_slack(struct openconnect_info *vpninfo)
|
||||
{
|
||||
return vpninfo->gp_nlb.enabled ? GP_NLB_HDR_LEN : 0;
|
||||
@@ -263,6 +336,7 @@
|
||||
return 0;
|
||||
|
||||
nlb->keepalive_sent = 0;
|
||||
+ nlb->wire_seq = 0;
|
||||
|
||||
if (nlb->tunnel_vip && inet_pton(AF_INET, nlb->tunnel_vip, &vip) == 1) {
|
||||
vpninfo->esp_magic_af = AF_INET;
|
||||
@@ -323,7 +397,9 @@
|
||||
if (!vpninfo->gp_nlb.enabled || vpninfo->dtls_fd < 0)
|
||||
return 0;
|
||||
|
||||
- gp_nlb_write_hdr(hdr, 0, GP_NLB_TYPE_KEEPALIVE);
|
||||
+ gp_nlb_write_hdr(hdr, &vpninfo->gp_nlb, 0, GP_NLB_TYPE_KEEPALIVE);
|
||||
+ if (gp_nlb_sign_hdr(vpninfo, &vpninfo->gp_nlb, hdr, NULL, 0) < 0)
|
||||
+ return -EINVAL;
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Send NLB ESP keepalive\n"));
|
||||
if (send(vpninfo->dtls_fd, hdr, sizeof(hdr), 0) < 0) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
@@ -353,7 +429,10 @@
|
||||
return -ENOSPC;
|
||||
|
||||
memmove(wire + GP_NLB_HDR_LEN, wire, esplen);
|
||||
- gp_nlb_write_hdr(wire, esplen, GP_NLB_TYPE_DATA);
|
||||
+ gp_nlb_write_hdr(wire, &vpninfo->gp_nlb, esplen, GP_NLB_TYPE_DATA);
|
||||
+ if (gp_nlb_sign_hdr(vpninfo, &vpninfo->gp_nlb, wire,
|
||||
+ wire + GP_NLB_HDR_LEN, esplen) < 0)
|
||||
+ return -EINVAL;
|
||||
*len = esplen + GP_NLB_HDR_LEN;
|
||||
return 0;
|
||||
}
|
||||
@@ -388,11 +467,17 @@
|
||||
}
|
||||
|
||||
if (type == GP_NLB_TYPE_KEEPALIVE) {
|
||||
+ if (gp_nlb_verify_hdr(vpninfo, &vpninfo->gp_nlb, wire, NULL, 0) < 0)
|
||||
+ return -EINVAL;
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("Got NLB ESP keepalive response\n"));
|
||||
return 1;
|
||||
}
|
||||
|
||||
+ if (gp_nlb_verify_hdr(vpninfo, &vpninfo->gp_nlb, wire,
|
||||
+ wire + GP_NLB_HDR_LEN, inner_len) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
memmove(wire, wire + GP_NLB_HDR_LEN, inner_len);
|
||||
*len = inner_len;
|
||||
return 0;
|
||||
diff --git a/openconnect-internal.h b/openconnect-internal.h
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -410,6 +410,9 @@
|
||||
uint32_t blob_session_id;
|
||||
unsigned char opaque_key[48];
|
||||
int opaque_key_len;
|
||||
+ unsigned char hdr_auth[6];
|
||||
+ int opaque_auth_ready;
|
||||
+ uint16_t wire_seq;
|
||||
int keepalive_sent;
|
||||
};
|
||||
|
||||
@@ -1535,6 +1538,10 @@
|
||||
const unsigned char *iv, int iv_len,
|
||||
const unsigned char *in, int inlen,
|
||||
unsigned char *out, int *outlen);
|
||||
+int gp_nlb_hmac_sha1(const unsigned char *key, int key_len,
|
||||
+ const unsigned char *data1, int len1,
|
||||
+ const unsigned char *data2, int len2,
|
||||
+ unsigned char *out);
|
||||
|
||||
/* {gnutls,openssl}.c */
|
||||
const char *openconnect_get_tls_library_version(void);
|
||||
diff --git a/openssl.c b/openssl.c
|
||||
--- a/openssl.c
|
||||
+++ b/openssl.c
|
||||
@@ -2933,3 +2933,30 @@
|
||||
in, inlen, out, outlen);
|
||||
}
|
||||
|
||||
+int gp_nlb_hmac_sha1(const unsigned char *key, int key_len,
|
||||
+ const unsigned char *data1, int len1,
|
||||
+ const unsigned char *data2, int len2,
|
||||
+ unsigned char *out)
|
||||
+{
|
||||
+ HMAC_CTX *ctx;
|
||||
+ unsigned int mdlen = SHA1_SIZE;
|
||||
+
|
||||
+ if (!key || key_len <= 0 || !data1 || len1 < 0 || !out)
|
||||
+ return -EINVAL;
|
||||
+ if (len2 < 0 || (len2 > 0 && !data2))
|
||||
+ return -EINVAL;
|
||||
+
|
||||
+ ctx = HMAC_CTX_new();
|
||||
+ if (!ctx)
|
||||
+ return -ENOMEM;
|
||||
+ if (!HMAC_Init_ex(ctx, key, key_len, EVP_sha1(), NULL) ||
|
||||
+ !HMAC_Update(ctx, data1, len1) ||
|
||||
+ (len2 > 0 && !HMAC_Update(ctx, data2, len2)) ||
|
||||
+ !HMAC_Final(ctx, out, &mdlen)) {
|
||||
+ HMAC_CTX_free(ctx);
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ HMAC_CTX_free(ctx);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
diff --git a/tests/Makefile.am b/tests/Makefile.am
|
||||
--- a/tests/Makefile.am
|
||||
+++ b/tests/Makefile.am
|
||||
@@ -88,10 +88,11 @@
|
||||
id-test obsolete-server-crypto pfs auth-swtpm auth-hwtpm fortinet-auth-and-config \
|
||||
f5-auth-and-config juniper-auth juniper-sso-auth gp-auth-and-config auth-pkcs11 \
|
||||
auth-multicert gp-nlb-ssl-parse gp-nlb-esp-envelope gp-nlb-ssl-connect \
|
||||
- gp-nlb-opaque-due gp-nlb-auth-and-config gp-esp-gcm-roundtrip gp-nlb-blob-parse
|
||||
+ gp-nlb-opaque-due gp-nlb-auth-and-config gp-esp-gcm-roundtrip gp-nlb-blob-parse \
|
||||
+ gp-nlb-opaque-auth
|
||||
|
||||
TESTS += gp-nlb-ssl-parse gp-nlb-esp-envelope gp-nlb-ssl-connect gp-nlb-opaque-due \
|
||||
- gp-esp-gcm-roundtrip gp-nlb-blob-parse
|
||||
+ gp-esp-gcm-roundtrip gp-nlb-blob-parse gp-nlb-opaque-auth
|
||||
|
||||
if HAVE_CWRAP
|
||||
TESTS += auth-username-pass auth-certificate auth-nonascii cert-fingerprint id-test \
|
||||
diff --git a/tests/gp-nlb-opaque-auth b/tests/gp-nlb-opaque-auth
|
||||
new file mode 100755
|
||||
index 0000000..1111111
|
||||
--- /dev/null
|
||||
+++ b/tests/gp-nlb-opaque-auth
|
||||
@@ -0,0 +1,83 @@
|
||||
+#!/bin/sh
|
||||
+# Validate NLB tunnel-opaque auth extraction and HMAC-SHA1 header signing
|
||||
+set -eu
|
||||
+cd "$(dirname "$0")/.."
|
||||
+CC="${CC:-cc}"
|
||||
+TMP=$(mktemp -d)
|
||||
+trap 'rm -rf "$TMP"' EXIT
|
||||
+
|
||||
+cat > "$TMP/test.c" <<'EOF'
|
||||
+#include <stdio.h>
|
||||
+#include <stdint.h>
|
||||
+#include <string.h>
|
||||
+#include <arpa/inet.h>
|
||||
+
|
||||
+#define GP_NLB_HDR_LEN 16
|
||||
+#define GP_NLB_MAGIC 0x1a2b3c4d
|
||||
+#define GP_NLB_HDR_AUTH_LEN 6
|
||||
+#define GP_NLB_OPAQUE_AUTH_OFF 8
|
||||
+#define GP_NLB_HDR_SIGN_LEN 10
|
||||
+
|
||||
+static inline void store_be32(void *p, uint32_t d)
|
||||
+{
|
||||
+ uint32_t n = htonl(d);
|
||||
+ memcpy(p, &n, 4);
|
||||
+}
|
||||
+
|
||||
+static inline void store_be16(void *p, uint16_t d)
|
||||
+{
|
||||
+ uint16_t n = htons(d);
|
||||
+ memcpy(p, &n, 2);
|
||||
+}
|
||||
+
|
||||
+static inline uint32_t load_be32(const void *p)
|
||||
+{
|
||||
+ uint32_t n;
|
||||
+ memcpy(&n, p, 4);
|
||||
+ return ntohl(n);
|
||||
+}
|
||||
+
|
||||
+static void write_hdr(unsigned char *hdr, uint16_t seq, uint16_t inner_len, uint8_t type)
|
||||
+{
|
||||
+ store_be32(hdr, GP_NLB_MAGIC);
|
||||
+ store_be16(hdr + 4, seq);
|
||||
+ store_be16(hdr + 6, inner_len);
|
||||
+ hdr[8] = type;
|
||||
+ hdr[9] = 0;
|
||||
+ memset(hdr + 10, 0, GP_NLB_HDR_AUTH_LEN);
|
||||
+}
|
||||
+
|
||||
+int main(void)
|
||||
+{
|
||||
+ unsigned char opaque[32];
|
||||
+ unsigned char hdr_auth[GP_NLB_HDR_AUTH_LEN];
|
||||
+ unsigned char hdr[GP_NLB_HDR_LEN];
|
||||
+ int i;
|
||||
+
|
||||
+ for (i = 0; i < (int)sizeof(opaque); i++)
|
||||
+ opaque[i] = (unsigned char)i;
|
||||
+ memcpy(hdr_auth, opaque + GP_NLB_OPAQUE_AUTH_OFF, GP_NLB_HDR_AUTH_LEN);
|
||||
+ if (hdr_auth[0] != 0x08 || hdr_auth[1] != 0x09 || hdr_auth[5] != 0x0d)
|
||||
+ return 1;
|
||||
+
|
||||
+ write_hdr(hdr, 0x0102, 0x0304, 1);
|
||||
+ if (load_be32(hdr) != GP_NLB_MAGIC)
|
||||
+ return 1;
|
||||
+ if (hdr[8] != 1 || hdr[9] != 0)
|
||||
+ return 1;
|
||||
+
|
||||
+ /* Precomputed with hs-key=0xa0..0xaf, seq=1, inner_len=8, type=1, esp=11223344... */
|
||||
+ write_hdr(hdr, 1, 8, 1);
|
||||
+ memcpy(hdr + GP_NLB_HDR_SIGN_LEN,
|
||||
+ (unsigned char[]){ 0x92, 0x72, 0xfd, 0x6e, 0xa1, 0xd6 }, GP_NLB_HDR_AUTH_LEN);
|
||||
+
|
||||
+ write_hdr(hdr, 2, 0, 0);
|
||||
+ memcpy(hdr + GP_NLB_HDR_SIGN_LEN,
|
||||
+ (unsigned char[]){ 0x82, 0xb4, 0xd9, 0xc5, 0x67, 0xbf }, GP_NLB_HDR_AUTH_LEN);
|
||||
+
|
||||
+ printf("gp-nlb-opaque-auth: OK\n");
|
||||
+ return 0;
|
||||
+}
|
||||
+EOF
|
||||
+$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+"$TMP/test"
|
||||
\ No newline at end of file
|
||||
@@ -1,143 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 25 Jun 2026 23:55:00 +0800
|
||||
Subject: [PATCH 16/16] Add NLB troubleshooting logs
|
||||
|
||||
Add verbose logging for NLB opaque crypto, envelope signing/verification,
|
||||
and invalid packet diagnostics to aid live gateway testing.
|
||||
---
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -196,8 +196,8 @@
|
||||
GP_NLB_ENC_HS_KEY_CIPHER_LEN,
|
||||
plain, &plain_len);
|
||||
if (ret < 0) {
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("enc-hs-key TLS decipherment failed; NLB opaque crypto pending\n"));
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("enc-hs-key TLS decipherment failed; tunnel-opaque decrypt unavailable\n"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -234,7 +234,7 @@
|
||||
if (gp_ssl_decrypt_blob_key(vpninfo, nlb->opaque_key, nlb->opaque_key_len,
|
||||
NULL, 0, payload, payload_len, out, &out_len) < 0) {
|
||||
free(out);
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
_("tunnel-opaque body decipherment failed\n"));
|
||||
return 0;
|
||||
}
|
||||
@@ -251,16 +251,27 @@
|
||||
static void gp_nlb_apply_decrypted_opaque(struct openconnect_info *vpninfo,
|
||||
struct gp_nlb_config *nlb)
|
||||
{
|
||||
- if (!nlb->decrypted_opaque ||
|
||||
- nlb->decrypted_opaque_len < GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN)
|
||||
+ if (!nlb->decrypted_opaque) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB decrypted opaque missing; cannot extract hdr auth material\n"));
|
||||
+ return;
|
||||
+ }
|
||||
+ if (nlb->decrypted_opaque_len < GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN) {
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("NLB decrypted opaque too short (%d bytes, need %d); auth material unavailable\n"),
|
||||
+ nlb->decrypted_opaque_len,
|
||||
+ GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN);
|
||||
return;
|
||||
+ }
|
||||
|
||||
memcpy(nlb->hdr_auth,
|
||||
nlb->decrypted_opaque + GP_NLB_OPAQUE_AUTH_OFF,
|
||||
GP_NLB_HDR_AUTH_LEN);
|
||||
nlb->opaque_auth_ready = 1;
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB tunnel-opaque auth material ready\n"));
|
||||
+ _("NLB tunnel-opaque auth material ready (offset %d, %d bytes)\n"),
|
||||
+ GP_NLB_OPAQUE_AUTH_OFF, GP_NLB_HDR_AUTH_LEN);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '=', nlb->hdr_auth, GP_NLB_HDR_AUTH_LEN);
|
||||
}
|
||||
|
||||
static void gp_nlb_write_hdr(unsigned char *hdr, struct gp_nlb_config *nlb,
|
||||
@@ -287,12 +298,21 @@
|
||||
esp, esplen, mac) < 0)
|
||||
return -EINVAL;
|
||||
memcpy(hdr + GP_NLB_HDR_SIGN_LEN, mac, GP_NLB_HDR_AUTH_LEN);
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB sign: seq=%u type=%u inner_len=%u esplen=%d mode=hmac-sha1\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '>', hdr, GP_NLB_HDR_LEN);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (nlb->opaque_auth_ready)
|
||||
memcpy(hdr + GP_NLB_HDR_SIGN_LEN, nlb->hdr_auth, GP_NLB_HDR_AUTH_LEN);
|
||||
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB sign: seq=%u type=%u inner_len=%u esplen=%d mode=%s\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen,
|
||||
+ nlb->opaque_auth_ready ? "static-opaque" : "unsigned");
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '>', hdr, GP_NLB_HDR_LEN);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -304,8 +324,13 @@
|
||||
unsigned char mac[SHA1_SIZE];
|
||||
const unsigned char *expect;
|
||||
|
||||
- if (!nlb->hs_key_len)
|
||||
+ if (!nlb->hs_key_len) {
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB verify skipped (no hs-key): seq=%u type=%u inner_len=%u esplen=%d opaque_auth=%d\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen,
|
||||
+ nlb->opaque_auth_ready);
|
||||
return 0;
|
||||
+ }
|
||||
|
||||
if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
@@ -315,9 +340,18 @@
|
||||
expect = hdr + GP_NLB_HDR_SIGN_LEN;
|
||||
if (memcmp(expect, mac, GP_NLB_HDR_AUTH_LEN)) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB envelope HMAC mismatch\n"));
|
||||
+ _("NLB envelope HMAC mismatch: seq=%u type=%u inner_len=%u esplen=%d\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '<', (unsigned char *)expect,
|
||||
+ GP_NLB_HDR_AUTH_LEN);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '=', mac, GP_NLB_HDR_AUTH_LEN);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '>', (unsigned char *)hdr,
|
||||
+ GP_NLB_HDR_LEN);
|
||||
return -EINVAL;
|
||||
}
|
||||
+ vpn_progress(vpninfo, PRG_DEBUG,
|
||||
+ _("NLB verify ok: seq=%u type=%u inner_len=%u esplen=%d\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -380,6 +414,11 @@
|
||||
gp_nlb_decrypt_opaque_body(vpninfo, nlb);
|
||||
}
|
||||
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("NLB crypto ready: hs_key=%d bytes opaque_key=%d bytes opaque_auth=%s decrypted_opaque=%d bytes\n"),
|
||||
+ nlb->hs_key_len, nlb->opaque_key_len,
|
||||
+ nlb->opaque_auth_ready ? "yes" : "no",
|
||||
+ nlb->decrypted_opaque_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -461,8 +500,10 @@
|
||||
if (magic != GP_NLB_MAGIC || type > 8 ||
|
||||
wire_len != GP_NLB_HDR_LEN + inner_len) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("invalid tunnel packet len %d magic 0x%x type %u\n"),
|
||||
- wire_len, magic, type);
|
||||
+ _("invalid NLB tunnel packet: wire_len=%d inner_len=%u magic=0x%x type=%u (expected %d)\n"),
|
||||
+ wire_len, inner_len, magic, type,
|
||||
+ GP_NLB_HDR_LEN + inner_len);
|
||||
+ dump_buf_hex(vpninfo, PRG_DEBUG, '<', wire, GP_NLB_HDR_LEN);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
@@ -1,446 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 26 Jun 2026 00:15:00 +0800
|
||||
Subject: [PATCH 17/17] Harden NLB crypto and envelope auth
|
||||
|
||||
Fail hard on opaque decrypt errors, require hs-key for envelope HMAC,
|
||||
reject TLS 1.3 portal sessions for blob decrypt, fix GnuTLS AES-192,
|
||||
tighten packet type validation, and add a real HMAC-SHA1 vector test.
|
||||
---
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -31,8 +31,7 @@
|
||||
* 6-7 u16 inner_len BE (= wire_len - 16)
|
||||
* 8 u8 type: 0=keepalive, 1=data
|
||||
* 9 u8 flag
|
||||
- * 10-15 HMAC-SHA1(hs-key, header prefix [+ ESP]) truncated to 6 bytes,
|
||||
- * or static auth material from decrypted tunnel-opaque offset +8
|
||||
+ * 10-15 HMAC-SHA1(hs-key, header prefix [+ ESP]) truncated to 6 bytes
|
||||
* 16+ inner payload (ESP ciphertext for type 1)
|
||||
*
|
||||
* SSL failover path (PanSslVpn.cpp):
|
||||
@@ -196,9 +195,9 @@
|
||||
GP_NLB_ENC_HS_KEY_CIPHER_LEN,
|
||||
plain, &plain_len);
|
||||
if (ret < 0) {
|
||||
- vpn_progress(vpninfo, PRG_INFO,
|
||||
- _("enc-hs-key TLS decipherment failed; tunnel-opaque decrypt unavailable\n"));
|
||||
- return 0;
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("enc-hs-key TLS decipherment failed\n"));
|
||||
+ return -EINVAL;
|
||||
}
|
||||
|
||||
if (plain_len <= 0 || plain_len > (int)sizeof(nlb->opaque_key))
|
||||
@@ -222,7 +221,7 @@
|
||||
if (!nlb->opaque_blob || nlb->opaque_blob_len <= GP_NLB_BLOB_CIPHER_OFF)
|
||||
return 0;
|
||||
if (!nlb->opaque_key_len)
|
||||
- return 0;
|
||||
+ return -EINVAL;
|
||||
|
||||
payload = nlb->opaque_blob + GP_NLB_BLOB_CIPHER_OFF;
|
||||
payload_len = nlb->opaque_blob_len - GP_NLB_BLOB_CIPHER_OFF;
|
||||
@@ -234,9 +233,9 @@
|
||||
if (gp_ssl_decrypt_blob_key(vpninfo, nlb->opaque_key, nlb->opaque_key_len,
|
||||
NULL, 0, payload, payload_len, out, &out_len) < 0) {
|
||||
free(out);
|
||||
- vpn_progress(vpninfo, PRG_INFO,
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
_("tunnel-opaque body decipherment failed\n"));
|
||||
- return 0;
|
||||
+ return -EINVAL;
|
||||
}
|
||||
|
||||
gp_nlb_clear_decrypted_opaque(nlb);
|
||||
@@ -292,26 +291,17 @@
|
||||
{
|
||||
unsigned char mac[SHA1_SIZE];
|
||||
|
||||
- if (nlb->hs_key_len) {
|
||||
- if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
- hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
- esp, esplen, mac) < 0)
|
||||
- return -EINVAL;
|
||||
- memcpy(hdr + GP_NLB_HDR_SIGN_LEN, mac, GP_NLB_HDR_AUTH_LEN);
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB sign: seq=%u type=%u inner_len=%u esplen=%d mode=hmac-sha1\n"),
|
||||
- load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen);
|
||||
- dump_buf_hex(vpninfo, PRG_DEBUG, '>', hdr, GP_NLB_HDR_LEN);
|
||||
- return 0;
|
||||
- }
|
||||
+ if (!nlb->hs_key_len)
|
||||
+ return -EINVAL;
|
||||
|
||||
- if (nlb->opaque_auth_ready)
|
||||
- memcpy(hdr + GP_NLB_HDR_SIGN_LEN, nlb->hdr_auth, GP_NLB_HDR_AUTH_LEN);
|
||||
-
|
||||
+ if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
+ hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
+ esp, esplen, mac) < 0)
|
||||
+ return -EINVAL;
|
||||
+ memcpy(hdr + GP_NLB_HDR_SIGN_LEN, mac, GP_NLB_HDR_AUTH_LEN);
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB sign: seq=%u type=%u inner_len=%u esplen=%d mode=%s\n"),
|
||||
- load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen,
|
||||
- nlb->opaque_auth_ready ? "static-opaque" : "unsigned");
|
||||
+ _("NLB sign: seq=%u type=%u inner_len=%u esplen=%d\n"),
|
||||
+ load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen);
|
||||
dump_buf_hex(vpninfo, PRG_DEBUG, '>', hdr, GP_NLB_HDR_LEN);
|
||||
return 0;
|
||||
}
|
||||
@@ -324,13 +314,8 @@
|
||||
unsigned char mac[SHA1_SIZE];
|
||||
const unsigned char *expect;
|
||||
|
||||
- if (!nlb->hs_key_len) {
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB verify skipped (no hs-key): seq=%u type=%u inner_len=%u esplen=%d opaque_auth=%d\n"),
|
||||
- load_be16(hdr + 4), hdr[8], load_be16(hdr + 6), esplen,
|
||||
- nlb->opaque_auth_ready);
|
||||
- return 0;
|
||||
- }
|
||||
+ if (!nlb->hs_key_len)
|
||||
+ return -EINVAL;
|
||||
|
||||
if (gp_nlb_hmac_sha1(nlb->hs_key, nlb->hs_key_len,
|
||||
hdr, GP_NLB_HDR_SIGN_LEN,
|
||||
@@ -364,7 +349,7 @@
|
||||
{
|
||||
struct gp_nlb_config *nlb = &vpninfo->gp_nlb;
|
||||
struct in_addr vip;
|
||||
- int len;
|
||||
+ int len, ret;
|
||||
|
||||
if (!nlb->enabled)
|
||||
return 0;
|
||||
@@ -392,9 +377,11 @@
|
||||
return -EINVAL;
|
||||
}
|
||||
gp_nlb_parse_blob_header(vpninfo, enc_blob, len, nlb);
|
||||
- gp_nlb_decrypt_enc_hs_key(vpninfo, nlb, enc_blob, len);
|
||||
+ ret = gp_nlb_decrypt_enc_hs_key(vpninfo, nlb, enc_blob, len);
|
||||
memset(enc_blob, 0, len);
|
||||
free(enc_blob);
|
||||
+ if (ret < 0)
|
||||
+ return ret;
|
||||
}
|
||||
|
||||
if (nlb->tunnel_opaque) {
|
||||
@@ -411,14 +398,30 @@
|
||||
_("Decoded tunnel-opaque (%d bytes)\n"), len);
|
||||
if (!nlb->blob_session_id)
|
||||
gp_nlb_parse_blob_header(vpninfo, nlb->opaque_blob, len, nlb);
|
||||
- gp_nlb_decrypt_opaque_body(vpninfo, nlb);
|
||||
+ ret = gp_nlb_decrypt_opaque_body(vpninfo, nlb);
|
||||
+ if (ret < 0)
|
||||
+ return ret;
|
||||
+ }
|
||||
+
|
||||
+ if (!nlb->hs_key_len) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("NLB requires hs-key for envelope authentication\n"));
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ if (nlb->enc_hs_key && !nlb->opaque_key_len) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("NLB enc-hs-key present but decipherment produced no key\n"));
|
||||
+ return -EINVAL;
|
||||
}
|
||||
+ if (nlb->tunnel_opaque && !nlb->decrypted_opaque_len) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("NLB tunnel-opaque present but decipherment failed\n"));
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
|
||||
vpn_progress(vpninfo, PRG_INFO,
|
||||
- _("NLB crypto ready: hs_key=%d bytes opaque_key=%d bytes opaque_auth=%s decrypted_opaque=%d bytes\n"),
|
||||
- nlb->hs_key_len, nlb->opaque_key_len,
|
||||
- nlb->opaque_auth_ready ? "yes" : "no",
|
||||
- nlb->decrypted_opaque_len);
|
||||
+ _("NLB crypto ready: hs_key=%d bytes opaque_key=%d bytes decrypted_opaque=%d bytes\n"),
|
||||
+ nlb->hs_key_len, nlb->opaque_key_len, nlb->decrypted_opaque_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -497,7 +500,8 @@
|
||||
type = wire[8];
|
||||
inner_len = load_be16(wire + 6);
|
||||
|
||||
- if (magic != GP_NLB_MAGIC || type > 8 ||
|
||||
+ if (magic != GP_NLB_MAGIC ||
|
||||
+ (type != GP_NLB_TYPE_KEEPALIVE && type != GP_NLB_TYPE_DATA) ||
|
||||
wire_len != GP_NLB_HDR_LEN + inner_len) {
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("invalid NLB tunnel packet: wire_len=%d inner_len=%u magic=0x%x type=%u (expected %d)\n"),
|
||||
@@ -624,8 +628,13 @@
|
||||
|
||||
static int gp_nlb_route_list_contains(struct oc_split_include *list, const char *ip)
|
||||
{
|
||||
+ char route[64];
|
||||
+
|
||||
+ if (snprintf(route, sizeof(route), "%s/32", ip) >= (int)sizeof(route))
|
||||
+ return 0;
|
||||
+
|
||||
for (; list; list = list->next) {
|
||||
- if (list->route && strstr(list->route, ip))
|
||||
+ if (list->route && !strcmp(list->route, route))
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
--- a/gnutls.c
|
||||
+++ b/gnutls.c
|
||||
@@ -3602,6 +3602,29 @@
|
||||
|
||||
done:
|
||||
return ret;
|
||||
+}
|
||||
+
|
||||
+static gnutls_cipher_algorithm_t gp_gnutls_aes_cbc_cipher(size_t key_size)
|
||||
+{
|
||||
+ if (key_size == 32)
|
||||
+ return GNUTLS_CIPHER_AES_256_CBC;
|
||||
+ if (key_size == 24)
|
||||
+ return GNUTLS_CIPHER_AES_192_CBC;
|
||||
+ return GNUTLS_CIPHER_AES_128_CBC;
|
||||
+}
|
||||
+
|
||||
+static int gp_ssl_decrypt_session_ok(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ gnutls_session_t sess = vpninfo->https_sess;
|
||||
+
|
||||
+ if (!sess)
|
||||
+ return -EINVAL;
|
||||
+ if (gnutls_protocol_get_version(sess) > GNUTLS_TLS1_2) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("NLB blob decrypt requires TLS 1.2 portal session\n"));
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ return 0;
|
||||
}
|
||||
|
||||
static int gp_aes_cbc_decrypt(const unsigned char *key, size_t key_size,
|
||||
@@ -3622,8 +3645,7 @@
|
||||
iv_d.data = (unsigned char *)iv;
|
||||
iv_d.size = iv_size;
|
||||
|
||||
- err = gnutls_cipher_init(&hd, key_size == 32 ? GNUTLS_CIPHER_AES_256_CBC :
|
||||
- GNUTLS_CIPHER_AES_128_CBC, &enc_key, &iv_d);
|
||||
+ err = gnutls_cipher_init(&hd, gp_gnutls_aes_cbc_cipher(key_size), &enc_key, &iv_d);
|
||||
if (err)
|
||||
return -EINVAL;
|
||||
|
||||
@@ -3687,6 +3709,9 @@
|
||||
if (!sess || !in || inlen <= 0 || !out || !outlen)
|
||||
return -EINVAL;
|
||||
|
||||
+ if (gp_ssl_decrypt_session_ok(vpninfo) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
if (gp_tls12_expand_keys(sess, key_block, sizeof(key_block),
|
||||
&key_size, &mac_size, &iv_size,
|
||||
&srv_key, &srv_iv) < 0)
|
||||
@@ -3711,6 +3736,9 @@
|
||||
if (!sess || !key || key_len <= 0 || !in || inlen <= 0 || !out || !outlen)
|
||||
return -EINVAL;
|
||||
|
||||
+ if (gp_ssl_decrypt_session_ok(vpninfo) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
if (gp_tls12_expand_keys(sess, key_block, sizeof(key_block),
|
||||
&key_size, &mac_size, &iv_size,
|
||||
&srv_key, &srv_iv) < 0)
|
||||
--- a/openssl.c
|
||||
+++ b/openssl.c
|
||||
@@ -2834,6 +2834,21 @@
|
||||
return 0;
|
||||
}
|
||||
|
||||
+static int gp_ssl_decrypt_session_ok(struct openconnect_info *vpninfo)
|
||||
+{
|
||||
+ SSL *ssl = vpninfo->https_ssl;
|
||||
+
|
||||
+ if (!ssl)
|
||||
+ return -EINVAL;
|
||||
+ if (SSL_version(ssl) > TLS1_2_VERSION) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("NLB blob decrypt requires TLS 1.2 portal session (got %s)\n"),
|
||||
+ SSL_get_version(ssl));
|
||||
+ return -EINVAL;
|
||||
+ }
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
static int gp_tls12_expand_keys(SSL *ssl,
|
||||
unsigned char *key_block, size_t key_block_len,
|
||||
size_t *mac_len, size_t *key_len, size_t *iv_len,
|
||||
@@ -2894,6 +2909,9 @@
|
||||
if (!ssl || !in || inlen <= 0 || !out || !outlen)
|
||||
return -EINVAL;
|
||||
|
||||
+ if (gp_ssl_decrypt_session_ok(vpninfo) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
if (gp_tls12_expand_keys(ssl, key_block, sizeof(key_block),
|
||||
&mac_len, &key_len, &iv_len,
|
||||
&srv_key, &srv_iv) < 0)
|
||||
@@ -2918,6 +2936,9 @@
|
||||
if (!ssl || !key || key_len <= 0 || !in || inlen <= 0 || !out || !outlen)
|
||||
return -EINVAL;
|
||||
|
||||
+ if (gp_ssl_decrypt_session_ok(vpninfo) < 0)
|
||||
+ return -EINVAL;
|
||||
+
|
||||
if (gp_tls12_expand_keys(ssl, key_block, sizeof(key_block),
|
||||
&mac_len, &blk_key_len, &blk_iv_len,
|
||||
&srv_key, &srv_iv) < 0)
|
||||
--- a/esp.c
|
||||
+++ b/esp.c
|
||||
@@ -211,8 +211,11 @@
|
||||
|
||||
if (nlb_ret > 0)
|
||||
continue;
|
||||
- if (nlb_ret < 0)
|
||||
+ if (nlb_ret < 0) {
|
||||
+ vpn_progress(vpninfo, PRG_INFO,
|
||||
+ _("Dropped invalid NLB ESP envelope packet\n"));
|
||||
continue;
|
||||
+ }
|
||||
}
|
||||
|
||||
/* both supported algos (SHA1 and MD5) have 12-byte MAC lengths (RFC2403 and RFC2404) */
|
||||
--- a/tests/gp-nlb-opaque-auth
|
||||
+++ b/tests/gp-nlb-opaque-auth
|
||||
@@ -1,21 +1,35 @@
|
||||
#!/bin/sh
|
||||
-# Validate NLB tunnel-opaque auth extraction and HMAC-SHA1 header signing
|
||||
+# Validate NLB envelope HMAC-SHA1 signing vectors
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
CC="${CC:-cc}"
|
||||
TMP=$(mktemp -d)
|
||||
trap 'rm -rf "$TMP"' EXIT
|
||||
|
||||
+CFLAGS="${CFLAGS:-}"
|
||||
+LIBS="${LIBS:-}"
|
||||
+if pkg-config --exists openssl 2>/dev/null; then
|
||||
+ CFLAGS="$CFLAGS $(pkg-config --cflags openssl)"
|
||||
+ LIBS="$LIBS $(pkg-config --libs openssl)"
|
||||
+elif pkg-config --exists libssl 2>/dev/null; then
|
||||
+ CFLAGS="$CFLAGS $(pkg-config --cflags libssl)"
|
||||
+ LIBS="$LIBS $(pkg-config --libs libssl)"
|
||||
+else
|
||||
+ CFLAGS="$CFLAGS -I/usr/include -I/usr/local/include -I/opt/homebrew/include"
|
||||
+ LIBS="$LIBS -lcrypto -lssl"
|
||||
+fi
|
||||
+
|
||||
cat > "$TMP/test.c" <<'EOF'
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <arpa/inet.h>
|
||||
+#include <openssl/hmac.h>
|
||||
+#include <openssl/sha.h>
|
||||
|
||||
#define GP_NLB_HDR_LEN 16
|
||||
#define GP_NLB_MAGIC 0x1a2b3c4d
|
||||
#define GP_NLB_HDR_AUTH_LEN 6
|
||||
-#define GP_NLB_OPAQUE_AUTH_OFF 8
|
||||
#define GP_NLB_HDR_SIGN_LEN 10
|
||||
|
||||
static inline void store_be32(void *p, uint32_t d)
|
||||
@@ -30,13 +44,6 @@
|
||||
memcpy(p, &n, 2);
|
||||
}
|
||||
|
||||
-static inline uint32_t load_be32(const void *p)
|
||||
-{
|
||||
- uint32_t n;
|
||||
- memcpy(&n, p, 4);
|
||||
- return ntohl(n);
|
||||
-}
|
||||
-
|
||||
static void write_hdr(unsigned char *hdr, uint16_t seq, uint16_t inner_len, uint8_t type)
|
||||
{
|
||||
store_be32(hdr, GP_NLB_MAGIC);
|
||||
@@ -47,37 +54,61 @@
|
||||
memset(hdr + 10, 0, GP_NLB_HDR_AUTH_LEN);
|
||||
}
|
||||
|
||||
+static int nlb_hmac_sha1(const unsigned char *key, int key_len,
|
||||
+ const unsigned char *hdr, int hdrlen,
|
||||
+ const unsigned char *esp, int esplen,
|
||||
+ unsigned char *out)
|
||||
+{
|
||||
+ unsigned char mac[SHA_DIGEST_LENGTH];
|
||||
+ unsigned int maclen = sizeof(mac);
|
||||
+ HMAC_CTX *ctx;
|
||||
+
|
||||
+ ctx = HMAC_CTX_new();
|
||||
+ if (!ctx)
|
||||
+ return -1;
|
||||
+ if (!HMAC_Init_ex(ctx, key, key_len, EVP_sha1(), NULL) ||
|
||||
+ !HMAC_Update(ctx, hdr, hdrlen) ||
|
||||
+ (esplen > 0 && !HMAC_Update(ctx, esp, esplen)) ||
|
||||
+ !HMAC_Final(ctx, mac, &maclen)) {
|
||||
+ HMAC_CTX_free(ctx);
|
||||
+ return -1;
|
||||
+ }
|
||||
+ HMAC_CTX_free(ctx);
|
||||
+ memcpy(out, mac, GP_NLB_HDR_AUTH_LEN);
|
||||
+ return 0;
|
||||
+}
|
||||
+
|
||||
+static int check_tag(const unsigned char *got, const unsigned char *expect)
|
||||
+{
|
||||
+ return memcmp(got, expect, GP_NLB_HDR_AUTH_LEN) == 0 ? 0 : 1;
|
||||
+}
|
||||
+
|
||||
int main(void)
|
||||
{
|
||||
- unsigned char opaque[32];
|
||||
- unsigned char hdr_auth[GP_NLB_HDR_AUTH_LEN];
|
||||
+ unsigned char key[16];
|
||||
unsigned char hdr[GP_NLB_HDR_LEN];
|
||||
+ unsigned char mac[GP_NLB_HDR_AUTH_LEN];
|
||||
+ unsigned char esp[8] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88 };
|
||||
int i;
|
||||
|
||||
- for (i = 0; i < (int)sizeof(opaque); i++)
|
||||
- opaque[i] = (unsigned char)i;
|
||||
- memcpy(hdr_auth, opaque + GP_NLB_OPAQUE_AUTH_OFF, GP_NLB_HDR_AUTH_LEN);
|
||||
- if (hdr_auth[0] != 0x08 || hdr_auth[1] != 0x09 || hdr_auth[5] != 0x0d)
|
||||
- return 1;
|
||||
+ for (i = 0; i < (int)sizeof(key); i++)
|
||||
+ key[i] = (unsigned char)(0xa0 + i);
|
||||
|
||||
- write_hdr(hdr, 0x0102, 0x0304, 1);
|
||||
- if (load_be32(hdr) != GP_NLB_MAGIC)
|
||||
+ write_hdr(hdr, 1, 8, 1);
|
||||
+ if (nlb_hmac_sha1(key, sizeof(key), hdr, GP_NLB_HDR_SIGN_LEN, esp, sizeof(esp), mac) < 0)
|
||||
return 1;
|
||||
- if (hdr[8] != 1 || hdr[9] != 0)
|
||||
+ if (check_tag(mac, (unsigned char[]){ 0x92, 0x72, 0xfd, 0x6e, 0xa1, 0xd6 }))
|
||||
return 1;
|
||||
|
||||
- /* Precomputed with hs-key=0xa0..0xaf, seq=1, inner_len=8, type=1, esp=11223344... */
|
||||
- write_hdr(hdr, 1, 8, 1);
|
||||
- memcpy(hdr + GP_NLB_HDR_SIGN_LEN,
|
||||
- (unsigned char[]){ 0x92, 0x72, 0xfd, 0x6e, 0xa1, 0xd6 }, GP_NLB_HDR_AUTH_LEN);
|
||||
-
|
||||
write_hdr(hdr, 2, 0, 0);
|
||||
- memcpy(hdr + GP_NLB_HDR_SIGN_LEN,
|
||||
- (unsigned char[]){ 0x82, 0xb4, 0xd9, 0xc5, 0x67, 0xbf }, GP_NLB_HDR_AUTH_LEN);
|
||||
+ if (nlb_hmac_sha1(key, sizeof(key), hdr, GP_NLB_HDR_SIGN_LEN, NULL, 0, mac) < 0)
|
||||
+ return 1;
|
||||
+ if (check_tag(mac, (unsigned char[]){ 0x82, 0xb4, 0xd9, 0xc5, 0x67, 0xbf }))
|
||||
+ return 1;
|
||||
|
||||
printf("gp-nlb-opaque-auth: OK\n");
|
||||
return 0;
|
||||
}
|
||||
EOF
|
||||
-$CC -o "$TMP/test" "$TMP/test.c"
|
||||
+$CC $CFLAGS -o "$TMP/test" "$TMP/test.c" $LIBS
|
||||
"$TMP/test"
|
||||
\ No newline at end of file
|
||||
-146
@@ -1,146 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 26 Jun 2026 01:00:00 +0800
|
||||
Subject: [PATCH 18/18] Cleanup NLB dead fields and error handling
|
||||
|
||||
Remove unused hdr_auth/opaque_auth_ready state, reconnect on opaque
|
||||
refresh failure, and log outbound NLB encap failures at ERR level.
|
||||
---
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -84,12 +84,8 @@
|
||||
#define GP_NLB_BLOB_CIPHER_OFF 28
|
||||
#define GP_NLB_ENC_HS_KEY_CIPHER_LEN 36
|
||||
#define GP_NLB_HDR_AUTH_LEN 6
|
||||
-#define GP_NLB_OPAQUE_AUTH_OFF 8
|
||||
#define GP_NLB_HDR_SIGN_LEN 10
|
||||
|
||||
-static void gp_nlb_apply_decrypted_opaque(struct openconnect_info *vpninfo,
|
||||
- struct gp_nlb_config *nlb);
|
||||
-
|
||||
static int gp_nlb_is_ipv4(const char *s)
|
||||
{
|
||||
struct in_addr a;
|
||||
@@ -146,8 +142,6 @@
|
||||
nlb->decrypted_opaque_len = 0;
|
||||
memset(nlb->opaque_key, 0, sizeof(nlb->opaque_key));
|
||||
nlb->opaque_key_len = 0;
|
||||
- memset(nlb->hdr_auth, 0, sizeof(nlb->hdr_auth));
|
||||
- nlb->opaque_auth_ready = 0;
|
||||
}
|
||||
|
||||
static void gp_nlb_clear_opaque_blob(struct gp_nlb_config *nlb)
|
||||
@@ -241,38 +235,11 @@
|
||||
gp_nlb_clear_decrypted_opaque(nlb);
|
||||
nlb->decrypted_opaque = out;
|
||||
nlb->decrypted_opaque_len = out_len;
|
||||
- gp_nlb_apply_decrypted_opaque(vpninfo, nlb);
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("Decrypted tunnel-opaque body (%d bytes)\n"), out_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
-static void gp_nlb_apply_decrypted_opaque(struct openconnect_info *vpninfo,
|
||||
- struct gp_nlb_config *nlb)
|
||||
-{
|
||||
- if (!nlb->decrypted_opaque) {
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB decrypted opaque missing; cannot extract hdr auth material\n"));
|
||||
- return;
|
||||
- }
|
||||
- if (nlb->decrypted_opaque_len < GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN) {
|
||||
- vpn_progress(vpninfo, PRG_INFO,
|
||||
- _("NLB decrypted opaque too short (%d bytes, need %d); auth material unavailable\n"),
|
||||
- nlb->decrypted_opaque_len,
|
||||
- GP_NLB_OPAQUE_AUTH_OFF + GP_NLB_HDR_AUTH_LEN);
|
||||
- return;
|
||||
- }
|
||||
-
|
||||
- memcpy(nlb->hdr_auth,
|
||||
- nlb->decrypted_opaque + GP_NLB_OPAQUE_AUTH_OFF,
|
||||
- GP_NLB_HDR_AUTH_LEN);
|
||||
- nlb->opaque_auth_ready = 1;
|
||||
- vpn_progress(vpninfo, PRG_DEBUG,
|
||||
- _("NLB tunnel-opaque auth material ready (offset %d, %d bytes)\n"),
|
||||
- GP_NLB_OPAQUE_AUTH_OFF, GP_NLB_HDR_AUTH_LEN);
|
||||
- dump_buf_hex(vpninfo, PRG_DEBUG, '=', nlb->hdr_auth, GP_NLB_HDR_AUTH_LEN);
|
||||
-}
|
||||
-
|
||||
static void gp_nlb_write_hdr(unsigned char *hdr, struct gp_nlb_config *nlb,
|
||||
uint16_t inner_len, uint8_t type)
|
||||
{
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -410,8 +410,6 @@
|
||||
uint32_t blob_session_id;
|
||||
unsigned char opaque_key[48];
|
||||
int opaque_key_len;
|
||||
- unsigned char hdr_auth[6];
|
||||
- int opaque_auth_ready;
|
||||
uint16_t wire_seq;
|
||||
int keepalive_sent;
|
||||
};
|
||||
--- a/gpst.c
|
||||
+++ b/gpst.c
|
||||
@@ -1343,7 +1343,12 @@
|
||||
/* fall through */
|
||||
case DTLS_ESTABLISHED:
|
||||
/* Rekey or check-and-resubmit HIP if needed */
|
||||
- if (gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
+ ret = gpst_nlb_maintenance(vpninfo, timeout);
|
||||
+ if (ret < 0) {
|
||||
+ vpninfo->dtls_need_reconnect = 1;
|
||||
+ return 1;
|
||||
+ }
|
||||
+ if (ret > 0)
|
||||
return 1;
|
||||
if (keepalive_action(&vpninfo->ssl_times, timeout) == KA_REKEY)
|
||||
goto do_rekey;
|
||||
@@ -1375,7 +1380,10 @@
|
||||
;
|
||||
}
|
||||
|
||||
- if (gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
+ ret = gpst_nlb_maintenance(vpninfo, timeout);
|
||||
+ if (ret < 0)
|
||||
+ goto do_reconnect;
|
||||
+ if (ret > 0)
|
||||
work_done = 1;
|
||||
|
||||
if (vpninfo->ssl_fd == -1)
|
||||
@@ -1801,7 +1809,7 @@
|
||||
if (pktlen < 0)
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Failed to send ESP probe\n"));
|
||||
else if (vpninfo->gp_nlb.enabled && gpst_nlb_esp_encap(vpninfo, pkt, &pktlen) < 0)
|
||||
- vpn_progress(vpninfo, PRG_DEBUG, _("Failed to NLB-wrap ESP probe\n"));
|
||||
+ vpn_progress(vpninfo, PRG_ERR, _("Failed to NLB-wrap ESP probe\n"));
|
||||
else if (send(vpninfo->dtls_fd, (void *)&pkt->esp, pktlen, 0) < 0)
|
||||
vpn_progress(vpninfo, PRG_DEBUG, _("Failed to send ESP probe\n"));
|
||||
|
||||
--- a/esp.c
|
||||
+++ b/esp.c
|
||||
@@ -360,8 +360,13 @@
|
||||
vpninfo->dtls_times.last_tx = now;
|
||||
}
|
||||
|
||||
- if (vpninfo->proto->proto == PROTO_GPST && gpst_nlb_maintenance(vpninfo, timeout) > 0)
|
||||
- work_done = 1;
|
||||
+ if (vpninfo->proto->proto == PROTO_GPST) {
|
||||
+ ret = gpst_nlb_maintenance(vpninfo, timeout);
|
||||
+ if (ret < 0)
|
||||
+ goto need_reconnect;
|
||||
+ if (ret > 0)
|
||||
+ work_done = 1;
|
||||
+ }
|
||||
|
||||
if (vpninfo->dtls_state != DTLS_ESTABLISHED)
|
||||
return work_done;
|
||||
@@ -459,6 +464,8 @@
|
||||
|
||||
if (vpninfo->proto->proto == PROTO_GPST && vpninfo->gp_nlb.enabled &&
|
||||
gpst_nlb_esp_encap(vpninfo, this, &len) < 0) {
|
||||
+ vpn_progress(vpninfo, PRG_ERR,
|
||||
+ _("Failed to NLB-wrap outbound ESP packet\n"));
|
||||
free_pkt(vpninfo, this);
|
||||
work_done = 1;
|
||||
continue;
|
||||
@@ -1,98 +0,0 @@
|
||||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Kevin Yue <[email protected]>
|
||||
Date: Thu, 26 Jun 2026 01:30:00 +0800
|
||||
Subject: [PATCH 19/19] Fix NLB prepare opaque-key wipe
|
||||
|
||||
Stop gp_nlb_clear_decrypted_opaque from zeroing opaque_key after
|
||||
enc-hs-key decipherment, and replace unused decrypted_opaque storage
|
||||
with an opaque_body_ready flag that discards plaintext after verify.
|
||||
---
|
||||
--- a/gpst_nlb.c
|
||||
+++ b/gpst_nlb.c
|
||||
@@ -132,21 +132,11 @@
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
-static void gp_nlb_clear_decrypted_opaque(struct gp_nlb_config *nlb)
|
||||
+static void gp_nlb_clear_opaque_blob(struct gp_nlb_config *nlb)
|
||||
{
|
||||
- if (nlb->decrypted_opaque) {
|
||||
- memset(nlb->decrypted_opaque, 0, nlb->decrypted_opaque_len);
|
||||
- free(nlb->decrypted_opaque);
|
||||
- nlb->decrypted_opaque = NULL;
|
||||
- }
|
||||
- nlb->decrypted_opaque_len = 0;
|
||||
+ nlb->opaque_body_ready = 0;
|
||||
memset(nlb->opaque_key, 0, sizeof(nlb->opaque_key));
|
||||
nlb->opaque_key_len = 0;
|
||||
-}
|
||||
-
|
||||
-static void gp_nlb_clear_opaque_blob(struct gp_nlb_config *nlb)
|
||||
-{
|
||||
- gp_nlb_clear_decrypted_opaque(nlb);
|
||||
if (nlb->opaque_blob) {
|
||||
memset(nlb->opaque_blob, 0, nlb->opaque_blob_len);
|
||||
free(nlb->opaque_blob);
|
||||
@@ -232,9 +222,9 @@
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
- gp_nlb_clear_decrypted_opaque(nlb);
|
||||
- nlb->decrypted_opaque = out;
|
||||
- nlb->decrypted_opaque_len = out_len;
|
||||
+ memset(out, 0, out_len);
|
||||
+ free(out);
|
||||
+ nlb->opaque_body_ready = 1;
|
||||
vpn_progress(vpninfo, PRG_DEBUG,
|
||||
_("Decrypted tunnel-opaque body (%d bytes)\n"), out_len);
|
||||
return 0;
|
||||
@@ -375,20 +365,16 @@
|
||||
_("NLB requires hs-key for envelope authentication\n"));
|
||||
return -EINVAL;
|
||||
}
|
||||
- if (nlb->enc_hs_key && !nlb->opaque_key_len) {
|
||||
- vpn_progress(vpninfo, PRG_ERR,
|
||||
- _("NLB enc-hs-key present but decipherment produced no key\n"));
|
||||
- return -EINVAL;
|
||||
- }
|
||||
- if (nlb->tunnel_opaque && !nlb->decrypted_opaque_len) {
|
||||
+ if (nlb->tunnel_opaque && !nlb->opaque_body_ready) {
|
||||
vpn_progress(vpninfo, PRG_ERR,
|
||||
_("NLB tunnel-opaque present but decipherment failed\n"));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
vpn_progress(vpninfo, PRG_INFO,
|
||||
- _("NLB crypto ready: hs_key=%d bytes opaque_key=%d bytes decrypted_opaque=%d bytes\n"),
|
||||
- nlb->hs_key_len, nlb->opaque_key_len, nlb->decrypted_opaque_len);
|
||||
+ _("NLB crypto ready: hs_key=%d bytes opaque_key=%d bytes opaque_body=%s\n"),
|
||||
+ nlb->hs_key_len, nlb->opaque_key_len,
|
||||
+ nlb->opaque_body_ready ? "ready" : "none");
|
||||
return 0;
|
||||
}
|
||||
|
||||
--- a/openconnect-internal.h
|
||||
+++ b/openconnect-internal.h
|
||||
@@ -405,8 +405,7 @@
|
||||
char *in_tunnel_gw_cert_chksum;
|
||||
unsigned char *opaque_blob;
|
||||
int opaque_blob_len;
|
||||
- unsigned char *decrypted_opaque;
|
||||
- int decrypted_opaque_len;
|
||||
+ int opaque_body_ready;
|
||||
uint32_t blob_session_id;
|
||||
unsigned char opaque_key[48];
|
||||
int opaque_key_len;
|
||||
--- a/library.c
|
||||
+++ b/library.c
|
||||
@@ -845,10 +845,6 @@
|
||||
free(vpninfo->gp_nlb.tunnel_vip);
|
||||
free(vpninfo->gp_nlb.connected_gw_ip);
|
||||
free(vpninfo->gp_nlb.in_tunnel_gw_cert_chksum);
|
||||
- if (vpninfo->gp_nlb.decrypted_opaque) {
|
||||
- memset(vpninfo->gp_nlb.decrypted_opaque, 0, vpninfo->gp_nlb.decrypted_opaque_len);
|
||||
- free(vpninfo->gp_nlb.decrypted_opaque);
|
||||
- }
|
||||
memset(vpninfo->gp_nlb.opaque_key, 0, sizeof(vpninfo->gp_nlb.opaque_key));
|
||||
if (vpninfo->gp_nlb.opaque_blob) {
|
||||
memset(vpninfo->gp_nlb.opaque_blob, 0, vpninfo->gp_nlb.opaque_blob_len);
|
||||
Reference in new issue
Block a user