Linux Audio

Check our new training course

Loading...
v3.15
 
 
 
 
  1#include <linux/kernel.h>
  2#include <linux/init.h>
  3#include <linux/cryptohash.h>
  4#include <linux/module.h>
  5#include <linux/cache.h>
  6#include <linux/random.h>
  7#include <linux/hrtimer.h>
  8#include <linux/ktime.h>
  9#include <linux/string.h>
 10#include <linux/net.h>
 11
 12#include <net/secure_seq.h>
 13
 14#if IS_ENABLED(CONFIG_IPV6) || IS_ENABLED(CONFIG_INET)
 15#define NET_SECRET_SIZE (MD5_MESSAGE_BYTES / 4)
 
 16
 17static u32 net_secret[NET_SECRET_SIZE] ____cacheline_aligned;
 
 18
 19static __always_inline void net_secret_init(void)
 20{
 21	net_get_random_once(net_secret, sizeof(net_secret));
 
 
 
 
 
 22}
 23#endif
 24
 25#ifdef CONFIG_INET
 26static u32 seq_scale(u32 seq)
 27{
 28	/*
 29	 *	As close as possible to RFC 793, which
 30	 *	suggests using a 250 kHz clock.
 31	 *	Further reading shows this assumes 2 Mb/s networks.
 32	 *	For 10 Mb/s Ethernet, a 1 MHz clock is appropriate.
 33	 *	For 10 Gb/s Ethernet, a 1 GHz clock should be ok, but
 34	 *	we also need to limit the resolution so that the u32 seq
 35	 *	overlaps less than one time per MSL (2 minutes).
 36	 *	Choosing a clock of 64 ns period is OK. (period of 274 s)
 37	 */
 38	return seq + (ktime_to_ns(ktime_get_real()) >> 6);
 39}
 40#endif
 41
 42#if IS_ENABLED(CONFIG_IPV6)
 43__u32 secure_tcpv6_sequence_number(const __be32 *saddr, const __be32 *daddr,
 44				   __be16 sport, __be16 dport)
 45{
 46	u32 secret[MD5_MESSAGE_BYTES / 4];
 47	u32 hash[MD5_DIGEST_WORDS];
 48	u32 i;
 49
 50	net_secret_init();
 51	memcpy(hash, saddr, 16);
 52	for (i = 0; i < 4; i++)
 53		secret[i] = net_secret[i] + (__force u32)daddr[i];
 54	secret[4] = net_secret[4] +
 55		(((__force u16)sport << 16) + (__force u16)dport);
 56	for (i = 5; i < MD5_MESSAGE_BYTES / 4; i++)
 57		secret[i] = net_secret[i];
 58
 59	md5_transform(hash, secret);
 60
 61	return seq_scale(hash[0]);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 62}
 63EXPORT_SYMBOL(secure_tcpv6_sequence_number);
 64
 65u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
 66			       __be16 dport)
 67{
 68	u32 secret[MD5_MESSAGE_BYTES / 4];
 69	u32 hash[MD5_DIGEST_WORDS];
 70	u32 i;
 71
 
 
 
 
 
 72	net_secret_init();
 73	memcpy(hash, saddr, 16);
 74	for (i = 0; i < 4; i++)
 75		secret[i] = net_secret[i] + (__force u32) daddr[i];
 76	secret[4] = net_secret[4] + (__force u32)dport;
 77	for (i = 5; i < MD5_MESSAGE_BYTES / 4; i++)
 78		secret[i] = net_secret[i];
 79
 80	md5_transform(hash, secret);
 81
 82	return hash[0];
 83}
 84EXPORT_SYMBOL(secure_ipv6_port_ephemeral);
 85#endif
 86
 87#ifdef CONFIG_INET
 88__u32 secure_ip_id(__be32 daddr)
 89{
 90	u32 hash[MD5_DIGEST_WORDS];
 91
 92	net_secret_init();
 93	hash[0] = (__force __u32) daddr;
 94	hash[1] = net_secret[13];
 95	hash[2] = net_secret[14];
 96	hash[3] = net_secret[15];
 97
 98	md5_transform(hash, net_secret);
 99
100	return hash[0];
101}
102
103__u32 secure_ipv6_id(const __be32 daddr[4])
104{
105	__u32 hash[4];
 
106
107	net_secret_init();
108	memcpy(hash, daddr, 16);
109	md5_transform(hash, net_secret);
110
111	return hash[0];
112}
113
114__u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
115				 __be16 sport, __be16 dport)
 
 
 
 
 
