remove bad comments from custom scripts

blockcheck.sh

@@ -41,6 +41,8 @@ CURL_MAX_TIME_QUIC=${CURL_MAX_TIME_QUIC:-$CURL_MAX_TIME}
 CURL_MAX_TIME_DOH=${CURL_MAX_TIME_DOH:-2}
 MIN_TTL=${MIN_TTL:-1}
 MAX_TTL=${MAX_TTL:-12}
+MIN_AUTOTTL_DELTA=${MIN_AUTOTTL_DELTA:-1}
+MAX_AUTOTTL_DELTA=${MAX_AUTOTTL_DELTA:-5}
 USER_AGENT=${USER_AGENT:-Mozilla}
 HTTP_PORT=${HTTP_PORT:-80}
 HTTPS_PORT=${HTTPS_PORT:-443}
@@ -1330,7 +1332,7 @@ pktws_check_domain_http_bypass_()
 	# $2 - encrypted test : 0 = plain, 1 - encrypted with server reply risk, 2 - encrypted without server reply risk
 	# $3 - domain
 
-	local ok ttls s f f2 e desync pos fooling frag sec="$2" delta orig splits
+	local ok ttls attls s f f2 e desync pos fooling frag sec="$2" delta orig splits
 	local need_split need_disorder need_fakedsplit need_hostfakesplit need_fakeddisorder need_fake need_wssize
 	local splits_http='method+2 midsld method+2,midsld'
 	local splits_tls='2 1 sniext+1 sniext+4 host+1 midsld 1,midsld 1,sniext+1,host+1,midsld-2,midsld,midsld+2,endhost-1'
@@ -1342,6 +1344,7 @@ pktws_check_domain_http_bypass_()
 	}
 
 	ttls=$(seq -s ' ' $MIN_TTL $MAX_TTL)
+	attls=$(seq -s ' ' $MIN_AUTOTTL_DELTA $MAX_AUTOTTL_DELTA)
 	need_wssize=1
 	for e in '' '--wssize 1:6'; do
 		need_split=
@@ -1500,7 +1503,7 @@ pktws_check_domain_http_bypass_()
 			ok=0
 			# orig-ttl=1 with start/cutoff limiter drops empty ACK packet in response to SYN,ACK. it does not reach DPI or server.
 			# missing ACK is transmitted in the first data packet of TLS/HTTP proto
-			for delta in 1 2 3 4 5; do
+			for delta in $attls; do
 				for f in '' '--orig-ttl=1 --orig-mod-start=s1 --orig-mod-cutoff=d1'; do
 					pktws_curl_test_update_vary $1 $2 $3 $desync --dpi-desync-ttl=1 --dpi-desync-autottl=-$delta $f $e && ok=1
 					[ "$ok" = 1 -a "$SCANLEVEL" != force ] && break
