Je vais faire des stats sur le pourcentage de ports < 32768 par FAI.
Cela permet de voir dans quel proportion les FAI utilisent plusieurs clients sur une IP (ou les clients utilisent Windows 2000 / XP ou Linux 2.2 ou <)

Les seuls systèmes d'exploitation à utiliser les ports < 32768 sont Windows XP est précédents et Linux 2.2 et précédents (Linux d'avant 2001)

- Windows XP (sortie en 2001) : de 1025 à 5000
- Windows server 2008 : 49152 à 65535 (recommandation de l'Internet Assigned Numbers Authority)
- Windows server 2008 avec Microsoft Exchange Server 2007 : 1025 à 60000
- Windows Vista (sortie en 2007) et suivants : de 49152 à 65535 (recommandation de l'Internet Assigned Numbers Authority)
- Linux avant 2001 (noyaux 2.2.x) : de 1024 à 4999
- Linux à  partir de 2001 (noyaux 2.4.x à 3.13) : de 32768 à 61000
- Linux à  partir de 2015 (noyaux 3.19 et suivants) : de 32768 à 60999
- FreeBSD : de 49152 à 65535 (recommandation de l'Internet Assigned Numbers Authority)
- MacOS X : de 49152 à 65535 (recommandation de l'Internet Assigned Numbers Authority)

J'ai refait des tests avec Windows 10, pas moyen d'avoir ce que vous avez, Corrector et Bensay.





PS : Pour le copyright "2016" de Windows10 10586, Microsoft à corrigé le bug et c'est repassé en "2015" avec les mises à jour de décembre.

La commande fonctionne bien avec Linux 2.2 aussi bien sous Linux Mandrake 7 et Debian Potato (2.2) et bien sur c'est toujours bon sur les systèmes plus récents.
cat /proc/sys/net/ipv4/ip_local_port_range
Pour Windows, la commande ne fonctionne que à  partir de Windows XP. Un Windows 2000 SP4 a bien netsh mais il ne semble pas possible de visualiser ou modifier les ports de retour. Je suppose qu'il faut passer par le registre (pas trouvé où est la valeur)
netsh int ipv4 show dynamicport tcp

Pour Windows, la commande ne fonctionne que à  partir de Windows XP. Un Windows 2000 SP4 a bien netsh mais il ne semble pas possible de visualiser ou modifier les ports de retour. Je suppose qu'il faut passer par le registre (pas trouvé où est la valeur)

oui:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters

puis mettre une valeur DWORD nommé MaxUserPort. Si la valeur n'existe pas c'est le défaut: 5000

https://technet.microsoft.com/en-us/library/cc938196.aspx

a priori on ne peut changer le port mini.

Les box sont toutes basées sur iptables ou pas?

Neufbox, Bbox, Freebox, oui ; Livebox, non pour les firmwares basés sur OpenRG (aucune référence, les fonctions pare-feu sont gérées du côté du code propriétaire) mais peut-être pour d'autres ; quant à la flotte de modems de Numericable, c'est moins sûr en sachant qu'une partie est basée sur des systèmes comme eCos.

Moi j'ai ça:

Peut être le fait d'avoir Vmware ?

213         while (udp_lport_inuse(best))
214                 best += UDP_HTABLE_SIZE;

Je n'arrive pas à comprendre ce qui garantit que ce truc termine à temps!

Il y a aussi ça :

503 static __inline__ int tcp_lport_inuse(int num)
504 {
505         struct sock *sk = tcp_bound_hash[tcp_bhashfn(num)];
506
507         for(; sk != NULL; sk = sk->bind_next) {
508                 if(sk->num == num)
509                         return 1;
510         }
511         return 0;
512 }
513
514 /* Find a "good" local port, this is family independant.
515  * There are several strategies working in unison here to
516  * get the best possible performance.  The current socket
517  * load is kept track of, if it is zero there is a strong
518  * likely hood that there is a zero length chain we will
519  * find with a small amount of searching, else the load is
520  * what we shoot for when the chains all have at least
521  * one entry.  The base helps us walk the chains in an
522  * order such that a good chain is found as quickly as possible.  -DaveM
523  */
524 unsigned short tcp_good_socknum(void)
525 {
526         static int start = PROT_SOCK;
527         static int binding_contour = 0;
528         int best = 0;
529         int size = 32767; /* a big num. */
530         int retval = 0, i, end, bc;
531
532         SOCKHASH_LOCK();
533         i = tcp_bhashfn(start);
534         end = i + TCP_BHTABLE_SIZE;
535         bc = binding_contour;
536         do {
537                 struct sock *sk = tcp_bound_hash[i&(TCP_BHTABLE_SIZE-1)];
538                 if(!sk) {
539                         /* find the smallest value no smaller than start
540                          * that has this hash value.
541                          */
542                         retval = tcp_bhashnext(start-1,i&(TCP_BHTABLE_SIZE-1));
543
544                         /* Check for decreasing load. */
545                         if (bc != 0)
546                                 binding_contour = 0;
547                         goto done;
548                 } else {
549                         int j = 0;
550                         do { sk = sk->bind_next; } while (++j < size && sk);
551                         if (j < size) {
552                                 best = i&(TCP_BHTABLE_SIZE-1);
553                                 size = j;
554                                 if (bc && size <= bc) {
555                                         i = best;
556                                         goto verify;
557                                 }
558                         }
559                 }
560         } while(++i != end);
561         i = best;
562
563         /* Socket load is increasing, adjust our load average. */
564         binding_contour = size;
565 verify:
566         if (size < binding_contour)
567                 binding_contour = size;
568
569         retval = tcp_bhashnext(start-1,i);
570
571         best = retval;  /* mark the starting point to avoid infinite loops */
572         while(tcp_lport_inuse(retval)) {
573                 retval = tcp_bhashnext(retval,i);
574                 if (retval > 32767)     /* Upper bound */
575                         retval = tcp_bhashnext(PROT_SOCK,i);
576                 if (retval == best) {
577                         /* This hash chain is full. No answer. */
578                         retval = 0;
579                         break;
580                 }
581         }
582
583 done:
584         start = (retval + 1);
585         if (start > 32767 || start < PROT_SOCK)
586                 start = PROT_SOCK;
587         SOCKHASH_UNLOCK();
588
589         return retval;
590 }

http://lxr.free-electrons.com/source/net/ipv4/tcp.c?v=2.0.40#L503