Pages:
Actions
  • #13 par vivien le 28 Dec 2015
  • 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
  • #14 par corrector le 28 Dec 2015
  • On est d'accord que les box préservent les ports? (sauf exception)

    Les box sont toutes basées sur iptables ou pas?
  • #15 par kgersen le 28 Dec 2015
  • 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.
  • #16 par corrector le 28 Dec 2015
  • Est-ce que SMF enregistre les ports?
  • #17 par Marin le 28 Dec 2015
  • 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.
  • #18 par vivien le 28 Dec 2015
  • Non, SMF n'enregistre pas les ports, mais Apache enregistre les ports.

    Je viens d'installer un Linux 2.0 (Redhat 5.1 qui date d’août 1998 et qui a le noyau Linux 2.0.34) mais si /proc/sys/net/ipv4/ existe bien, pas de "ip_local_port_range"

    Il y a uniquement :
    - /proc/sys/net/ipv4/arp_check_interval (6000)
    - /proc/sys/net/ipv4/arp_confirm_interval (30000)
    - /proc/sys/net/ipv4/apr_confirm_timeout (500)
    - /proc/sys/net/ipv4/arp_dead_res_time (6000)
    - /proc/sys/net/ipv4/arp_max_tries (3)
    - /proc/sys/net/ipv4/arp_res_time (500)
    - /proc/sys/net/ipv4/arp_timeout (6000)
    - /proc/sys/net/ipv4/ip_dynaddr (0)
    - /proc/sys/net/ipv4/ip_forward (0)
  • #19 par Breizh 29 le 28 Dec 2015
  • Moi j'ai ça:
  • #20 par corrector le 28 Dec 2015
  • Je viens d'installer un Linux 2.0 (Redhat 5.1 qui date d’août 1998 et qui a le noyau Linux 2.0.34) mais si /proc/sys/net/ipv4/ existe bien, pas de "ip_local_port_range"
    J'ai trouvé deux choses :

    1) Si l'utilisateur choisit un numéro de port, il ne peut pas prendre n'importe lequel :

    19 /*
     20  *      Linux ports don't normally get allocated above 32K.
     21  *      I used an extra 4K port-space
     22  */
     23
     24 #define PORT_MASQ_BEGIN 61000
     25 #define PORT_MASQ_END   (PORT_MASQ_BEGIN+4096)
     

    616 #ifdef CONFIG_IP_MASQUERADE
    617         /* The kernel masquerader needs some ports. */         
    618         if(snum>=PORT_MASQ_BEGIN && snum<=PORT_MASQ_END)
    619                 return -EADDRINUSE;
    620 #endif

    Donc cette plage de ports était réservée pour MASQUERADE et donc interdite aux sockets créées localement! Cela évite d'avoir à gérer les sockets locales dans MASQUERADE.

    Dans un linux moderne (càd version > 2.6), la généralisation de MASQUERADE qui est SNAT gère automatiquement toutes les connexions sortantes même quand on ne lui demande que de gérer certaines connexions.

    2) Si l'utilisateur ne spécifie pas de numéro de port :


    168 static inline int udp_lport_inuse(u16 num)
    169 {
    170         struct sock *sk = udp_hash[num & (UDP_HTABLE_SIZE - 1)];
    171
    172         for (; sk != NULL; sk = sk->next) {
    173                 if (sk->num == num)
    174                         return 1;
    175         }
    176         return 0;
    177 }
    178
    179 /* Shared by v4/v6 tcp. */
    180 unsigned short udp_good_socknum(void)
    181 {
    182         int result;
    183         static int start = 0;
    184         int i, best, best_size_so_far;
    185
    186         SOCKHASH_LOCK();
    187
    188         /* Select initial not-so-random "best" */
    189         best = PROT_SOCK + 1 + (start & 1023);
    190         best_size_so_far = 32767;       /* "big" num */
    191         result = best;
    192         for (i = 0; i < UDP_HTABLE_SIZE; i++, result++) {
    193                 struct sock *sk;
    194                 int size;
    195
    196                 sk = udp_hash[result & (UDP_HTABLE_SIZE - 1)];
    197
    198                 /* No clashes - take it */
    199                 if (!sk)
    200                         goto out;
    201
    202                 /* Is this one better than our best so far? */
    203                 size = 0;
    204                 do {
    205                         if (++size >= best_size_so_far)
    206                                 goto next;
    207                 } while ((sk = sk->next) != NULL);
    208                 best_size_so_far = size;
    209                 best = result;
    210 next:
    211         }
    212
    213         while (udp_lport_inuse(best))
    214                 best += UDP_HTABLE_SIZE;
    215         result = best;
    216 out:
    217         start = result;
    218         SOCKHASH_UNLOCK();
    219         return result;
    220 }

    Voir

    http://lxr.free-electrons.com/source/net/ipv4/af_inet.c?v=2.0.40#L329
    http://lxr.free-electrons.com/source/net/ipv4/udp.c?v=2.0.40#L179
    http://lxr.free-electrons.com/source/include/net/ip_masq.h?v=2.0.40#L19
    http://lxr.free-electrons.com/source/include/net/sock.h?v=2.0.40#L429
  • #21 par Bensay le 28 Dec 2015
  • Peut être le fait d'avoir Vmware ?
  • #22 par corrector le 28 Dec 2015
  • Tu parles du NAT de Vmware?
  • #23 par corrector le 28 Dec 2015
  • 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
  • #24 par vivien le 28 Dec 2015
  • Peut être le fait d'avoir Vmware ?
    C'est une bonne piste.

    A noter que Virtualbox et KVM/libvirt ne font pas ce type de modifications sous Linux.
Pages:
Actions