B2. Anti-Replay Window

Il ricevitore manterrà una finestra anti-replay di dimensione W. Questa finestra limiterà quanto fuori ordine può essere un pacchetto, rispetto al pacchetto con il numero di sequenza più alto che è stato autenticato finora. (Non viene stabilito alcun requisito per dimensioni minime o raccomandate per questa finestra, oltre ai valori di 32 e 64 pacchetti già stabiliti per finestre con numeri di sequenza a 32 bit. Tuttavia, si suggerisce che un implementatore scali questi valori in modo coerente con la velocità dell'interfaccia supportata da un'implementazione che utilizza l'opzione ESN. Inoltre, l'algoritmo descritto di seguito presume che la finestra non sia maggiore di 2^31 pacchetti in larghezza.) Tutti i 2^32 numeri di sequenza associati a qualsiasi valore fisso per i 32 bit di ordine superiore (Seqh) saranno d'ora in poi chiamati un sottospazio di numeri di sequenza. La seguente tabella elenca le variabili pertinenti e le loro definizioni.

Var. Name	Size (bits)	Meaning
W	32	Dimensione della finestra
T	64	Numero di sequenza più alto autenticato finora, limite superiore della finestra
Tl	32	32 bit inferiori di T
Th	32	32 bit superiori di T
B	64	Limite inferiore della finestra
Bl	32	32 bit inferiori di B
Bh	32	32 bit superiori di B
Seq	64	Numero di sequenza del pacchetto ricevuto
Seql	32	32 bit inferiori di Seq
Seqh	32	32 bit superiori di Seq

Quando si esegue il controllo anti-replay, o quando si determina quali bit di ordine superiore utilizzare per autenticare un pacchetto in arrivo, ci sono due casi:

• Case A: Tl >= (W - 1). In questo caso, la finestra è all'interno di un sottospazio di numeri di sequenza. (Vedere Figura 1)
• Case B: Tl < (W - 1). In questo caso, la finestra si estende su due sottospazi di numeri di sequenza. (Vedere Figura 2)

Nelle figure seguenti, la linea inferiore ("----") mostra due sottospazi di numeri di sequenza consecutivi, con zeri che indicano l'inizio di ciascun sottospazio. Le due linee più corte sopra di essa mostrano i bit di ordine superiore che si applicano. Il "====" rappresenta la finestra. Il "****" rappresenta numeri di sequenza futuri, cioè quelli oltre il numero di sequenza più alto attuale autenticato (ThTl).

    Th+1                         *********

    Th               =======*****

          --0--------+-----+-----0--------+-----------0--
                     Bl    Tl            Bl
                                    (Bl+2^32) mod 2^32

                        Figure 1 -- Case A


    Th                           ====**************

    Th-1                      ===

          --0-----------------+--0--+--------------+--0--
                              Bl    Tl            Bl
                                             (Bl+2^32) mod 2^32

                        Figure 2 -- Case B

B2.1. Managing and Using the Anti-Replay Window

La finestra anti-replay può essere pensata come una stringa di bit dove 'W' definisce la lunghezza della stringa. W = T - B + 1 e non può superare 2^32 - 1 in valore. Il bit più in basso corrisponde a B e il bit più in alto corrisponde a T, e ogni numero di sequenza da Bl a Tl è rappresentato da un bit corrispondente. Il valore del bit indica se un pacchetto con quel numero di sequenza è stato ricevuto e autenticato, in modo che i replay possano essere rilevati e rifiutati.

Quando viene ricevuto e convalidato un pacchetto con un numero di sequenza a 64 bit (Seq) maggiore di T,

• B viene aumentato di (Seq - T)
• (Seq - T) bit vengono eliminati dall'estremità inferiore della finestra
• (Seq - T) bit vengono aggiunti all'estremità superiore della finestra
• Il bit superiore viene impostato per indicare che un pacchetto con quel numero di sequenza è stato ricevuto e autenticato
• I nuovi bit tra T e il bit superiore vengono impostati per indicare che non sono ancora stati ricevuti pacchetti con quei numeri di sequenza.
• T viene impostato sul nuovo numero di sequenza

Nel controllo dei pacchetti riprodotti,

• Nel Case A: Se Seql >= Bl (dove Bl = Tl - W + 1) AND Seql <= Tl, allora controllare il bit corrispondente nella finestra per vedere se questo Seql è già stato visto. Se sì, rifiutare il pacchetto. Se no, eseguire il controllo di integrità (vedere Appendice B2.2 di seguito per la determinazione di SeqH).

• Nel Case B: Se Seql >= Bl (dove Bl = Tl - W + 1) OR Seql <= Tl, allora controllare il bit corrispondente nella finestra per vedere se questo Seql è già stato visto. Se sì, rifiutare il pacchetto. Se no, eseguire il controllo di integrità (vedere Appendice B2.2 di seguito per la determinazione di Seqh).

B2.2. Determining the Higher-Order Bits (Seqh) of the Sequence Number

Poiché solo 'Seql' verrà trasmesso con il pacchetto, il ricevitore deve dedurre e tracciare il sottospazio di numeri di sequenza in cui rientra ciascun pacchetto, cioè determinare il valore di Seqh. Le seguenti equazioni definiscono come selezionare Seqh in condizioni "normali"; vedere l'Appendice B3 per una discussione su come recuperare da una perdita estrema di pacchetti.

Nel Case A (Figura 1):

• Se Seql >= Bl (dove Bl = Tl - W + 1), allora Seqh = Th
• Se Seql < Bl (dove Bl = Tl - W + 1), allora Seqh = Th + 1

Nel Case B (Figura 2):

• Se Seql >= Bl (dove Bl = Tl - W + 1), allora Seqh = Th - 1
• Se Seql < Bl (dove Bl = Tl - W + 1), allora Seqh = Th

B2.3. Pseudo-Code Example

Il seguente pseudo-codice illustra gli algoritmi sopra per i controlli anti-replay e di integrità. I valori per 'Seql', 'Tl', 'Th' e 'W' sono interi senza segno a 32 bit. L'aritmetica è mod 2^32.

If (Tl >= W - 1)                            Case A
    If (Seql >= Tl - W + 1)
        Seqh = Th
        If (Seql <= Tl)
            If (pass replay check)
                If (pass integrity check)
                    Set bit corresponding to Seql
                    Pass the packet on
                Else reject packet
            Else reject packet
        Else
            If (pass integrity check)
                Tl = Seql (shift bits)
                Set bit corresponding to Seql
                Pass the packet on
            Else reject packet
    Else
        Seqh = Th + 1
        If (pass integrity check)
            Tl = Seql (shift bits)
            Th = Th + 1
            Set bit corresponding to Seql
            Pass the packet on
        Else reject packet
Else                                    Case B
    If (Seql >= Tl - W + 1)
        Seqh = Th - 1
        If (pass replay check)
            If (pass integrity check)
                Set the bit corresponding to Seql
                Pass packet on
            Else reject packet
        Else reject packet
    Else
        Seqh = Th
        If (Seql <= Tl)
            If (pass replay check)
                If (pass integrity check)
                    Set the bit corresponding to Seql
                    Pass packet on
                Else reject packet
            Else reject packet
        Else
            If (pass integrity check)
                Tl = Seql (shift bits)
                Set the bit corresponding to Seql
                Pass packet on
            Else reject packet