net: tls: add socket diag
Subsystems (6)
v3 cover net: tls: add socket diag
The current kernel does not provide any diagnostic tool, except getsockopt(TCP_ULP), to know more about TCP sockets that have an upper layer protocol (ULP) on top of them. This series extends the set of information exported by INET_DIAG_INFO, to include data that are specific to the ULP (and that might be meaningful for debug/testing purposes).
patch 1/3 ensures that the control plane reads/updates ULP specific data using RCU.
patch 2/3 extends INET_DIAG_INFO and allows knowing the ULP name for each TCP socket that has done setsockopt(TCP_ULP) successfully.
patch 3/3 extends kTLS to let programs like 'ss' know the protocol version and the cipher in use.
Changes since v2:
- remove unneeded #ifdef and fix reverse christmas tree in tls_get_info(), thanks to Jakub Kicinski
Changes since v1:
- don't worry about grace period when accessing ulp_ops, thanks to Jakub Kicinski and Eric Dumazet
- use rcu_dereference() to access ULP data in tls get_info(), and test against NULL value, thanks to Jakub Kicinski
- move RCU protected section inside tls get_info(), thanks to Jakub Kicinski
Changes since RFC:
- some coding style fixes, thanks to Jakub Kicinski
- add X_UNSPEC as lowest value of uAPI enums, thanks to Jakub Kicinski
- fix assignment of struct nlattr *start, thanks to Jakub Kicinski
- let tls dump RXCONF and TXCONF, suggested by Jakub Kicinski
- don't dump anything if TLS version or cipher are 0 (but still return a constant size in get_aux_size()), thanks to Boris Pismenny
- constify first argument of get_info() and get_size()
- use RCU to access access ulp_ops, like it's done for ca_ops
- add patch 1/3, from Jakub Kicinski
Davide Caratti (2):
tcp: ulp: add functions to dump ulp-specific information
net: tls: export protocol version, cipher, tx_conf/rx_conf to socket
diag
Jakub Kicinski (1):
net/tls: use RCU protection on icsk->icsk_ulp_data
include/net/inet_connection_sock.h | 2 +- include/net/tcp.h | 3 + include/net/tls.h | 26 ++++++++- include/uapi/linux/inet_diag.h | 9 +++ include/uapi/linux/tls.h | 15 +++++ net/core/sock_map.c | 2 +- net/ipv4/tcp_diag.c | 52 ++++++++++++++++- net/tls/tls_device.c | 2 +- net/tls/tls_main.c | 90 +++++++++++++++++++++++++++--- 9 files changed, 188 insertions(+), 13 deletions(-)
Signature · 1 line
2.20.1
PATCH v3 1/3 net/tls: use RCU protection on icsk->icsk_ulp_data
From: Jakub Kicinski <[email protected]>
We need to make sure context does not get freed while diag code is interrogating it. Free struct tls_context with kfree_rcu().
We add the __rcu annotation directly in icsk, and cast it away in the datapath accessor. Presumably all ULPs will do a similar thing.
--- include/net/inet_connection_sock.h | 2 +- include/net/tls.h | 9 +++++++-- net/core/sock_map.c | 2 +- net/tls/tls_device.c | 2 +- net/tls/tls_main.c | 26 +++++++++++++++++++------- 5 files changed, 29 insertions(+), 12 deletions(-)
include/net/inet_connection_sock.h +1 -1
@@ -97,7 +97,7 @@ struct inet_connection_sock {const struct tcp_congestion_ops *icsk_ca_ops;const struct inet_connection_sock_af_ops *icsk_af_ops;const struct tcp_ulp_ops *icsk_ulp_ops; -void *icsk_ulp_data; +void __rcu *icsk_ulp_data;void (*icsk_clean_acked)(struct sock *sk,u32 acked_seq);struct hlist_node icsk_listen_portaddr_node;unsigned int (*icsk_sync_mss)(struct sock *sk,u32 pmtu);
include/net/tls.h +7 -2
@@ -41,6 +41,7 @@#include <linux/tcp.h> #include <linux/skmsg.h> #include <linux/netdevice.h> +#include <linux/rcupdate.h> #include <net/tcp.h> #include <net/strparser.h>
@@ -290,6 +291,7 @@ struct tls_context {struct list_head list;refcount_t refcount; +struct rcu_head rcu; };enum tls_offload_ctx_dir {
@@ -348,7 +350,7 @@ struct tls_offload_context_rx {#define TLS_OFFLOAD_CONTEXT_SIZE_RX \ (sizeof(struct tls_offload_context_rx) + TLS_DRIVER_STATE_SIZE_RX) -void tls_ctx_free (struct tls_context *ctx); +void tls_ctx_free (struct sock *sk,struct tls_context *ctx);int wait_on_pending_writer (struct sock *sk,long *timeo);int tls_sk_query (struct sock *sk,int optname,char __user *optval,int __user *optlen);
@@ -467,7 +469,10 @@ static inline struct tls_context *tls_get_ctx(const struct sock *sk) {struct inet_connection_sock *icsk =inet_csk (sk); -return icsk->icsk_ulp_data; +/* Use RCU on icsk_ulp_data only for sock diag code, +* TLS data path doesn't need rcu_dereference(). +*/ +return (__force void *)icsk->icsk_ulp_data; } static inline void tls_advance_record_sn(struct sock *sk,
net/core/sock_map.c +1 -1
@@ -345,7 +345,7 @@ static int sock_map_update_common(struct bpf_map *map, u32 idx,return -EINVAL ;if (unlikely (idx >= map->max_entries))return -E2BIG ; -if (unlikely (icsk->icsk_ulp_data)) +if (unlikely (rcu_access_pointer (icsk->icsk_ulp_data)))return -EINVAL ; link =sk_psock_init_link ();
net/tls/tls_device.c +1 -1
@@ -61,7 +61,7 @@ static void tls_device_free_ctx(struct tls_context *ctx)if (ctx->rx_conf ==TLS_HW )kfree (tls_offload_ctx_rx (ctx)); -tls_ctx_free (ctx); +tls_ctx_free (NULL , ctx); }static void tls_device_gc_task (struct work_struct *work)
net/tls/tls_main.c +19 -7
@@ -251,14 +251,26 @@ static void tls_write_space(struct sock *sk) ctx->sk_write_space (sk); } -void tls_ctx_free (struct tls_context *ctx) +/** +* tls_ctx_free() - free TLS ULP context +* @sk: socket to with @ctx is attached +* @ctx: TLS context structure +* +* Free TLS context. If @sk is %NULL caller guarantees that the socket +* to which @ctx was attached has no outstanding references. +*/ +void tls_ctx_free (struct sock *sk,struct tls_context *ctx) {if (!ctx)return ;memzero_explicit (&ctx->crypto_send,sizeof (ctx->crypto_send));memzero_explicit (&ctx->crypto_recv,sizeof (ctx->crypto_recv)); -kfree (ctx); + +if (sk) +kfree_rcu (ctx, rcu); +else +kfree (ctx); } static void tls_sk_proto_cleanup(struct sock *sk,
@@ -306,7 +318,7 @@ static void tls_sk_proto_close(struct sock *sk, long timeout)write_lock_bh (&sk->sk_callback_lock);if (free_ctx) - icsk->icsk_ulp_data =NULL ; +rcu_assign_pointer (icsk->icsk_ulp_data,NULL ); sk->sk_prot = ctx->sk_proto;if (sk->sk_write_space == tls_write_space) sk->sk_write_space = ctx->sk_write_space;
@@ -321,7 +333,7 @@ static void tls_sk_proto_close(struct sock *sk, long timeout) ctx->sk_proto_close (sk, timeout);if (free_ctx) -tls_ctx_free (ctx); +tls_ctx_free (sk, ctx); } static int do_tls_getsockopt_tx(struct sock *sk, char __user *optval,
@@ -610,7 +622,7 @@ static struct tls_context *create_ctx(struct sock *sk)if (!ctx)return NULL ; - icsk->icsk_ulp_data = ctx; +rcu_assign_pointer (icsk->icsk_ulp_data, ctx); ctx->setsockopt = sk->sk_prot->setsockopt; ctx->getsockopt = sk->sk_prot->getsockopt; ctx->sk_proto_close = sk->sk_prot->close;
@@ -651,8 +663,8 @@ static void tls_hw_sk_destruct(struct sock *sk) ctx->sk_destruct (sk);/* Free ctx */ -tls_ctx_free (ctx); - icsk->icsk_ulp_data =NULL ; +rcu_assign_pointer (icsk->icsk_ulp_data,NULL ); +tls_ctx_free (sk, ctx); }static int tls_hw_prot (struct sock *sk)
Signature · 1 line
2.20.1
PATCH v3 2/3 tcp: ulp: add functions to dump ulp-specific information
In reply to Davide Caratticurrently, only getsockopt(TCP_ULP) can be invoked to know if a ULP is on top of a TCP socket. Extend idiag_get_aux() and idiag_get_aux_size(), introduced by commit b37e88407c1d ("inet_diag: allow protocols to provide additional data"), to report the ULP name and other information that can be made available by the ULP through optional functions.
Users having CAP_NET_ADMIN privileges will then be able to retrieve this information through inet_diag_handler, if they specify INET_DIAG_INFO in the request.
--- include/net/tcp.h | 3 ++ include/uapi/linux/inet_diag.h | 8 ++++++ net/ipv4/tcp_diag.c | 52 +++++++++++++++++++++++++++++++++- 3 files changed, 62 insertions(+), 1 deletion(-)
include/net/tcp.h +3 -0
@@ -2122,6 +2122,9 @@ struct tcp_ulp_ops {void (*update)(struct sock *sk,struct proto *p);/* cleanup ulp */ void (*release)(struct sock *sk); +/* diagnostic */ +int (*get_info)(const struct sock *sk,struct sk_buff *skb); +size_t (*get_info_size)(const struct sock *sk);char name[TCP_ULP_NAME_MAX ];struct module *owner;
include/uapi/linux/inet_diag.h +8 -0
@@ -153,11 +153,19 @@ enum {INET_DIAG_BBRINFO ,/* request as INET_DIAG_VEGASINFO */ INET_DIAG_CLASS_ID ,/* request as INET_DIAG_TCLASS */ INET_DIAG_MD5SIG , +INET_DIAG_ULP_INFO , __INET_DIAG_MAX, };#define INET_DIAG_MAX (__INET_DIAG_MAX - 1) +enum { +INET_ULP_INFO_UNSPEC , +INET_ULP_INFO_NAME , + __INET_ULP_INFO_MAX, +}; +#define INET_ULP_INFO_MAX (__INET_ULP_INFO_MAX - 1) +/* INET_DIAG_MEM */ struct inet_diag_meminfo {
net/ipv4/tcp_diag.c +51 -1
81 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v3 3/3 net: tls: export protocol version, cipher, tx_conf/rx_conf to socket diag
In reply to Davide CarattiWhen an application configures kernel TLS on top of a TCP socket, it's now possible for inet_diag_handler() to collect information regarding the protocol version, the cipher type and TX / RX configuration, in case INET_DIAG_INFO is requested.
--- include/net/tls.h | 17 +++++++++ include/uapi/linux/inet_diag.h | 1 + include/uapi/linux/tls.h | 15 ++++++++ net/tls/tls_main.c | 64 ++++++++++++++++++++++++++++++++++ 4 files changed, 97 insertions(+)
include/net/tls.h +17 -0
@@ -431,6 +431,23 @@ static inline bool is_tx_ready(struct tls_sw_context_tx *ctx)return READ_ONCE (rec->tx_ready); } +static inline u16 tls_user_config (struct tls_context *ctx,bool tx) +{ +u16 config = tx ? ctx->tx_conf : ctx->rx_conf; + +switch (config) { +case TLS_BASE : +return TLS_CONF_BASE ; +case TLS_SW : +return TLS_CONF_SW ; +case TLS_HW : +return TLS_CONF_HW ; +case TLS_HW_RECORD : +return TLS_CONF_HW_RECORD ; + } +return 0 ; +} +struct sk_buff *tls_validate_xmit_skb (struct sock *sk,struct net_device *dev,struct sk_buff *skb);
include/uapi/linux/inet_diag.h +1 -0
@@ -162,6 +162,7 @@ enum {enum {INET_ULP_INFO_UNSPEC ,INET_ULP_INFO_NAME , +INET_ULP_INFO_TLS , __INET_ULP_INFO_MAX, };#define INET_ULP_INFO_MAX (__INET_ULP_INFO_MAX - 1)
include/uapi/linux/tls.h +15 -0
@@ -109,4 +109,19 @@ struct tls12_crypto_info_aes_ccm_128 { unsigned char rec_seq[TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE]; }; +enum { +TLS_INFO_UNSPEC , +TLS_INFO_VERSION , +TLS_INFO_CIPHER , +TLS_INFO_TXCONF , +TLS_INFO_RXCONF , + __TLS_INFO_MAX, +}; +#define TLS_INFO_MAX (__TLS_INFO_MAX - 1) + +#define TLS_CONF_BASE 1 +#define TLS_CONF_SW 2 +#define TLS_CONF_HW 3 +#define TLS_CONF_HW_RECORD 4 +#endif /* _UAPI_LINUX_TLS_H */
net/tls/tls_main.c +64 -0
82 lines not on this page · raw message
Signature · 1 line
2.20.1
Re: [PATCH net-next v3 3/3] net: tls: export protocol version, cipher, tx_conf/rx_conf to socket diag
Quoted 6 lines · Davide Caratti
When an application configures kernel TLS on top of a TCP socket, it's now possible for
inet_diag_handler()to collect information regarding the protocol version, the cipher type and TX / RX configuration, in caseINET_DIAG_INFOis requested.Signed-off-by Davide Caratti <[email protected]>
Thank you!
David Miller
maintainerFrom: Davide Caratti <[email protected]>
Date: Fri, 30 Aug 2019 12:25:46 +0200
Quoted 6 lines
The current kernel does not provide any diagnostic tool, except
getsockopt(TCP_ULP), to know more about TCP sockets that have an upper layer protocol (ULP) on top of them. This series extends the set of information exported byINET_DIAG_INFO, to include data that are specific to the ULP (and that might be meaningful for debug/testing purposes).
...
Series applied, thanks Davide.