@@ -1508,7 +1511,7 @@ pktws_check_domain_http_bypass_()
 			done
 			[ "$SCANLEVEL" = force ] && {
 				for orig in 1 2 3; do
-					for delta in 1 2 3 4 5; do
+					for delta in $attls; do
 						pktws_curl_test_update_vary $1 $2 $3 $desync ${orig:+--orig-autottl=+$orig} --dpi-desync-ttl=1 --dpi-desync-autottl=-$delta $e && ok=1
 					done
 					[ "$ok" = 1 -a "$SCANLEVEL" != force ] && break

docs/changes.txt

@@ -555,3 +555,9 @@ nfqws: optimize ipv4 ip_id. apply ip_id on all OS the same way.
 blockcheck: print PRETTY_NAME and some OPENWRT_xxx from /etc/os-release
 blockcheck: new strategies
 blockcheck: curl test simulation : SIMULATE=1
+
+v72.1
+
+nfqws: --ip-id=seq|seqgroup|rnd|zero
+blockcheck: MIN_AUTOTTL_DELTA,MAX_AUTOTTL_DELTA
+init.d: 50-quic4all custom

docs/readme.en.md

@@ -1,4 +1,4 @@
-# zapret v72
+# zapret v72.1
 
 # SCAMMER WARNING
 
@@ -23,6 +23,7 @@ ___
   - [Fake mods](#fake-mods)
   - [TCP segmentation](#tcp-segmentation)
   - [Sequence numbers overlap](#sequence-numbers-overlap)
+  - [IP_ID assignment](#ip_id-assignment)
   - [ipv6 specific modes](#ipv6-specific-modes)
   - [Original modding](#original-modding)
   - [Duplicates](#duplicates)
@@ -180,6 +181,7 @@ nfqws takes the following parameters:
  --dup-badack-increment=<int|0xHEX>                        ; badseq fooling ackseq signed increment for dup. default -66000
  --dup-start=[n|d|s]N                                      ; apply dup to packet numbers (n, default), data packet numbers (d), relative sequence (s) greater or equal than N
  --dup-cutoff=[n|d|s]N                                     ; apply dup to packet numbers (n, default), data packet numbers (d), relative sequence (s) less than N
+ --ip-id=zero|seq|seqgroup|rnd                             ; ipv4 ip_id assignment scheme
  --dpi-desync=[<mode0>,]<mode>[,<mode2>]                   ; try to desync dpi state. modes : synack fake fakeknown rst rstack hopbyhop destopt ipfrag1 multisplit multidisorder fakedsplit hostfakesplit fakeddisorder ipfrag2 udplen tamper
  --dpi-desync-fwmark=<int|0xHEX>                           ; override fwmark for desync packet. default = 0x40000000 (1073741824)
  --dpi-desync-ttl=<int>                                    ; set ttl for desync packet
@@ -439,6 +441,21 @@ All unix OS except Solaris preserve last received data. This is not the case for
 Disorder requires `seqovl` to be less than split position. Otherwise `seqovl` is not possible and will be cancelled.
 Method allows to avoid separate fakes. Fakes and real data are mixed.
 
+### IP_ID assignment
+
+Some DPIs check ipv4 ip_id value. OS normally increment ip_id value every packet. Some anti-DPI software may send fakes or tcp segments with the same ip_id as original causing block trigger.
+
+Sequental ip_id will be broken in case of sending fakes or additional tcp segments because OS knows nothing about them. But still there are options how to assignt ip_id to generated packets.
+
+`ip-id` parameter sets ip_id assignment scheme for a desync profile :
+
+ * `seq` (default) : increment ip_id for every next packet. in `multidisorder` case increase ip_id for the number of tcp segments then decrease by 1 every packet.
+ * `seqgroup` : same as `seq` but send fake replacements with the same ip_id as original parts. related only to fake tcp segments with the same size and same sequence as originals.
+ * `rnd` : assign random ip_id
+ * `zero` : always set zero. Linux and BSD will send zero, Windows will replace zero with it's own counter.
+
+ipv6 header lacks ip_id field, `ip-id` parameter ignored for ipv6.
+
 ### ipv6 specific modes
 
 `hopbyhop`, `destopt` and `ipfrag1` desync modes (they're not the same as `hopbyhop` fooling !) are ipv6 only. One `hop-by-hop`,

docs/readme.md

@@ -1,4 +1,4 @@
-# zapret v72
+# zapret v72.1
 
 # ВНИМАНИЕ, остерегайтесь мошенников
 
@@ -25,6 +25,7 @@ zapret является свободным и open source.
     - [МОДИФИКАЦИЯ ФЕЙКОВ](#модификация-фейков)
     - [TCP СЕГМЕНТАЦИЯ](#tcp-сегментация)
     - [ПЕРЕКРЫТИЕ SEQUENCE NUMBERS](#перекрытие-sequence-numbers)
+    - [НАЗНАЧЕНИЕ IP_ID](#назначение-ip_id)
     - [СПЕЦИФИЧЕСКИЕ РЕЖИМЫ IPV6](#специфические-режимы-ipv6)
     - [МОДИФИКАЦИЯ ОРИГИНАЛА](#модификация-оригинала)
     - [ДУБЛИКАТЫ](#дубликаты)
@@ -207,6 +208,7 @@ dvtws, собираемый из тех же исходников (см. [док
 --methodeol                                               ; добавить перевод строки в unix стиле ('\n') перед методом и убрать пробел из Host: : "GET / ... Host: domain.com" => "\nGET  / ... Host:domain.com"
 --hostspell=HoST                                          ; точное написание заголовка Host (можно "HOST" или "HoSt"). автоматом включает --hostcase
 --domcase                                                 ; домен после Host: сделать таким : TeSt.cOm
+--ip-id=seq|seqgroup|rnd|zero                             ; режим назначения ip_id для генерированных пакетов
 --dpi-desync=[<mode0>,]<mode>[,<mode2]                    ; атака по десинхронизации DPI. mode : synack syndata fake fakeknown rst rstack hopbyhop destopt ipfrag1 multisplit multidisorder fakedsplit hostfakesplit fakeddisorder ipfrag2 udplen tamper
 --dpi-desync-fwmark=<int|0xHEX>                           ; бит fwmark для пометки десинхронизирующих пакетов, чтобы они повторно не падали в очередь. default = 0x40000000
 --dpi-desync-ttl=<int>                                    ; установить ttl для десинхронизирующих пакетов
@@ -537,6 +539,27 @@ Windows оставляет старые данные, поэтому disorder с
 В варианте `disorder` допустимо применение всех вариантов маркеров.
 Они автоматически нормализуются к текущему пакету в серии. Можно сплитать на `midsld` и делать seqovl на `midsld-1`.
 
+### НАЗНАЧЕНИЕ IP_ID
+
+Некоторые DPI секут поле ipv4 заголовка ip_id. Защита заключается в распознавании нехарактерного для разных ОС порядка назначения ip_id,
+но характерного для некоторого anti-DPI софта. Обычно ОС инкрементируют ip_id для каждого следующего пакета.
+Например, на ТСПУ повторение ненулевых ip_id фейка и не фейка вызывает триггер блока на диапазонах IP `googlevideo.com`.
+
+Если отсылаются фейки или дополнительные tcp сегменты, то в любом случае последовательность будет нарушена, поскольку ОС ничего не будет знать о всунутых фейках
+и не увеличит свой счетчик ip_id на количество фейков или дополнительных tcp сегментов.
+Чтобы сохранить последовательность, потребовалось бы перехватывать все соединение до конца, что очень затратно по ресурсам.
+Поэтому после отработки серии генерированных пакетов ip_id возвращается к тому значению, о котором знает ОС.
+
+Параметр `ip-id` относится к профилю и задает режим назначения ip_id при отсылке генерированных в nfqws пакетов.
+
+ * `seq` (по умолчанию) : взять последний ip_id реального пакета. последующие генерированыне пакеты получают увеличенные на 1 ip_id, кроме случая `multidisorder`.
+ для `multidisorder` в пределах сегментов, где есть сплит-позиции, значение ip_id увеличивается на количество частей, затем уменьшается на 1 с каждой отосланной частью.
+ * `seqgroup` : то же, что и `seq`, но фейки того же размера, что и оригинальные сегменты, маскирующиеся под оригинал получают те же ip_id.
+ * `rnd` : всем генерированным пакетам назначать случайный ip_id
+ * `zero` : всем генерированным пакетам назначать ip_id=0 . в этом случае Linux и BSD отошлют 0, Windows назначит последовательные ip_id всем пакетам (тем самым автоматически решается проблема сбоя счетчика пакетов).
+
+В заголовках ipv6 поле ip_id отсутствует, параметр игнорируется для ipv6.
+
 ### СПЕЦИФИЧЕСКИЕ РЕЖИМЫ IPV6
 
 Режимы десинхронизации `hopbyhop`, `destopt` и `ipfrag1` (не путать с fooling !) относятся только к ipv6 и заключается
@@ -1803,6 +1826,8 @@ SECURE_DNS=0|1 - принудительно выключить или включ
 DOH_SERVERS - список URL DoH через пробел для автоматического выбора работающего сервера
 DOH_SERVER - конкретный DoH URL, отказ от поиска
 UNBLOCKED_DOM - незаблокированный домен, который используется для тестов IP block
+MIN_TTL,MAX_TTL - пределы тестов с TTL. MAX_TTL=0 отключает тесты.
+MIN_AUTOTTL_DELTA,MAX_AUTOTTL_DELTA - пределы тестов с autottl по дельте. MAX_AUTOTTL_DELTA=0 отключает тесты.
 SIMULATE=1 - включить режим симуляции для отладки логики скрипта. отключаются реальные запросы через curl, заменяются рандомным результатом.
 SIM_SUCCESS_RATE=<percent> - вероятность успеха симуляции в процентах
 ```

init.d/custom.d.examples.linux/50-discord-media

@@ -15,7 +15,6 @@ zapret_custom_daemons()
 	local opt="--qnum=$QNUM_DISCORD_MEDIA $NFQWS_OPT_DESYNC_DISCORD_MEDIA"
 	do_nfqws $1 $DNUM_DISCORD_MEDIA "$opt"
 }
-# size = 156 (8 udp header + 148 payload) && payload starts with 0x01000000
 zapret_custom_firewall()
 {
         # $1 - 1 - run, 0 - stop

init.d/custom.d.examples.linux/50-quic4all

@@ -0,0 +1,30 @@
+# this custom script runs desync to all IETF QUIC initials
+# NOTE: @ih requires nft 1.0.1+ and updated kernel version. it's confirmed to work on 5.15 (openwrt 23) and not work on 5.10 (openwrt 22)
+
+# can override in config :
+NFQWS_OPT_DESYNC_QUIC="${NFQWS_OPT_DESYNC_QUIC:---dpi-desync=fake --dpi-desync-repeats=2}"
+
+alloc_dnum DNUM_QUIC4ALL
+alloc_qnum QNUM_QUIC4ALL
+
+zapret_custom_daemons()
+{
+	# $1 - 1 - add, 0 - stop
+
+	local opt="--qnum=$QNUM_QUIC4ALL $NFQWS_OPT_DESYNC_QUIC"
+	do_nfqws $1 $DNUM_QUIC4ALL "$opt"
+}
+zapret_custom_firewall()
+{
+        # $1 - 1 - run, 0 - stop
+
+	local f='-p udp -m u32 --u32'
+	fw_nfqws_post $1 "$f 0>>22&0x3C@4>>16=264:65535&&0>>22&0x3C@8>>28=0xC&&0>>22&0x3C@9=0x00000001" "$f 44>>16=264:65535&&48>>28=0xC&&49=0x00000001" $QNUM_QUIC4ALL
+}
+zapret_custom_firewall_nft()
+{
+        # stop logic is not required
+
+	local f="udp length >= 264 @ih,0,4 0xC @ih,8,32 0x00000001"
+	nft_fw_nfqws_post "$f" "$f" $QNUM_QUIC4ALL
+}

init.d/custom.d.examples.linux/50-stun4all

@@ -14,7 +14,6 @@ zapret_custom_daemons()
 	local opt="--qnum=$QNUM_STUN4ALL $NFQWS_OPT_DESYNC_STUN"
 	do_nfqws $1 $DNUM_STUN4ALL "$opt"
 }
-# size = 156 (8 udp header + 148 payload) && payload starts with 0x01000000
 zapret_custom_firewall()
 {
         # $1 - 1 - run, 0 - stop

init.d/windivert.filter.examples/windivert_part.quic_initial_ietf.txt

@@ -0,0 +1,4 @@
+  outbound and
+  udp.PayloadLength>=256 and
+  udp.Payload[0]>=0xC0 and udp.Payload[0]<0xD0 and
+  udp.Payload[1]=0 and udp.Payload16[1]=0 and udp.Payload[4]=1

nfq/desync.c

@@ -835,25 +835,43 @@ static bool ipcache_get_hostname(const struct in_addr *a4, const struct in6_addr
 }
 
 
-static uint16_t IP4_IP_ID_FIX(const struct ip *ip)
+static uint16_t IP4_IP_ID_FIX(const struct ip *ip, t_ip_id_mode mode)
 {
-	return ip ? ip->ip_id ? ip->ip_id : (uint16_t)random() : 0;
+	if (ip)
+	{
+		switch(mode)
+		{
+			case IPID_RND:
+				return (uint16_t)(random()%0xFFFF + 1);
+			case IPID_SEQ:
+			case IPID_SEQ_GROUP:
+				return ip->ip_id ? ip->ip_id : (uint16_t)random();
+			default:
+				break;
 		}
-static uint16_t IP4_IP_ID_ADD(uint16_t ip_id, uint16_t inc)
+	}
+	return 0;
+}
+static uint16_t IP4_IP_ID_ADD(uint16_t ip_id, uint16_t inc, t_ip_id_mode mode)
 {
+	switch(mode)
+	{
+		case IPID_RND:
+			return (uint16_t)(random()%0xFFFF + 1);;
+		case IPID_SEQ_GROUP:
+		case IPID_SEQ:
 			if (ip_id)
 			{
-		ip_id += net16_add(ip_id, inc);
+				ip_id = net16_add(ip_id, inc);
 				if (!ip_id) ip_id = net16_add(ip_id, ((int16_t)inc) < 0 ? -1 : 1); // do not allow zero
 			}
 			return ip_id;
+		default:
+			return 0;
 	}
-#define IP4_IP_ID_ADD(ip_id,inc) (ip_id ? net16_add(ip_id,inc) : 0)
+}
-#define IP4_IP_ID_NEXT(ip_id) IP4_IP_ID_ADD(ip_id,+1)
+#define IP4_IP_ID_NEXT(ip_id,mode) IP4_IP_ID_ADD(ip_id,+1,mode)
-#define IP4_IP_ID_PREV(ip_id) IP4_IP_ID_ADD(ip_id,-1)
+#define IP4_IP_ID_PREV(ip_id,mode) IP4_IP_ID_ADD(ip_id,-1,mode)
-//#define IP4_IP_ID_FIX(x) 0
-//#define IP4_IP_ID_NEXT(ip_id) ip_id
-//#define IP4_IP_ID_PREV(ip_id) ip_id
 
 
 // fake_mod buffer must at least sizeof(desync_profile->fake_tls)
@@ -985,7 +1003,7 @@ static bool tcp_orig_send(uint8_t verdict, uint32_t fwmark, const char *ifout, c
 				timestamps = tcp_find_timestamps(dis->tcp);
 				sack = tcp_has_sack(dis->tcp);
 				nmss = tcp_find_mss(dis->tcp);
-				ip_id = IP4_IP_ID_FIX(dis->ip);
+				ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
 
 				len = sizeof(pkt);
 				if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst,
@@ -1055,7 +1073,7 @@ static bool udp_orig_send(uint8_t verdict, uint32_t fwmark, const char *ifout, c
 
 			if (dp->dup_fooling_mode)
 			{
-				ip_id = IP4_IP_ID_FIX(dis->ip);
+				ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
 
 				len = sizeof(pkt);
 				if (!prepare_udp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst,
@@ -1338,7 +1356,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 			}
 			pkt1_len = sizeof(pkt1);
 			if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst, TH_ACK, false, 0, dis->tcp->th_seq, dis->tcp->th_ack, dis->tcp->th_win, SCALE_NONE, timestamps,
-				DF, ttl_orig, IP4_TOS(dis->ip), IP4_IP_ID_FIX(dis->ip), IP6_FLOW(dis->ip6),
+				DF, ttl_orig, IP4_TOS(dis->ip), IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode), IP6_FLOW(dis->ip6),
 				FOOL_NONE, 0, 0, 0, NULL, 0, pkt1, &pkt1_len))
 			{
 				DLOG_ERR("cannot prepare split SYNACK ACK part\n");
@@ -1374,6 +1392,10 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 	bSack = tcp_has_sack(dis->tcp);
 	nmss = tcp_find_mss(dis->tcp);
 
+	uint16_t ip_id=0;
+	if (replay && ctrack_replay->ip_id) ip_id = ctrack_replay->ip_id;
+	if (!ip_id) ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
+
 	if (!replay)
 	{
 		if (tcp_syn_segment(dis->tcp))
@@ -1383,7 +1405,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 			case DESYNC_SYNACK:
 				pkt1_len = sizeof(pkt1);
 				if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst, TH_SYN | TH_ACK, false, 0, dis->tcp->th_seq, dis->tcp->th_ack, dis->tcp->th_win, scale_factor, timestamps,
-					DF, ttl_fake, IP4_TOS(dis->ip), IP4_IP_ID_FIX(dis->ip), IP6_FLOW(dis->ip6),
+					DF, ttl_fake, IP4_TOS(dis->ip), ip_id, IP6_FLOW(dis->ip6),
 					dp->desync_fooling_mode, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					NULL, 0, pkt1, &pkt1_len))
 				{
@@ -1407,11 +1429,12 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 				}
 				pkt1_len = sizeof(pkt1);
 				if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst, flags_orig, bSack, nmss, dis->tcp->th_seq, dis->tcp->th_ack, dis->tcp->th_win, scale_factor, timestamps,
-					DF, ttl_orig, IP4_TOS(dis->ip), IP4_IP_ID_FIX(dis->ip), IP6_FLOW(dis->ip6),
+					DF, ttl_orig, IP4_TOS(dis->ip), ip_id, IP6_FLOW(dis->ip6),
 					0, 0, 0, 0, dp->fake_syndata, dp->fake_syndata_size, pkt1, &pkt1_len))
 				{
 					goto send_orig;
 				}
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending SYN with fake data : ");
 				hexdump_limited_dlog(dp->fake_syndata, dp->fake_syndata_size, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -1438,7 +1461,6 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 		size_t multisplit_pos[MAX_SPLITS];
 		int multisplit_count;
 		int i;
-		uint16_t ip_id = IP4_IP_ID_FIX(dis->ip);
 
 		bool bHaveHost = false, bHostIsIp = false;
 		t_l7proto l7proto = UNKNOWN;
@@ -1629,6 +1651,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 			{
 				DLOG("desync profile changed by revealed l7 protocol or hostname !\n");
 				autottl_rediscover(ctrack_replay, dis->ip ? &dis->ip->ip_dst : NULL, dis->ip6 ? &dis->ip6->ip6_dst : NULL, ifout);
+				ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
 				// re-evaluate start/cutoff limiters
 				if (replay)
 				{
@@ -1944,7 +1967,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 						reasm_orig_cancel(ctrack);
 						goto send_orig;
 					}
-					ip_id = IP4_IP_ID_NEXT(ip_id);
+					ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 					if (dp->tcp_mod.seq) sequence += fake_size;
 				}
 			}
@@ -1968,7 +1991,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 				reasm_orig_cancel(ctrack);
 				goto send_orig;
 			}
-			ip_id = IP4_IP_ID_NEXT(ip_id);
+			ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 			bFake = true;
 			break;
 		case DESYNC_HOPBYHOP:
@@ -2038,7 +2061,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					fooling_orig, 0, 0, 0,
 					seg, pos_host, pkt1, &pkt1_len))
 					goto send_orig;
-				ip_id = IP4_IP_ID_NEXT(ip_id);
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending hostfakesplit before_host part 0-%zu len=%zu : ", pos_host - 1, pos_host);
 				hexdump_limited_dlog(seg, pos_host, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2093,14 +2116,14 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					dp->desync_fooling_mode, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					fakehost, host_size, pkt2, &pkt2_len))
 					goto send_orig_clean;
-
+				if (dp->ip_id_mode!=IPID_SEQ_GROUP) ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending hostfakesplit fake host %zu-%zu len=%zu : ", pos_host, pos_endhost - 1, host_size);
 				hexdump_limited_dlog(fakehost, host_size, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, pkt2, pkt2_len))
 					goto send_orig_clean;
 
-				ip_id_after_host = IP4_IP_ID_NEXT(ip_id);
+				ip_id_after_host = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
-				if (pos_split_host) ip_id_after_host = IP4_IP_ID_NEXT(ip_id_after_host);
+				if (pos_split_host) ip_id_after_host = IP4_IP_ID_NEXT(ip_id_after_host,dp->ip_id_mode);
 
 				// pkt3: after_host segment
 				pkt3_len = sizeof(pkt3);
@@ -2129,6 +2152,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					fooling_orig, 0, 0, 0,
 					seg + pos_host, sz, pkt1, &pkt1_len))
 					goto send_orig_clean;
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 
 				DLOG("sending hostfakesplit real host %s%zu-%zu len=%zu : ", pos_split_host ? "part 1 " : "", pos_host, pos_host + sz - 1, sz);
 				hexdump_limited_dlog(seg + pos_host, sz, PKTDATA_MAXDUMP); DLOG("\n");
@@ -2139,7 +2163,6 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 				{
 					sz = pos_endhost - pos_split_host;
 					pkt1_len = sizeof(pkt1);
-					ip_id = IP4_IP_ID_NEXT(ip_id);
 					if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst, flags_orig, false, 0,
 						net32_add(dis->tcp->th_seq, pos_split_host), dis->tcp->th_ack,
 						dis->tcp->th_win, scale_factor, timestamps,
@@ -2147,6 +2170,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 						fooling_orig, 0, 0, 0,
 						seg + pos_split_host, sz, pkt1, &pkt1_len))
 						goto send_orig_clean;
+					ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 					DLOG("sending hostfakesplit real host part 2 %zu-%zu len=%zu : ", pos_split_host, pos_endhost - 1, sz);
 					hexdump_limited_dlog(seg + pos_split_host, sz, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2155,11 +2179,21 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (dp->hfs_mod.ordering == 0)
 				{
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+					{
+						if (dis->ip) ((struct ip*)pkt2)->ip_id = ip_id;
+						ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+					}
 					DLOG("sending hostfakesplit fake(2) host %zu-%zu len=%zu : ", pos_host, pos_endhost - 1, host_size);
 					hexdump_limited_dlog(fakehost, host_size, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, pkt2, pkt2_len))
 						goto send_orig_clean;
 
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+					{
+						ip_id_after_host = ip_id;
+						if (dis->ip) ((struct ip*)pkt3)->ip_id = ip_id;
+					}
 					DLOG("sending hostfakesplit after_host part %zu-%zu len=%zu : ", pos_endhost, seg_len - 1, seg_len - pos_endhost);
 					hexdump_limited_dlog(seg + pos_endhost, seg_len - pos_endhost, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt3, pkt3_len))
@@ -2168,7 +2202,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				free(fakehost);
 
-				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id_after_host);
+				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id_after_host,dp->ip_id_mode);
 
 				return VERDICT_DROP;
 			send_orig_clean:
@@ -2227,7 +2261,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 							fooling_orig, 0, 0, 0,
 							seg, seg_len, pkt1, &pkt1_len))
 							goto send_orig;
-						ip_id = IP4_IP_ID_NEXT(ip_id);
+						ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 						DLOG("sending multisplit part %d %zu-%zu len=%zu seqovl=%u : ", i + 1, from, to - 1, to - from, seqovl);
 						hexdump_limited_dlog(seg, seg_len, PKTDATA_MAXDUMP); DLOG("\n");
 						if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2266,7 +2300,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (replay && ctrack_replay->ip_id) ip_id = ctrack_replay->ip_id;
 
-				ip_id_end = ip_id = IP4_IP_ID_ADD(ip_id, (uint16_t)multisplit_count);
+				ip_id_end = ip_id = IP4_IP_ID_ADD(ip_id, (uint16_t)multisplit_count, dp->ip_id_mode);
 
 				for (i = multisplit_count - 1, to = dis->len_payload; i >= -1; i--)
 				{
@@ -2305,7 +2339,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 						fooling_orig, 0, 0, 0,
 						seg, seg_len, pkt1, &pkt1_len))
 						goto send_orig;
-					ip_id = IP4_IP_ID_PREV(ip_id);
+					ip_id = IP4_IP_ID_PREV(ip_id,dp->ip_id_mode);
 					DLOG("sending multisplit part %d %zu-%zu len=%zu seqovl=%u : ", i + 2, from, to - 1, to - from, seqovl);
 					hexdump_limited_dlog(seg, seg_len, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2314,7 +2348,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					to = from;
 				}
 
-				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id_end);
+				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id_end,dp->ip_id_mode);
 
 				return VERDICT_DROP;
 			}
@@ -2344,7 +2378,6 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 						DLOG("seqovl>=split_pos (%zu>=%zu). cancelling seqovl.\n", seqovl_pos, split_pos);
 					else
 						seqovl = seqovl_pos;
-					ip_id = IP4_IP_ID_NEXT(ip_id);
 				}
 				else
 				{
@@ -2380,6 +2413,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (order == 0)
 				{
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP) ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 					DLOG("sending fake(1) 2nd out-of-order tcp segment %zu-%zu len=%zu : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos);
 					hexdump_limited_dlog(pat + split_pos, dis->len_payload - split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg2, fakeseg2_len))
@@ -2392,6 +2426,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					fooling_orig, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					seg, seg_len, pkt1, &pkt1_len))
 					goto send_orig;
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending 2nd out-of-order tcp segment %zu-%zu len=%zu seqovl=%u : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos, seqovl);
 				hexdump_limited_dlog(seg, seg_len, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2399,6 +2434,11 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (order <= 1)
 				{
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+					{
+						if (dis->ip) ((struct ip*)fakeseg2)->ip_id = ip_id;
+						ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+					}
 					DLOG("sending fake(2) 2nd out-of-order tcp segment %zu-%zu len=%zu : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos);
 					hexdump_limited_dlog(pat + split_pos, dis->len_payload - split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg2, fakeseg2_len))
@@ -2407,14 +2447,13 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (split_pos)
 				{
-					ip_id = IP4_IP_ID_PREV(ip_id);
-
 					seg_len = sizeof(fakeseg);
 					if (!prepare_tcp_segment((struct sockaddr *)&src, (struct sockaddr *)&dst, flags_orig, false, 0, dis->tcp->th_seq, dis->tcp->th_ack, dis->tcp->th_win, scale_factor, timestamps,
 						DF, ttl_fake, IP4_TOS(dis->ip), ip_id, IP6_FLOW(dis->ip6),
 						dp->desync_fooling_mode, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 						pat, split_pos, fakeseg, &seg_len))
 						goto send_orig;
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP) ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 					DLOG("sending fake(1) 1st out-of-order tcp segment 0-%zu len=%zu : ", split_pos - 1, split_pos);
 					hexdump_limited_dlog(pat, split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, seg_len))
@@ -2426,6 +2465,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 						fooling_orig, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 						dis->data_payload, split_pos, pkt1, &pkt1_len))
 						goto send_orig;
+					ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 					DLOG("sending 1st out-of-order tcp segment 0-%zu len=%zu : ", split_pos - 1, split_pos);
 					hexdump_limited_dlog(dis->data_payload, split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2433,6 +2473,11 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 					if (order <= 2)
 					{
+						if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+						{
+							if (dis->ip) ((struct ip*)fakeseg)->ip_id = ip_id;
+							ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+						}
 						DLOG("sending fake(2) 1st out-of-order tcp segment 0-%zu len=%zu : ", split_pos - 1, split_pos);
 						hexdump_limited_dlog(pat, split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 						if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, seg_len))
@@ -2440,7 +2485,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					}
 				}
 
-				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id);
+				if (replay) ctrack_replay->ip_id = ip_id;
 
 				return VERDICT_DROP;
 			}
@@ -2480,6 +2525,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 			if (order == 0)
 			{
+				if (dp->ip_id_mode!=IPID_SEQ_GROUP) ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending fake(1) 1st tcp segment 0-%zu len=%zu : ", split_pos - 1, split_pos);
 				hexdump_limited_dlog(pat, split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, fakeseg_len))
@@ -2516,7 +2562,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					fooling_orig, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					seg, seg_len, pkt1, &pkt1_len))
 					goto send_orig;
-				ip_id = IP4_IP_ID_NEXT(ip_id);
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending 1st tcp segment 0-%zu len=%zu seqovl=%u : ", split_pos - 1, split_pos, seqovl);
 				hexdump_limited_dlog(seg, seg_len, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2536,6 +2582,11 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 #endif
 			if (order <= 1)
 			{
+				if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+				{
+					if (dis->ip) ((struct ip*)fakeseg)->ip_id = ip_id;
+					ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+				}
 				DLOG("sending fake(2) 1st tcp segment 0-%zu len=%zu : ", split_pos - 1, split_pos);
 				hexdump_limited_dlog(pat, split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, fakeseg_len))
@@ -2550,6 +2601,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					dp->desync_fooling_mode, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					pat + split_pos, dis->len_payload - split_pos, fakeseg, &fakeseg_len))
 					goto send_orig;
+				if (dp->ip_id_mode!=IPID_SEQ_GROUP) ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending fake(1) 2nd tcp segment %zu-%zu len=%zu : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos);
 				hexdump_limited_dlog(pat + split_pos, dis->len_payload - split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, fakeseg_len))
@@ -2561,7 +2613,7 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 					fooling_orig, dp->desync_ts_increment, dp->desync_badseq_increment, dp->desync_badseq_ack_increment,
 					dis->data_payload + split_pos, dis->len_payload - split_pos, pkt1, &pkt1_len))
 					goto send_orig;
-				ip_id = IP4_IP_ID_NEXT(ip_id);
+				ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				DLOG("sending 2nd tcp segment %zu-%zu len=%zu : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos);
 				hexdump_limited_dlog(dis->data_payload + split_pos, dis->len_payload - split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 				if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
@@ -2569,6 +2621,11 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 
 				if (order <= 2)
 				{
+					if (dp->ip_id_mode!=IPID_SEQ_GROUP)
+					{
+						if (dis->ip) ((struct ip*)fakeseg)->ip_id = ip_id;
+						ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+					}
 					DLOG("sending fake(2) 2nd tcp segment %zu-%zu len=%zu : ", split_pos, dis->len_payload - 1, dis->len_payload - split_pos);
 					hexdump_limited_dlog(pat + split_pos, dis->len_payload - split_pos, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, fakeseg, fakeseg_len))
@@ -2581,7 +2638,9 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 			return VERDICT_DROP;
 		}
 		case DESYNC_IPFRAG2:
-			if (!reasm_offset)
+			if (reasm_offset)
+				goto unsplitted_part;
+			else
 			{
 				verdict_tcp_csum_fix(verdict, dis->tcp, dis->transport_len, dis->ip, dis->ip6);
 
@@ -2620,6 +2679,8 @@ static uint8_t dpi_desync_tcp_packet_play(bool replay, size_t reasm_offset, uint
 				if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt2, pkt2_len))
 					goto send_orig;
 
+				if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+
 				return VERDICT_DROP;
 			}
 		default:
@@ -2641,7 +2702,7 @@ unsplitted_part:
 	{
 		DLOG("changing ip_id of unsplitted part\n");
 		dis->ip->ip_id = ctrack_replay->ip_id;
-		ctrack_replay->ip_id = IP4_IP_ID_NEXT(ctrack_replay->ip_id);
+		ctrack_replay->ip_id = IP4_IP_ID_NEXT(ctrack_replay->ip_id,dp->ip_id_mode);
 		return VERDICT_MODIFY;
 	}
 	goto send_orig;
@@ -2806,7 +2867,10 @@ static uint8_t dpi_desync_udp_packet_play(bool replay, size_t reasm_offset, uint
 	{
 		struct blob_collection_head *fake;
 		bool bHaveHost = false, bHostIsIp = false;
-		uint16_t ip_id = IP4_IP_ID_FIX(dis->ip);
+		uint16_t ip_id=0;
+
+		if (replay && ctrack_replay->ip_id) ip_id = ctrack_replay->ip_id;
+		if (!ip_id) ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
 
 		if (IsQUICInitial(dis->data_payload, dis->len_payload))
 		{
@@ -3055,6 +3119,7 @@ static uint8_t dpi_desync_udp_packet_play(bool replay, size_t reasm_offset, uint
 			{
 				DLOG("desync profile changed by revealed l7 protocol or hostname !\n");
 				autottl_rediscover(ctrack_replay, dis->ip ? &dis->ip->ip_dst : NULL, dis->ip6 ? &dis->ip6->ip6_dst : NULL, ifout);
+				ip_id = IP4_IP_ID_FIX(dis->ip,dp->ip_id_mode);
 				// re-evaluate start/cutoff limiters
 				if (replay)
 				{
@@ -3170,7 +3235,7 @@ static uint8_t dpi_desync_udp_packet_play(bool replay, size_t reasm_offset, uint
 					hexdump_limited_dlog(fake_data, fake_size, PKTDATA_MAXDUMP); DLOG("\n");
 					if (!rawsend_rep(dp->desync_repeats, (struct sockaddr *)&dst, desync_fwmark, ifout, pkt1, pkt1_len))
 						goto send_orig;
-					ip_id = IP4_IP_ID_NEXT(ip_id);
+					ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
 				}
 				bFake = true;
 			}
@@ -3252,8 +3317,6 @@ static uint8_t dpi_desync_udp_packet_play(bool replay, size_t reasm_offset, uint
 			uint8_t *pkt_orig;
 			size_t pkt_orig_len;
 
-			// freebsd do not set ip.id
-			ip_id = IP4_IP_ID_FIX(dis->ip);
 			uint32_t ident = dis->ip ? ip_id ? ip_id : htons(1 + random() % 0xFFFF) : htonl(1 + random() % 0xFFFFFFFF);
 			size_t ipfrag_pos = (dp->desync_ipfrag_pos_udp && dp->desync_ipfrag_pos_udp < dis->transport_len) ? dp->desync_ipfrag_pos_udp : sizeof(struct udphdr);
 
@@ -3286,6 +3349,8 @@ static uint8_t dpi_desync_udp_packet_play(bool replay, size_t reasm_offset, uint
 			if (!rawsend((struct sockaddr *)&dst, desync_fwmark, ifout, pkt2, pkt2_len))
 				goto send_orig;
 
+			if (replay) ctrack_replay->ip_id = IP4_IP_ID_NEXT(ip_id,dp->ip_id_mode);
+
 			return ct_new_postnat_fix(ctrack, dis->ip, dis->ip6, NULL);
 		}
 		default:

nfq/nfqws.c

@@ -1792,6 +1792,7 @@ static void exithelp(void)
 		" --hostnospace\t\t\t\t\t\t; remove space after Host: and add it to User-Agent: to preserve packet size\n"
 		" --domcase\t\t\t\t\t\t; mix domain case : Host: TeSt.cOm\n"
 		" --methodeol\t\t\t\t\t\t; add '\\n' before method and remove space from Host:\n"
+		" --ip-id=zero|seq|seqgroup|rnd\t\t\t\t; ipv4 ip_id assignment scheme\n"
 		" --dpi-desync=[<mode0>,]<mode>[,<mode2>]\t\t; try to desync dpi state. modes :\n"
 		"\t\t\t\t\t\t\t; synack syndata fake fakeknown rst rstack hopbyhop destopt ipfrag1\n"
 		"\t\t\t\t\t\t\t; multisplit multidisorder fakedsplit fakeddisorder hostfakesplit ipfrag2 udplen tamper\n"
@@ -1959,6 +1960,7 @@ enum opt_indices {
 	IDX_HOSTNOSPACE,
 	IDX_DOMCASE,
 	IDX_METHODEOL,
+	IDX_IP_ID,
 	IDX_DPI_DESYNC,
 #ifdef __linux__
 	IDX_DPI_DESYNC_FWMARK,
@@ -2091,6 +2093,7 @@ static const struct option long_options[] = {
 	[IDX_HOSTNOSPACE] = {"hostnospace", no_argument, 0, 0},
 	[IDX_DOMCASE] = {"domcase", no_argument, 0, 0},
 	[IDX_METHODEOL] = {"methodeol", no_argument, 0, 0},
+	[IDX_IP_ID] = {"ip-id", required_argument, 0, 0},
 	[IDX_DPI_DESYNC] = {"dpi-desync", required_argument, 0, 0},
 #ifdef __linux__
 	[IDX_DPI_DESYNC_FWMARK] = {"dpi-desync-fwmark", required_argument, 0, 0},
@@ -2486,6 +2489,21 @@ int main(int argc, char **argv)
 			}
 			dp->methodeol = true;
 			break;
+		case IDX_IP_ID:
+			if (!strcmp(optarg,"zero"))
+				dp->ip_id_mode = IPID_ZERO;
+			else if (!strcmp(optarg,"seq"))
+				dp->ip_id_mode = IPID_SEQ;
+			else if (!strcmp(optarg,"seqgroup"))
+				dp->ip_id_mode = IPID_SEQ_GROUP;
+			else if (!strcmp(optarg,"rnd"))
+				dp->ip_id_mode = IPID_RND;
+			else
+			{
+				DLOG_ERR("invalid ip_id mode : %s\n",optarg);
+				exit_clean(1);
+			}
+			break;
 		case IDX_DPI_DESYNC:
 		{
 			char *mode = optarg, *mode2, *mode3;
@@ -2707,8 +2725,8 @@ int main(int argc, char **argv)
 				exit_clean(1);
 			}
 			dp->split_count += ct;
-		}
 			break;
+		}
 		case IDX_DPI_DESYNC_SPLIT_HTTP_REQ:
 			// obsolete arg
 			DLOG_CONDUP("WARNING ! --dpi-desync-split-http-req is deprecated. use --dpi-desync-split-pos with markers.\n", MAX_SPLITS);
@@ -3323,7 +3341,7 @@ int main(int argc, char **argv)
 		if (dp->orig_mod_ttl6 == 0xFF) dp->orig_mod_ttl6 = dp->orig_mod_ttl;
 		if (!dp->fsplit_pattern)
 		{
-			if (dp->fsplit_pattern=calloc(64,1))
+			if ((dp->fsplit_pattern=calloc(64,1)))
 				dp->fsplit_pattern_size=64;
 			else
 			{

nfq/params.h

@@ -97,6 +97,7 @@ struct tcp_mod
 };
 
 typedef enum {SS_NONE=0,SS_SYN,SS_SYNACK,SS_ACKSYN} t_synack_split;
+typedef enum {IPID_SEQ=0,IPID_SEQ_GROUP,IPID_RND,IPID_ZERO} t_ip_id_mode;
 
 struct desync_profile
 {
@@ -109,6 +110,8 @@ struct desync_profile
 
 	t_synack_split synack_split;
 
+	t_ip_id_mode ip_id_mode;
+
 	bool hostcase, hostnospace, domcase, methodeol;
 	char hostspell[4];
 	enum dpi_desync_mode desync_mode0,desync_mode,desync_mode2;