diff --git a/crates/openconnect/deps/patches/0014-Implement-exact-PanGPS-do_ssl_decrypt-handling.patch b/crates/openconnect/deps/patches/0014-Implement-exact-PanGPS-do_ssl_decrypt-handling.patch new file mode 100644 index 0000000..4b7f32c --- /dev/null +++ b/crates/openconnect/deps/patches/0014-Implement-exact-PanGPS-do_ssl_decrypt-handling.patch @@ -0,0 +1,453 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Kevin Yue +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 +@@ -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;