116{
117	u32 hash[MD5_DIGEST_WORDS];
118
119	net_secret_init();
120	hash[0] = (__force u32)saddr;
121	hash[1] = (__force u32)daddr;
122	hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
123	hash[3] = net_secret[15];
124
125	md5_transform(hash, net_secret);
126
127	return seq_scale(hash[0]);
128}
129
130u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport)
131{
132	u32 hash[MD5_DIGEST_WORDS];
133
134	net_secret_init();
135	hash[0] = (__force u32)saddr;
136	hash[1] = (__force u32)daddr;
137	hash[2] = (__force u32)dport ^ net_secret[14];
138	hash[3] = net_secret[15];
139
140	md5_transform(hash, net_secret);
141
142	return hash[0];
143}
144EXPORT_SYMBOL_GPL(secure_ipv4_port_ephemeral);
145#endif
146
147#if IS_ENABLED(CONFIG_IP_DCCP)
148u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
149				__be16 sport, __be16 dport)
150{
151	u32 hash[MD5_DIGEST_WORDS];
152	u64 seq;
153
154	net_secret_init();
155	hash[0] = (__force u32)saddr;
156	hash[1] = (__force u32)daddr;
157	hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
158	hash[3] = net_secret[15];
159
160	md5_transform(hash, net_secret);
161
162	seq = hash[0] | (((u64)hash[1]) << 32);
163	seq += ktime_to_ns(ktime_get_real());
164	seq &= (1ull << 48) - 1;
165
166	return seq;
167}
168EXPORT_SYMBOL(secure_dccp_sequence_number);
169
170#if IS_ENABLED(CONFIG_IPV6)
171u64 secure_dccpv6_sequence_number(__be32 *saddr, __be32 *daddr,
172				  __be16 sport, __be16 dport)
173{
174	u32 secret[MD5_MESSAGE_BYTES / 4];
175	u32 hash[MD5_DIGEST_WORDS];
 
 
 
 
 
 
 
 
 
176	u64 seq;
177	u32 i;
178
179	net_secret_init();
180	memcpy(hash, saddr, 16);
181	for (i = 0; i < 4; i++)
182		secret[i] = net_secret[i] + daddr[i];
183	secret[4] = net_secret[4] +
184		(((__force u16)sport << 16) + (__force u16)dport);
185	for (i = 5; i < MD5_MESSAGE_BYTES / 4; i++)
186		secret[i] = net_secret[i];
187
188	md5_transform(hash, secret);
189
190	seq = hash[0] | (((u64)hash[1]) << 32);
191	seq += ktime_to_ns(ktime_get_real());
192	seq &= (1ull << 48) - 1;
193
194	return seq;
195}
196EXPORT_SYMBOL(secure_dccpv6_sequence_number);
197#endif
198#endif
v4.17
  1/*
  2 * Copyright (C) 2016 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
  3 */
  4
  5#include <linux/kernel.h>
  6#include <linux/init.h>
  7#include <linux/cryptohash.h>
  8#include <linux/module.h>
  9#include <linux/cache.h>
 10#include <linux/random.h>
 11#include <linux/hrtimer.h>
 12#include <linux/ktime.h>
 13#include <linux/string.h>
 14#include <linux/net.h>
 15#include <linux/siphash.h>
 16#include <net/secure_seq.h>
 17
 18#if IS_ENABLED(CONFIG_IPV6) || IS_ENABLED(CONFIG_INET)
 19#include <linux/in6.h>
 20#include <net/tcp.h>
 21
 22static siphash_key_t net_secret __read_mostly;
 23static siphash_key_t ts_secret __read_mostly;
 24
 25static __always_inline void net_secret_init(void)
 26{
 27	net_get_random_once(&net_secret, sizeof(net_secret));
 28}
 29
 30static __always_inline void ts_secret_init(void)
 31{
 32	net_get_random_once(&ts_secret, sizeof(ts_secret));
 33}
 34#endif
 35
 36#ifdef CONFIG_INET
 37static u32 seq_scale(u32 seq)
 38{
 39	/*
 40	 *	As close as possible to RFC 793, which
 41	 *	suggests using a 250 kHz clock.
 42	 *	Further reading shows this assumes 2 Mb/s networks.
 43	 *	For 10 Mb/s Ethernet, a 1 MHz clock is appropriate.
 44	 *	For 10 Gb/s Ethernet, a 1 GHz clock should be ok, but
 45	 *	we also need to limit the resolution so that the u32 seq
 46	 *	overlaps less than one time per MSL (2 minutes).
 47	 *	Choosing a clock of 64 ns period is OK. (period of 274 s)
 48	 */
 49	return seq + (ktime_get_real_ns() >> 6);
 50}
 51#endif
 52
 53#if IS_ENABLED(CONFIG_IPV6)
 54u32 secure_tcpv6_ts_off(const struct net *net,
 55			const __be32 *saddr, const __be32 *daddr)
 56{
 57	const struct {
 58		struct in6_addr saddr;
 59		struct in6_addr daddr;
 60	} __aligned(SIPHASH_ALIGNMENT) combined = {
 61		.saddr = *(struct in6_addr *)saddr,
 62		.daddr = *(struct in6_addr *)daddr,
 63	};
 64
 65	if (net->ipv4.sysctl_tcp_timestamps != 1)
 66		return 0;
 67
 68	ts_secret_init();
 69	return siphash(&combined, offsetofend(typeof(combined), daddr),
 70		       &ts_secret);
 71}
 72EXPORT_SYMBOL(secure_tcpv6_ts_off);
 73
 74u32 secure_tcpv6_seq(const __be32 *saddr, const __be32 *daddr,
 75		     __be16 sport, __be16 dport)
 76{
 77	const struct {
 78		struct in6_addr saddr;
 79		struct in6_addr daddr;
 80		__be16 sport;
 81		__be16 dport;
 82	} __aligned(SIPHASH_ALIGNMENT) combined = {
 83		.saddr = *(struct in6_addr *)saddr,
 84		.daddr = *(struct in6_addr *)daddr,
 85		.sport = sport,
 86		.dport = dport
 87	};
 88	u32 hash;
 89
 90	net_secret_init();
 91	hash = siphash(&combined, offsetofend(typeof(combined), dport),
 92		       &net_secret);
 93	return seq_scale(hash);
 94}
 95EXPORT_SYMBOL(secure_tcpv6_seq);
 96
 97u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
 98			       __be16 dport)
 99{
100	const struct {
101		struct in6_addr saddr;
102		struct in6_addr daddr;
103		__be16 dport;
104	} __aligned(SIPHASH_ALIGNMENT) combined = {
105		.saddr = *(struct in6_addr *)saddr,
106		.daddr = *(struct in6_addr *)daddr,
107		.dport = dport
108	};
109	net_secret_init();
110	return siphash(&combined, offsetofend(typeof(combined), dport),
111		       &net_secret);
 
 
 
 
 
 
 
 
112}
113EXPORT_SYMBOL(secure_ipv6_port_ephemeral);
114#endif
115
116#ifdef CONFIG_INET
117u32 secure_tcp_ts_off(const struct net *net, __be32 saddr, __be32 daddr)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
118{
119	if (net->ipv4.sysctl_tcp_timestamps != 1)
120		return 0;
121
122	ts_secret_init();
123	return siphash_2u32((__force u32)saddr, (__force u32)daddr,
124			    &ts_secret);
 
 
125}
126
127/* secure_tcp_seq_and_tsoff(a, b, 0, d) == secure_ipv4_port_ephemeral(a, b, d),
128 * but fortunately, `sport' cannot be 0 in any circumstances. If this changes,
129 * it would be easy enough to have the former function use siphash_4u32, passing
130 * the arguments as separate u32.
131 */
132u32 secure_tcp_seq(__be32 saddr, __be32 daddr,
133		   __be16 sport, __be16 dport)
134{
135	u32 hash;
136
137	net_secret_init();
138	hash = siphash_3u32((__force u32)saddr, (__force u32)daddr,
139			    (__force u32)sport << 16 | (__force u32)dport,
140			    &net_secret);
141	return seq_scale(hash);
 
 
 
 
142}
143
144u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport)
145{
 
 
146	net_secret_init();
147	return siphash_3u32((__force u32)saddr, (__force u32)daddr,
148			    (__force u16)dport, &net_secret);
 
 
 
 
 
 
149}
150EXPORT_SYMBOL_GPL(secure_ipv4_port_ephemeral);
151#endif
152
153#if IS_ENABLED(CONFIG_IP_DCCP)
154u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
155				__be16 sport, __be16 dport)
156{
 
157	u64 seq;
 
158	net_secret_init();
159	seq = siphash_3u32((__force u32)saddr, (__force u32)daddr,
160			   (__force u32)sport << 16 | (__force u32)dport,
161			   &net_secret);
162	seq += ktime_get_real_ns();
 
 
 
 
 
163	seq &= (1ull << 48) - 1;
 
164	return seq;
165}
166EXPORT_SYMBOL(secure_dccp_sequence_number);
167
168#if IS_ENABLED(CONFIG_IPV6)
169u64 secure_dccpv6_sequence_number(__be32 *saddr, __be32 *daddr,
170				  __be16 sport, __be16 dport)
171{
172	const struct {
173		struct in6_addr saddr;
174		struct in6_addr daddr;
175		__be16 sport;
176		__be16 dport;
177	} __aligned(SIPHASH_ALIGNMENT) combined = {
178		.saddr = *(struct in6_addr *)saddr,
179		.daddr = *(struct in6_addr *)daddr,
180		.sport = sport,
181		.dport = dport
182	};
183	u64 seq;
 
 
184	net_secret_init();
185	seq = siphash(&combined, offsetofend(typeof(combined), dport),
186		      &net_secret);
187	seq += ktime_get_real_ns();
 
 
 
 
 
 
 
 
 
188	seq &= (1ull << 48) - 1;
 
189	return seq;
190}
191EXPORT_SYMBOL(secure_dccpv6_sequence_number);
192#endif
193#endif