1

Security of Patched DNSBar Ilan University, Department of Computer Science, Network Security Group Technical Report TR12-04

Amir Herzberg and Haya Shulman

Abstract—Most caching DNS resolvers still rely for their security, against poisoning, on validating that the DNS responses containsome ‘unpredictable’ values, copied from the request. These values include the 16 bit identifier field, and other fields, randomised andvalidated by different ‘patches’ to DNS. We investigate the prominent patches, and show how attackers can circumvent all of them,namely:• We show how attackers can circumvent source port randomisation, in the (common) case where the resolver connects to the

Internet via different NAT devices.• We show how attackers can circumvent IP address randomisation, using some (standard-conforming) resolvers.• We show how attackers can circumvent query randomisation, including both randomisation by prepending a random nonce and

case randomisation (0x20 encoding).We present countermeasures preventing our attacks; however, we believe that our attacks provide additional motivation for adoption ofDNSSEC (or other MitM-secure defenses).

Index Terms—DNS security, DNS poisoning, Kamisky attack, Network Address Translator, NAT, DNS server selection, Internet security.

F

1 INTRODUCTION

CORRECT and efficient operation of the DomainName System (DNS) is essential for the operation of

the Internet. However, there is a long history of vulner-abilities and exploits related to DNS, mostly focusing onDNS cache poisoning. In a poisoning attempt the attackercauses recursive DNS servers (resolvers) to cache anincorrect, fake DNS record, e.g., mapping VIC-Bank.comto an IP address controlled by the attacker; Son andShmatikov [1] performed an extensive study of the vul-nerabilities in caching policies of DNS resolvers, thatallow poisoning attacks. DNS poisoning can facilitatemany other attacks, such as injection of malware, phish-ing, website hijacking/defacing and denial of service.

The main technique for DNS poisoning is by generat-ing forged responses to DNS requests which were sentby resolvers; as a countermeasure, the resolvers validateresponses using different mechanisms. Currently, mostresolvers rely on non-cryptographic validation, mainly,confirming that the response echoes some unpredictable(random) values sent with the request, such as in theDNS transaction ID field, the source port selected bythe resolver, or within the resource (domain) name;e.g., see RFC 5452 [2] for more details. Obviously, suchmechanisms are insecure against a Man-in-the-Middle(MitM) attacker, who can read the randomness fromthe request and send a fake response with the valididentifiers.

• Computer Science Department, Bar Ilan University, Ramat Gan, Israel,52900.E-mail: {amir.herzberg,haya.shulman}@gmail.com .

Furthermore, even a weaker - and more common -off-path, spoofing attackers, may be able to send validDNS responses and cause DNS poisoning, when thevalidated values are predictable or limited. For example,some DNS implementations use predictable identifiers(sequential, or produced by a weak pseudorandom gen-erator); e.g., in [3], Klein shows how to predict theidentifier for the then-current version of Bind 9, a widely-used DNS server, and how this can be exploited forhighly-efficient DNS poisoning by off-path attackers.Indeed, as pointed out by Vixie [4], already in 1995,the identifier field alone is simply too short (16 bits) toprovide sufficient defense against a determined spoofingattacker, who can foil it by sending (not too) many fakeresponses.

To improve DNS security, the IETF published DNSSEC[5], [6], [7], an extension to DNS, using cryptogra-phy (signatures and hashing) to ensure security (even)against MitM attackers. However, in spite of the publi-cation of DNSSEC more than a decade ago, in 1997 [8],and the wide awareness to its existence, deployment isstill limited - e.g., less than 2% as reported in [9] forApril, 2012. There are also many caching DNS resolversthat still do not support, or do not perform validationof, DNSSEC [10]; see discussion of the deployment statusof DNSSEC in [11]. Furthermore, due to implementationerrors DNSSEC protection may fail, even when both theresolver and zone deploy it: validation of signatures ofimportant top level domains, e.g., mil, fails since the rootdoes not delegate the public signature verification keyof mil but instead provides an (incorrect) indication thatmil does not support DNSSEC. This results in resolversfalling back to a non-validating mode.

2

Indeed the deployment of DNSSEC is progress-ing slowly, due to challenges (see [11]), and possiblydue to the recent improvements (‘patches’) to non-cryptographic defenses, causing the ‘if it ain’t broke,don’t fix it’ response. These patches are mainly bydeploying new sources of ‘unpredictability’ in DNS re-quests and responses, such as use of random sourceports [12], [13], random DNS server selection [2] andrandom capitalisation of the domain name [14].

This manuscript investigates such non-cryptographic‘patches’, that are deployed as countermeasures againstDNS cache poisoning. Our goal is twofold: (1) to helpimprove these patches, since evidently they will remainwidely used for years; and (2) to further motivate adop-tion of more secure solutions such as DNSSEC, by point-ing out weaknesses in the patches. While these specificweaknesses can be fixed (and we show how - often,easily), their existence should motivate the adoption ofbetter security measures such as DNSSEC, providingdefense against a MitM attacker and allowing for bettervalidation of security, e.g., see [15].

1.1 Patching DNS Resolvers Against Poisoning

Many researchers have identified vulnerabilities andsuggested improvements in the approach of relying onan ‘unpredictability’ of some fields in a DNS requestand proposed patches; we next review some of the mainresults. Bernstein, [16], suggested to improve DNS’sdefense against spoofed responses by sending the re-quest from a random port, which can add a significantamount of entropy1. To prevent birthday attack, whereattacker causes resolver to issue multiple queries forsame domain in order to increase the probability of amatch with one of multiple fake responses, Bernstein[16] and others suggest to limit the maximal numberof concurrent requests for the same resource record (toone or to some small number); this technique is usuallyreferred to as the birthday protection.

Many implementations did not integrate support forthese suggestions till the recent Kaminsky attack, [12],[13], which showed that DNS cache poisoning was apractical threat. Kaminsky introduced two critical im-provements, allowing devastating attacks on many In-ternet applications. The first improvement was to con-trol the time at which the resolver sends queries (towhich the attacker wishes to respond), by sending tothe resolver queries for a non-existing host name, e.g.,with a random or sequential prefix of the domain name.The second improvement was to add, in the spoofedresponses sent to the resolver, a type NS DNS record(specifying a new name for the domain name server)and/or a type A ‘glue’ DNS record (specifying the IPaddress of that domain’s name server). These recordspoison the resolver’s entries for the victim name server.

1. The exact amount of entropy added depends on the number ofavailable ports, which may be below 216.

Hence, if the attack succeeds once (for one record), theadversary controls the entire name space of the victim.

As a result of Kaminsky’s attack, it became obviousthat changes were needed to prevent DNS poisoning.Indeed, major DNS resolvers were quickly patched.The most basic patches were known measures - sourceport randomisation and birthday protection (see above).These and other additional patches were summarisedin RFC 5452 [2], including the use of random (valid)IP addresses for the name server. Additional patches,implemented by some resolvers, are to randomise DNSqueries by randomly ‘case toggling’ the domain name(0x20 encoding [14]), or by adding a random prefix tothe domain name [17]. Other patches were proposed,[18], [19], [20], [21], however, they are not yet deployed.

It is tempting to interpret the analysis in [14], [22],[2], [17] as indication that the ‘patches’ may suffice tomake poisoning impractical, reducing the motivationfor deployment of more systematic defenses. However,we caution against this conclusion. This work showsthat in common network scenarios, attackers can of-ten circumvent some or all of the ‘patches’, making itfeasible to poison resolvers that rely on validation of‘unpredictable’ values copied from requests to responses(rather than relying on cryptographic security affordedby DNSSEC).

Some concerns pertaining to ‘patches’ were presentedin earlier works. In particular, the most widely deployed‘patch’ is source port randomisation. However, securityexperts, e.g., [23], [13], [21], noted that DNS resolverslocated behind firewall/NAT devices, that use sequentialassignment of external ports, were still vulnerable tothe poisoning attack. On the other hand, it was widelybelieved that ‘port-randomising’ NAT devices, that suf-ficiently randomise the external ports, could retain oreven improve the defense against DNS cache poisoning,e.g., see [13]. In addition, it was believed that ‘port-preserving’ NAT devices, that leave the source port in-tact, can be safely used with port-randomising resolvers,e.g., see [24]. Our results show otherwise, i.e., some ofour attacks show how to circumvent port randomisa-tion, in the resolver-behind-NAT scenario, even for port-randomising and port-preserving NATs.

Note that the resolver-behind-NAT scenario is com-mon [25], [26]. A recent study, [10], of DNSSEC de-ployment by recursive resolvers observed that a largenumber of recursive DNS resolvers is located behindNAT devices, and often multiple resolvers reside behindthe same NAT device. Furthermore, [27] found that 90%out of 20,000 DSL lines (from a major European ISP) werelocated behind NAT devices.

1.2 Attacker Model

In our attacks, we assume an off-path, spoofing adver-sary connected to the Internet and a host, compromisedby the adversary), on the local network; the attackermodel is depicted in Figure 1. Depending on the attack,

3

Fig. 1. Attack scenario and network configuration. We assume an off-pathspoofing attacker Eve on the Internet. Attacks in Section 2 are targeted againstDNS resolvers located behind NAT devices, using a zombie; In Sections 3 and 4we assume a puppet (and do not require a NAT).

we assume different capabilities on the malware runningon the internal host. The attacks in Section 2 assumea non-spoofing (user-mode) compromised host (zombie)on the local network (zombies exist in many networks,e.g., see [28]); the zombie can open user mode socketsand can send arbitrary (non-spoofed) packets, [29]. Inthese attacks we also assume that the resolver is locatedbehind a NAT device. The attacks in Sections 3 and 4use a puppet (a script confined by a browser), and donot require the network to be connected to the Internetvia a NAT.

1.3 Contributions

The security of patched DNS resolvers relies on therandomness provided by the validation fields. We showthat it is possible to reduce and often to nullify the ran-domness, thereby exposing the resolvers to Kaminsky-style poisoning attacks. Our attacks apply to widely-deployed ‘patches’:Source-port randomisation. In Section 2 we expose vul-nerabilities in common source port allocation algorithmsused by popular NAT devices. The vulnerabilities allowto circumvent source port randomisation, thus enablingprediction of the source port in DNS requests. We testedour attacks in a lab setting against several popular NATdevices, see Table 1. The type of the NAT that theresolver resides behind is important in deciding whichattack technique to launch.

DNS server IP randomisation. We present techniquesallowing to predict the IP address of the name server towhich the resolver will send its DNS request (Section 3).Our techniques rely on fragmented DNS responses.

Domain name randomisation. In Section 4 we showthat randomisation of DNS queries via 0x20, or byprepending a random string, is not always effective anddoes not introduce protection against poisoning attacks.

In addition to exposing the vulnerabilities, we alsopropose countermeasures. However, our most importantcontribution is in motivating the adoption of systematic,secure defenses against poisoning, such as DNSSEC.

A preliminary version of this work appeared in [31].

2 SOURCE PORT (DE)RANDOMISATION

The main defense against DNS cache poisoning is sourceport randomisation (SPR). When the resolver supportsSPR, it selects the source port in each DNS request,that it sends, at random. SPR increases the entropyin DNS requests by a factor of O(216), and therefore,appears to provide sufficient protection against DNScache poisoning by off-path attackers.

In this section we present techniques to trap/predict2

the external port that will be allocated by the NAT deviceto the DNS request, of the DNS resolver, which theattacker wishes to poison. This phase allows to reduce(in some cases even nullify) the randomness added bySPR. We tested our trap/predict attacks against popularnetwork address translation (NAT) and firewall (FW)devices, see Table 1, and we identified three categortiesof port allocation mechanisms, such that, each devicetypically supports an allocation according to one of thosecategories:

(1) random allocation where NAT selects ports at ran-dom from a pool of available ports until all the ports areexhausted; (2) per-destination sequential allocation wherethe NAT selects the first port to each destination atrandom, and subsequent packets to that destinationare allocated consecutive mappings; (3) port preservingallocation, where the NAT preserves the original portin the outgoing packets, and allocates sequentially uponcollision3.

Note that all the allocations (above) are ‘believed’ tobe secure and sufficient to prevent DNS cache poisoningattacks. Indeed following to Kaminsky attack, DNS-OARC set up an online tool, porttest [30], to allowtesting for source port randomisation.

dig +short porttest.dns-oarc.net txt

The tool assigns one of the possible three scores: GREAT,GOOD and POOR, rating the ‘unpredictability’ of theports’ allocation process. We tested the amount of un-predictability of the source ports assigned by the devicestested in this work, via the porttest tool, and the toolreported a GREAT score for all the devices.

However, as we show in this work, merely randomis-ing the source ports does not guarantee that the portscannot be predicted (or trapped). We present techniquesallowing attackers to effectively derandomise the SPRof the NAT devices that implement ports’ allocationbelonging to one of the above categories. The conclusionis that ports that ‘appear’ to be random should not betaken as indication of security.

In what follows we show (trap/predict) techniques tocircumvent SPR supported by each category: a random al-location (Section 2.1), per-destination sequential allocation(Section 2.2) and port preserving allocation (Section 2.3).

2. Depending on the attack strategy, we coin our attacks trap orpredict attacks.

3. Upon collision, depending on the implementation, the collidingport can be assigned a random port, e.g., CISCO IOS; we associatesuch implementations with the random category.

4

Vendor Port Allocation Port-test Rating [30] Vulnerability [Section]

Linux Netfilter Iptables per-destination GREAT Predict attack(kernel 2.6) with ‘–random’ sequential [Section 2.2]

Linux Netfilter Iptables preserving GREAT Predict attack(kernel 2.6) (sequential if collide) [Section 2.3]Fedora 16 preserving GREAT Trap attack

(kernel 3.3.0) (random if collide) [Section 2.1]FreeBSD 9 preserving GREAT Trap attack

(random if collide) [Section 2.1]Windows XP ICS first random GREAT Predict attack(Service Pack 3) then sequential [Section 2.2]

Windows XP WinGate preserving GREAT Trap attack(Release 2.6.4) (random if collide) [Section 2.1]

CISCO IOS (release 15) preserving GREAT Trap attack(random if collide) [Section 2.1]

CISCO ASA (release 5500) random GREAT Trap attack[Section 2.1]

TABLE 1Summary of the source port derandomisation attacks presented in this work, against different types of NAT devices that were tested.

We tested the attacks against popular NAT devices, eachsupporting an algorithm from one of the category; seeTable 1. In our attacks we use a patched DNS resolver,Unbound 1.4.18, which supports source port and trans-action ID randomisation.

The NAT allocates mappings (permutations) betweenthe addressing used by the internal host, identifiedby the tuple (SIP :SPort, DIP :DPort), and the address-ing used by the external host, identified by the tuple(NATIP :NATPort, DIP :DPort), with the same values ofDIP :DPort in both tuples. We denote such mappings(permutations) by function f(·).

2.1 Trap-then-Poison for Random Ports

The attack in this section relies on the fact that the NATimplements outbound refresh mapping for UDP connec-tions, as specified in requirement 6 of RFC 4787 [32] (andimplemented in most NATs). Namely, the NAT main-tains the mappings from an internal (source) SIP : Sport

pair to an external port NATport, for T seconds since apacket was last sent from SIP :Sport (on the internal sideof the NAT) to the external network, using this mapping.We further assume that the NAT device selects an exter-nal port at random for each outgoing packet, e.g., CISCOASA. The NAT device silently drops outgoing packets,sent from SIP :Sport to DIP :Dport, when all external portsfor DIP :Dport are currently mapped to other sources; thisis the typical expected NAT behaviour, see [32].

The attack begins when the zombie contacts the at-tacker’s command-and-control center, identifies its lo-cation, and receives a signal to initiate the attack. Wenext describe the steps of the attack; also illustrated withsimplifications in Figure 2.

1) The zombie, at address 10.6.6.6, sends UDP packetsto 1.2.3.4:53, i.e., to the DNS port (53) of thename server of the ‘victim’ domain, whose fullyqualified domain name (FQDN) is ns.V.com, fromeach port p in the set of available ports Ports. To

handle faults, the payload of each packet containsthe sending port p ∈ Ports. The NAT allocates toeach packet it forwards to ns.V.com a ‘random’permutation f over Ports; the allocation of eachexternal port f(p) to a specific internal port p isheld for T seconds, unless refreshed. Since noneof these packets is a legitimate DNS packet, theauthoritative name server ns.V.com ignores all ofthem, and does not send back any response.

2) After step 1 completed4, Eve sends a packet witha spoofed source address 1.2.3.4:53, to externalport 666 of the NAT (i.e., to 7.7.7.7:666). Since7.7.7.7:666 is currently mapped to the internal IPaddress 10.6.6.6 and some port f−1(666), the NATrelays the packet to this IP and port. Thereby, thezombie learns the mapping of external port 666 tothe internal port f−1(666); this will be crucial inthe continuation of the attack, where we ‘force’ thequery of the resolver to be sent using external port666 (the ‘trap’). This packet contains as a payloada random string of 8, or so, digits to be used as theprefix of the FQDN in the query sent in the attack(in step 4).

3) After receipt of the packet on port f−1(666) in step2, the zombie waits until the mappings establishedin step 1 are about to expire, i.e., until t3 = t1 + T(where t1 is the time of step 1). At t3, the zombiesends additional empty UDP packets, to all portsin Ports, except port f−1(666). As a result, the NATrefreshes the mappings on all of these ports; onlythe mapping for port 666 times out, and hence thisbecomes the trap: i.e., the only available externalport of the NAT, which can be allocated for UDPpackets whose destination is 1.2.3.4:53.

4) Following to step 3, the attacker knows that theexternal port 666 of the NAT is the only port which

4. Eve can learn it is time to send the packet at the beginning ofstep 2, e.g., by an appropriate packet from the zombie to Eve uponcompletion of step 1.

5

Resolver10.0.0.2

Alice10.0.0.1

Zombie10.6.6.6

Eve6.6.6.6

ignored

Step

1

2

3

4

5

6

7

8

NAT7.7.7.7

ignored

ignoredrefresh

If fail: repeatfrom step 1

Fig. 2. DNS trap-then-poison attack with random ports allocation, for configuration in Figure 1.

can be allocated to the UDP packets sent from theinternal network to the authoritative name server,at 1.2.3.4:53. The zombie sends a single DNS queryto the resolver, for a random FQDN r.V.com; theuse of a random ‘subdomain’ r allows to evadethe caching of the resolver and ensures that theresolver issues a DNS query for this FQDN. Theresolver then sends a query to ns.V.com, fromsome ‘random’ (more precisely, unpredictable toattacker) port which we denote p, and using somerandom identifier i.

5) Next, Eve sends a forged response per each i ∈ 216

values of the ID field. If one of these responsesmatches all of the validation fields in the query,the resolver accepts the poisoned records [r.V.comA 6.6.6.6] and [V.com NS r.V.com]. Namely,from this point on, the resolver considers 6.6.6.6as a valid IP address for the authoritative DNSserver of ns.V.com. The resolver also forwards theresponse [r.V.com A 6.6.6.6] to the zombie,which detects the successful attack, and informsEve (this phase is not shown in the figure).

6) The resolver receives a legitimate ‘non-existingdomain’ (NXDOMAIN) response from the ‘real’name server, at 1.2.3.4. If the attack succeeded thisresponse is ignored, since the query is not pendingany more. Otherwise, the resolver forwards theNXDOMAIN response to the zombie, who willinform Eve; they will repeat the attack from step1 (as soon as the ports expire on the NAT).

7) Finally, steps 7 and 8 illustrate subsequent poi-

soning of ‘real’ FQDN within the V.com domain.Since, following step 5, the resolver uses the‘poisoned’ mappings [ns.V.com A 6.6.6.6], allsubsequent requests for this domain are sent to6.6.6.6.

2.2 Predict-then-Poison for Per-Destination Ports

In practice, due to efficiency considerations, NATdevices often do not select a random external portfor every outgoing packet, but, depending on the NATdevice, select the first port (for a tuple defined by< SIP : SPort, DIP : DPort, protocol >) at random, andsubsequent ports are increased sequentially (for thattuple), until NAT refreshes its mapping for that tuple(if no packets arrived, by default after 30 seconds).For a different tuple, e.g., different destination IP, anew random port is selected for first packet, whilesubsequent packets are assigned sequentially increasingport numbers. When the NAT refreshes the mappingthe port for outgoing packets with destination IP andport tuple is selected at random again. This behaviouris consistent with prominent NAT devices, e.g., IptablesNAT, Carrier Grade NAT [33].

In this section we present predict-then-poison attackon a NAT supporting a per-destination sequential portsallocation. In contrast to ‘trap’ attacks, the ‘predict’attacks exploit an insufficient source port randomisationmechanism of the NAT, which allows to producemuch more efficient attacks by predicting the sourceport allocated for the DNS requests by the NAT. Inparticular, the zombie is only required to generate

6

Resolver10.0.0.2

Alice10.0.0.1

Zombie10.6.6.6

Eve6.6.6.6

ignored

Step

1

2

3

4

5

6

7

8

NAT7.7.7.7

ignored

I f f a i l : r e p e a tf r o m s t e p 1

x←$

d←$

q←$ q'←$

Fig. 3. Predict-then-poison DNS attack, for configuration in Figure 1, assuming per-destination port sequential NAT.

and send three packets during the attack: first packetcreates a mapping in the NAT table (so that packetsfrom Eve can come through), subsequent packet letsEve know which external port was used by the NAT,and the third packet is a DNS query which the zombiesends to local resolver for some random name in thevictim domain r.V.com. The attack can be optimised byhaving the zombie transmit k packets5 (1 ≤ k ≤ 216)from consecutive ports; Eve then sends

⌊Pk

⌋packets

(P ≡|Ports|), such that j-th packet is sent to portPorts[j · k]. The steps of the attack (in Figure 3) follow.

1) Zombie opens the ports (to the destination IPaddress of the authoritative DNS), i.e., sends kUDP packets from sequentially increasing portsPorts[1],...,Ports[k]. All k packets have 1.2.3.4:53 asthe destination IP address and UDP port respec-tively (i.e., the name server of the victim domain,whose FQDN is ns.V.com). The NAT assigns arandomly selected port Ports[x] to the first packet(in the sequence of k packets) that it receives, therest k−1 packets are assigned consecutive (sequen-tially increasing) external ports. The NAT sendsthese k packets to ns.V.com. The authoritative DNSns.V.com ignores those UDP packets, since they donot constitute valid DNS requests.

2) Eve sends⌊Pk

⌋UDP packets, to sequentially in-

creasing (by a factor of k) external ports of the NAT,with spoofed source IP 1.2.3.4:53. The payload of

5. Typically, it may be preferable for zombie to issue less packets(i.e., to use smaller k) to evade detection.

each packet contains the destination port number.The zombie receives exactly one packet from Eve,w.l.o.g. on port Ports[i∗], and with payload con-taining j∗ ·k (i.e., packet that was sent to port withindex Ports[j∗ · k] of the NAT).

3) Next the zombie calculates the port that will beassigned by the NAT to the DNS query of thelocal resolver: Ports[j∗ · k+ (k− i∗) + 1], and sendsit to Eve in the payload (from some (random)source port Ports[$] to a destination port 666, onwhich Eve is configured to be listening). Since thedestination IP address of the packet sent to Eve isdifferent from that of the authoritative name server,NAT will select an external port at random, andnot consecutively, i.e., some Ports[$] s.t., with highprobability Ports[$] 6=Ports[x+ k + 1].

4) The zombie then issues a DNS query to the localresolver, asking for a random FQDN r.V.com. Sincethis domain name most likely does not exist in thecache, the resolver sends a DNS query from some(random) port Ports[d] containing a random iden-tifier, to the authoritative name server ns.V.com.Note that the destination in the query of the localresolver is the same as the one that was used in theUDP packets of the zombie (i.e., the authoritativename server), the NAT will allocate the next avail-able (consecutive) port to the query of the resolver,i.e., Ports[x+k+1], following the sequence of portsassigned to the packets of zombie.

5) As soon as Eve receives the packet containing theexternal port of the NAT that is mapped to the

7

internal port of the resolver, she will generate andtransmit P packets with different values in the IDfield, with spoofed source IP address (ostensiblyoriginating from ns.V.com). The destination portin all the packets is Ports[j∗ · k + (k − i∗) + 1], andthe response contains: [r.V.com A 6.6.6.6] and[V.com NS r.V.com]. Since this port was allo-cated by the NAT to the query sent by the resolver,the NAT will forward all these DNS responses tothe resolver.

6) Eventually when the authentic response ‘non-existing domain’ (NXDOMAIN) of the real nameserver at 1.2.3.4 arrives, the resolver will ignore itif one of the maliciously crafted packets (sent byEve) matched and gets accepted.

The remaining steps are identical to steps (7) and (8),presented in Section 2.1, Figure 2.

2.3 Predict-then-Poison for Preserving Ports

Port preserving NAT leaves the original source portwithout modification when possible. When two clients(with different source IP addresses) send a packet (each)with the same source port, NAT preserves the port ofthe first packet and assigns the next available port tothe second packet6, e.g., Linux (iptables) based NATassigns the (lowest) next available port when collisionoccurs. The challenge (in this case) is to ensure that thequery of the local resolver falls in the range of the portsoccupied by the zombie. Eve and zombie can coordinatein advance on the range size and initial and final indicesof the packets sent by the zombie to the authoritativeDNS. The steps of the attack are identical to the stepsof the attack in Figure 3, with one exception: in step(2) Eve does not need to send P

k packets and a singlepacket suffices. The number k of UDP packets, that thezombie sends, should be sufficiently large, to increase theprobability that the DNS packet of the local resolver fallsin the occupied range. The probability that the sourceport in a DNS query of the resolver will be in the rangeof ports occupied by the UDP packets of the zombie is k

P ,where k is the number of ports occupied by the zombie,and P is the total number of ports.

To evade detection7, part of the attack can be carriedout by the puppets. Specifically, the puppets can beused to make k queries to the local resolver, to occupysufficiently large range of ports, causing the query of thelocal resolver to be mapped to a predictable port.

The steps of the attack are as follows:1) Zombie sends k UDP packets, with sequentially

increasing ports destined to the authoritative DNS:Ports[i] (j ≤ i ≤ k) where j ≥ 1. The idea is to

6. The source port selection procedure, when collision occurs, variesdepending on the NAT implementation, e.g., can be sequential like inLinux, or random like in CISCO IOS.

7. In order to maintain control over a zombie the attacker wouldprefer to reduce the usage of the zombie to minimum, and to usepuppets when possible.

occupy a range (of size k) of ports. NAT assignsk consecutive ports, preserving the original sourceports.

2) Eve sends Pk packets to the zombie, such that each

packet contains the destination port in payload.This step is essential since the NAT may havealready allocated some of the ports to other clients’packets, and the packets of the zombie will beallocated higher ports. Therefore, Eve needs to sendto receive the last port that was allocated by theNAT to the packets of zombie.

3) Upon receipt of a first packet from Eve (the rest areignored) the zombie sends to Eve

4) Zombie then sends to Eve the port number Ports[k],of the last packet, in the payload.

5) As soon as Eve receives the packet from zombie,she transmits 216 DNS responses with all the possi-ble IDs, destined to the NAT 7.7.7.7 : p+k+1. NATwill forward the responses to the local resolver,since p + k + 1 is mapped to d. The local resolveraccepts and stores the response.

6) Zombie makes a DNS query to the local resolverasking for a random FQDN in domain V.com; thisdomain name most likely will not be in cacheand as a result, the resolver will issue a DNSquery from some random port d, containing arandom identifier, to the authoritative name serverns.V.com. If NAT has already allocated port d, itwill select (sequentially) the next available port,and will assign this port as the external port of theDNS query. Since zombie occupied p, ..., p + k thenext available port is p+ k + 1.

The next steps, (5)-(7), are identical to steps (6)-(8) inattack presented in Section 2.2.

The probability that the source port in the DNS queryof the local resolver will have already been allocated byNAT to the packets sent by zombie is proportional to k;If the port in the DNS request of the resolver falls withinthe range defined by k, the port will be mapped to nextavailable port, i.e., p+ k+1. This is the destination portthat Eve will use in its spoofed responses.

2.4 Experimental Evaluation

We next describe the setting that we used for validationof the attacks in this section. We also summarise ourresults for each NAT device, against which we testedthe attacks, in Table 1; the NAT devices were selectedfrom different categories, i.e., proprietary NAT devices,e.g., Checkpoint, SOHO NAT devices, e.g., windows XPICS, and other prominent NAT devices. This list of NATdevices that we tested is of course not exhaustive, butsince we found that almost all of them, except one,allowed the attacker to reduce source port randomisationof the resolver, it is very likely that many more may bevulnerable to our (or other) attacks, e.g., Carrier GradeNAT of Juniper Networks (based on the technical report,[33], published in 2011).

8

Testbed Setup. Figure 1 illustrates the testbed used forthe experimental evaluation of our attacks. The testbedconsists of a NAT enabled gateway, which has two net-work cards. One card is connected via an ethernet cableto a switch, connecting a benign client, a compromisedhost, and a DNS resolver. The other is connected to Eve(also via a switch). The DNS resolver is running Un-bound 1.4.18 software. The tests were run concurrentlywith other benign uses of the network. We report on theresults of the success of the DNS cache poisoning, byrunning trap and predict attacks against popular NATdevices, in Table 1, and in more detail in the technicalreport [11].

2.5 Improved Port Allocation Mechanism

The recommendations, [34], for NAT behaviour do notspecify the implementation of port allocation mecha-nism. As a result, the developers and designers of NATdevices follow different approaches which may seemsecure. Based on our findings we identify two designfactors in ports allocation mechanism of the NAT: (1) theprocess via which the ports are selected (i.e., random,preserving, sequential); (2) the mapping table whichmaintains the allocated ports.Randomise Ports Selection. Use port randomisation, buteither with separate, random external port for eachinternal port, or at least with pseudo-random (but notsequential) increments between external port numbers8.Random ports assignment prevents the ‘predict’ attacks.Restricted Mapping Table. The mapping table of allo-cated ports, maintained by the NAT, should be smallerthan the pool of all the ports9, e.g., half or less of the totalof number of ports; a smaller mapping table preventsthe attacker from trapping the port. For each arrivingpacket NAT should randomly select and assign a portfrom the pool of ports. Each time an entry is removedfrom the table when the external port is freed, e.g., theentry is refreshed after a timeout, NAT should select anew random port from the pool of ports.

3 IP ADDRESSES (DE)RANDOMISATION

DNS resolvers can increase the entropy in DNS re-quests by randomising the IP addresses, i.e., selectingthe source/destination IP addresses in a DNS requestat random, and then validating the same addresses inthe DNS response. Selecting random source IP addressis rare, and the resolvers are typically allocated one (orfew) IP address as IPv4 addresses are a scarce resource.Furthermore, resolvers behind NAT devices use the IPof the NAT for their requests, and the address of theresolver is generally known [2].

8. A pseudo-random permutation will provide as efficient datastructure and lookup, as when using sequential allocation.

9. This approach was supported only by the Checkpoint NAT whichallowed it to evade our trap attacks.

In contrast, most operators of DNS zones use a num-ber of authoritative name servers for performance, ro-bustness, and enhanced resilience to cache poisoningattacks. We found that the majority of top level domains(TLDs) use 5 to 7 authority name servers, and importantdomains, e.g., com, use 13 authority servers10; see Fig-ure 4.

When zone operators employ multiple authorityservers, the resolver should send the query to the onewith the shortest response time, and avoid querying non-responsive name servers, see [36], [37], [38].

We present techniques that enable an off-path attackerto predict the target name server’s IP, for resolverswhich avoid querying unresponsive name servers, as perthe recommendations in [38], [37]; i.e., when the targetname server is not responsive, i.e., queries time-out, theresolver does not send subsequent queries to it, but onlyperiodically, probes the target server until it becomesresponsive. The (standard-conforming) Unbound (1.4.18)resolver sets this probing interval to 15 minutes. Asimilar behaviour was observed by [38] in PowerDNS,with the exception that PowerDNS sets the interval to3 minutes. It appears that relying on the DNS server IPaddress randomisation for additional entropy requirescareful study of particular resolver in question.

12345678910111213140

10

20

30

40

50

60

70

Number of servers

TL

Ds

Fig. 4. The number of IP addresses in use by Top Level Domains (TLDs).

The idea of the attack is to indirectly intervene ina fragment reassembly process by spoofing a secondfragment. The spoofed second fragment is reassembledwith the first authentic fragment which results in acorrupt, e.g., incorrectly formatted, DNS response. Thisresponse is discarded by the resolver. After several failedattempts, the destination IP is marked as non-responsiveand is blocked for interval τ of time; τ depends on theresolver implementation.

We next (Section 3.1) present the attack and the exper-imental evaluation, and then (Section 3.2) we discuss theconditions required for the attack and the study of the IP-ID allocation methods supported by top level domains.

3.1 Predicting the Destination IP AddressThe idea of destination IP prediction phase, in Figure 6,is to exploit large DNS responses which result in frag-mentation; fragmented IP traffic has been exploited fordenial of service attacks in the past, e.g., [39], [40], [41].Fragmented DNS responses are common for records

10. The list of TLDs is taken from the list published by IANA [35].

9

within root or top-level domains (or even domains lowerin the DNS hierarchy that support DNSSEC), e.g., mostresponses to records within a gov domain exceed 1500bytes, see Figure 5.

We performed the attack against a 404.gov domain11,whose non-existing domain responses exceed 1500 bytesand thus get fragmented en-route;

This phase, of forcing the resolver to use a specific IP,requires a puppet, i.e., a script confined in a browser,which issues DNS requests via a local caching DNSresolver, at IP 1.2.3.4; the attack is illustrated in Figure 6.

In steps 1 and 2 the puppet coordinates with the

Fig. 5. The number of IP addresses in use by Top Level Domains (TLDs).

spoofer and issues a DNS request for $123.404.gov(where $123 is a random prefix). In steps 3 and 4, thespoofer sends a forged second fragment, for all thepossible name servers (i.e., a total of 2 spoofed frag-ments) except one which the attacker wants the resolverto use for its queries during the poisoning phase; the404.gov domain has three name servers. This ensuresthat only one IP address results in a valid response,and the other two result in malformed DNS packets.The spoofed second fragment is incorrect, and containsa single arbitrary byte (in addition to headers). In step 5,the spoofed second fragment is reconstructed with theauthentic first fragment resulting in a malformed DNSpacket which leaves the fragments reassembly buffer.This malformed DNS response is then discarded by theresolver, and the IP of the name server is marked12 as‘non-responsive’. After a timeout the resolver retrans-mits the request again, and the attacker applies the sametechnique to ruin the responses. After two failed requeststhe Unbound resolver marks the name server’s IP asnon-responsive and blocks it for 15 minutes; As a resultof ‘ruining‘ the responses from all name servers except

11. We focused on 404.gov since it has only three name servers,which simplifies the presentation.

12. In reality the resolver marks the server as ‘non-responsive’ aftertwo unsuccessful respopnses, and this is easily handled by the attackerby sending two spoofed fragments with consecutive IP-ID in each IPheader.

one, the resolver is forced to direct all its queries for404.gov domain to one specific name server.

3.2 Fragments Reassembly ConditionsLet x be the payload in the original IP packet (containinga DNS response) sent by the name server, then after frag-mentation, it is sent as two IP packets y1, y2, such thattheir respective lengths are smaller than x. To overwritethe second fragment, the attacker sends a fake secondfragment y′2 so that it arrives at the defragmentationmodule before the authentic fragments y1, y2 of the DNSresponse13. The fragment reassembly process, applied tothe pair < y1, y

′2 >, either returns a failure or a different

packet x′ 6= x.To ensure that the spoofed second fragment is matched

with the authentic first fragment the attacker must pre-dict certain fields in the IP header.

3.2.1 Matching IP Header FieldsAccording to [42], [40] the fragments of a datagramare associated with each other by four parameters inthe IP header: (1) the transport layer protocol number,(2) the value in their IP-ID field, and (3-4) by thesource/destination IP address pair. Thus both the firstauthentic fragment y1 and the second spoofed fragmenty′2 must have the same destination IP address (of theresolver that sent the query), the same source IP ad-dress (of the responding DNS server), the same protocolfield (UDP) and the same fragment identifier (IP-ID). Inaddition, the spoofed second fragment should have thecorrect offset (as in the authentic second fragment); butthe second spoofed fragment is not required to be of thesame length as the authentic second fragment. Matchingthe MTU, and IP address of the resolver, is easy, as theycan be anticipated by the attacker. It remains to ensurea match between the value of the fragment identifier (IP-ID) field in the fake fragment y′2, and the IP-ID in theauthentic fragment y1 of the original response x, sent bythe name server.

The success probability of the attacker, as well asthe strategy that the attacker applies, depend on thefollowing factors: (1) the version of the IP protocol (IPv4or IPv6), (2) the size of the fragment reassembly buffer atthe receiver (e.g., resolver) and (3) the IP-ID assignmentalgorithm implemented by OS of the DNS server.

IP VERSION. In the most common scenario the com-munication is over IPv4, where the IP-ID field is 16 bits.Support of IPv6 (32 bits) by DNS servers is limited, andwe therefore focus on IPv4.

REASSEMBLY BUFFER SIZE. The host performing thedefragmentation process, i.e., the resolver or firewall,allocates a reassembly cache for fragments per particular<source IP, destination IP, protocol> combination.

13. Note that it is easy to adjust this technique to the (less common)case where fragments are sent in a reverse order: attacker removes theauthentic second fragment y2 from the reassembly buffer by sendingan arbitrary y′1 (whose validation fields match those of the y2), andthe rest is the identical to the description above.

10

SrcIP:162.138.191.11 dstIP:1.2.3.4 IP-ID: 777 Offset:0

SrcIP: 162.138.191.11 dstIP:1.2.3.4 IP-ID: 777 Offset: 1480

2

Spoofer6.6.6.6

Spoofer6.6.6.6

RecursiveDNS resolver

1.2.3.4

RecursiveDNS resolver

1.2.3.4

Puppet1.2.3.6

Puppet1.2.3.6

A?$123.404.GOV1

Attack initiated

3

SrcIP:162.138.191.11 dstIP:1.2.3.4 IP-ID: 777 Offset:1480

Does not have a matchthus can not be reassembled.

Discarded after 30 seconds

Reassembled with attacker's fragment

(sent in step 3).

5

Name Serverfalcon.sec.GOV162.138.191.11

Name Serverfalcon.sec.GOV162.138.191.11

Name Serverpuffin.sec.GOV162.138.191.23

Name Serverpuffin.sec.GOV162.138.191.23

SrcIP:162.138.191.23 dstIP:1.2.3.4 IP-ID: 888 Offset:0

SrcIP: 162.138.191.23 dstIP:1.2.3.4 IP-ID: 888 Offset: 1480

4

SrcIP:162.138.191.23 dstIP:1.2.3.4 IP-ID: 888 Offset:1480

7

A?$123.404.GOV

A?$123.404.GOV

Name Servercrow.sec.GOV162.138.183.11

Name Servercrow.sec.GOV162.138.183.11

6

Malformed DNS response discarded by

resolver. Server marked asnon-responsive. Query resent

to next server.

Reassembled with attacker's fragment

(sent in step 4).

A?$123.404.GOV8

9

SrcIP:162.138.183.11 dstIP:1.2.3.4 IP-ID: 555 Offset:0

SrcIP:162.138.183.11 dstIP:1.2.3.4 IP-ID: 555 Offset:1480

Malformed DNS response discarded by resolver. Server

marked as non-responsive . Query resent to next server.

Response correct. During next15 minutes queries are

sent to that server.

Does not have a matchthus can not be reassembled.

Discarded after 30 seconds

Does not have a matchthus can not be reassembled.

Discarded after 30 seconds

Fig. 6. The destination IP address prediction attacks: spoofing attacker crafts a forged second fragment that gets reassembled with the authentic first fragment andresults in a malformed packet, which is discarded by the resolver.

In linux, the reassembly cache is limited to n frag-ments per source, destination and protocol tuple via theipfrag max dist parameter, and is 64 by default; see [43].Legacy kernel versions of Linux OS allow buffering ofup to few thousands of fragments.

IP-ID ASSIGNMENT METHODS. The strategy that theattacker employs to predict the IP-ID value depends onthe IP-ID assignment method.

We carried out a study14 of the IP-ID allocation meth-ods implemented by the name servers of the top leveldomains (TLDs), i.e., a total of 271 TLDs, served by1139 distinct IP addresses (407 IPs serve more than onedomain). Figure 7 summarises our findings15 related tothe IP-ID allocation algorithms supported by servers au-thoritative for TLDs: 0.51% servers could not be reached,8.99% of the name servers assign a constant zero IP-IDvalue16 in the IP header of DNS responses; 56.63% ofthe servers assign per-destination incrementing IP-ID;13.85% of the servers assign globally incrementing IP-ID, and 0.26% use some other allocation (under ‘other’allocation we include (a seemingly) random IP-ID as-signment); 19.74% support a ‘mixed’ IP-ID allocation.The ‘mixed‘ allocation is an indication of name serversthat support load balancing, [44]. When using DNSserver-side load balancing, several physical machines arelocated behind the same IP address, and each physicalmachine may be implementing a different IP-ID alloca-tion mechanism at the IP layer. We extend more on this

14. During this study we sent 50 requests to each name server witha 500 milliseconds delay between each request; we added the delaysince some name servers would return server failure response whenmore than 10 packets were sent without any delay, and we found he500 millisecond delay to be sufficient to receive the required responses.

15. It is important to emphasise that our study was conductedfrom within the network of our university, and findings may varywhen performed from a different network, e.g., due to anycast routingsupported by DNS servers.

16. The zero IP-ID is assigned to DNS responses that do not getfragmented.

in Sections 3.2.4 and 3.2.3.MATCHING THE IP-ID. If there is no restriction on

the size of the recipient’s fragment reassembly cache,then the attacker can simply send fragments covering allthe IP-ID range and one will always match. Assumingcommunication is over IPv4, i.e., the IP-ID field is 16 bits,the distribution of all IP-ID values is of size 216 = 65536;namely, in the worst case the attacker has to craft 65536fragments, and to trigger a single query at the resolver,to almost certainly match the IP-ID in the DNS response.We perform all our attacks in a restricted setting wherethe caching DNS resolver is running on a Linux OS, andn = 64 fragments, i.e., the ipfrag max dist is initiatedwith the default value of 64; a better success probabilitycan be achieved if such a restriction is not imposed.

We next report on our findings of IP-ID allocationmethods by the name servers of TLDs. We discuss thefour cases of IP-ID assignment: random, per-destination,global and mixed, suggest strategies which the attackerscan employ to predict the IP-ID values assigned by eachof the methods and analyse the efficiency and the successprobability.

Zero Per-destination Global Other Non-responsive Mixed0

100

200

300

400

500

600

700

800

900

1000

Fig. 7. The IP-ID allocation methods among the DNS servers authoritative for(271) Top Level Domains (TLDs).

11

In Figure 8 we illustrate our results of IP-ID hittingrate for two domains: 404.gov implementing a per-destination IP-ID allocation and ssa.gov implementinga global IP-ID allocation (with average query rate of 100per second). During the evaluation we sent a query to(each) name server every 5 milliseconds, and repeatedthe attacks 20 times.

Fig. 8. IP-ID hitting success rate for two domains each implementing a differentIP-ID allocation method.

3.2.2 Unpredictable IP-ID AllocationAssuming that the attacker has no prior knowledge onthe process according to which the IP-ID is incremented,and assuming that the IP-ID values in the authenticpacket and in the spoofed fragment are selected indepen-dently, it suffices for the attacker to send 64 spoofed sec-ond fragments (assuming a restriction on the fragmentsreassembly buffer exists), to ensure success probabilityof roughly 1/1024 of replacing the second fragment of apacket in a single attempt. After a 1024 attempts, i.e.,repeated attacks, on average, the attacker can hit thecorrect IP-ID with a probability that is close to 1.

Under this category we classify four name servers,among the servers of TLDs, that support (what seemsto be) an unpredictable IP-ID allocation.

However, most systems select the IP-ID sequentially.Of these, many use a single counter for all destinations(globally-sequential), as in Windows and by default inFreeBSD. Other systems, e.g., Linux, use per-destinationIP-ID counters, where the first IP-ID to some desti-nation is selected at random, and subsequent packetsare assigned sequentially incrementing IP-ID values. Inboth of these cases, as we next show, the attacker canefficiently predict the IP-ID, achieving a significantlyhigher probability of success (compared to 1/1024).

3.2.3 Per-Destination Incrementing IP-ID AllocationIn a per-destination IP-ID allocation the first IP-ID tosome destination is selected at random and subsequentpackets are allocated sequentially increasing IP-ID val-ues. The DNS server maintains the counter mappingto the destination IP for some period of time, typicallyseveral minutes.

In constrast to random IP-ID allocation, sequentiallyincrementing IP-ID assignment allows to implement a

much more efficient attack. The idea is to narrow downthe search space thus reducing the number of queriesthat the resolver is required to issue. We next describe thealgorithm of the attacker. Assuming that the fragment re-assembly buffer at the resolver is limited to n fragments,and n = 64 for the same source/destination and protocoltuple, the attacker should plant n − 2 spoofed secondfragments in the recipient’s buffer, and should leavespace for two authentic fragmens; this is required sinceotheriwse attacker’s least recently arrived fragments willbe evicted from the cache, when two authentic fragmentsenter the reassembly cache. Each ith fragment, out ofn− 2 sent by the attacker, contains{

i · 2|IP−ID|

(n− 2)

}(n−2)−1

i=0={i · 2

16

62

}61

i=0= {i · 1057}61i=0

(where |IP−ID| is the size of the distribution containingall possible IP-ID values). The puppet then issues 1057DNS requests17 for records that result in fragmentedresponses. With probability 1, one of the first fragments,sent in response to DNS requests, will be reconstructedwith the second spoofed fragment of the attacker, thatwaits in the reassembly buffer; this is since the IP-IDvalues in the DNS responses sent to the resolver overlapthe IP-ID values in one of the 1057 traps set by theattacker.

3.2.4 Globally Incrementing IP-ID AllocationA globally-incrementing IP-ID appears to be widelyused, and in this case the attacker can simply learn thecurrent value, and the propagation rate18, by queryingthe name server directly. The method of exploiting theIP-ID advancement to measure the transmission rate ofsystems is not new, and was used in [46].

3.2.5 Mixed Incrementing IP-ID AllocationAs we mentioned earlier, some of the servers, authori-tative for TLDs, use load balancing (305 out of 1139 tobe precise) and more than one physical machine may beallocated the same IP address. For instance, the nameserver a0.pro.afilias-nst.info (IP 199.182.0.1) authoritativefor pro TLD, appears to be using more than 4 physicalmachines, as we were able to identify four sequentiallyincrementing IP-ID allocations (i.e., four ranges whichare incremented by units of 1), and one random. Figure 9summarises the distribution of servers (authoritative forTLDs) which support load balancing, and each physicalmachine uses a different counter to the destination IP.Note that the number of instances of machines behinda load balancer is dynamic, and some machines may gooffline and new ones may emerge; furthermore, it maybe the case that our requests did not reach some of themachine instances due to the way requests are rerouted

17. To cincumvent the caching of the resolver the puppet shouldissue requests for records that result in non-existing domain responses(RCODE=3) or NODATA responses.

18. The query rate to name servers is known to be stable, [45].

12

to different machines. Therefore, the study in Figure 9is meant to provide a general idea of the load balancingimplemented by name servers.

1 2 3 4 5 6 7 8 90

5

10

15

20

25

30

35

40

2 3 4 5 6 7 80

20

40

60

80

100

120

140

Fig. 9. The distribution of the number of physical machines behind a single IPaddress; this holds for 305 name servers authoritative for TLDs, that support loadbalancing. The x corresponds to the number of name servers and the y to thenumber of counters detected behind an IP address.

We next show the impact of load balancing on thesuccess probability of the attacker to hit the correct IP-ID.Let k be the number of different physical servers, suchthat each uses a different counter to the destination IP. Inthis case, the attacker can follow either of the followingtwo strategies: (1) divide the fragment reassembly bufferinto k logical buffers each of size (n − 2)/k fragments(where n is the actual size of the fragment reassemblybuffer), or (2) issue additional O(k) queries, in the worstcase, in order to ensure that the load balancer relaysthe DNS request to the machine with the required IP-ID counter value; typically the name servers respond ina round-robin sequence, so on average, after k queries,the required name server will return the response.

In our attacks we focused on name servers that main-tained a single counter to some destination. Specifically,by applying the technique in Section 3, we forced, i.e.,‘pinned’, the resolver to query the name servers that didnot implement load balancing.

3.3 Experimental Evaluation

The Wireshark capture, in Figure 10, that was run onthe resolver, demonstrates the experimental evalutation,i.e., the DNS packets entering/leaving the network cardof the resolver. During the course of the experimentthe puppet issued 6000 queries19 to the resolver. Thespoofer initiates the attack by sending three spoofedfragments to each IP address except 162.138.183.11. Forsimplicity, the capture presents only the packets ex-changed between the resolver and the name server of404.gov at 162.138.191.23 (by adjusting a correspond-ing filter in wireshark); the complete capture containsqueries/responses from other name servers too. Packets

19. Note that our goal was to test the behaviour of the resolver, andto check the frequency of the queries to non-responsive servers; in realattack, once the IP-ID is known, it suffices to issue two queries to markthe server as non-responsive.

numbered 18-20 are the forged fragments sent by thespoofer, with sequentially incrementing IP-IDs. Thenzombie triggers a DNS request (packet 29). The responsefrom the name server contains two fragments, packets33 and 34. The first fragment is reassembled with aspoofed fragment (packet 18), resulting in a malformedpacket which is discarded by the resolver. The secondfragment is discarded after a timeout. In packet 48 theresolver requests a public verification key of the 404.govzone. The response contains three fragments 49-51; thefirst fragment is reconstructed with the spoofed fragmentin packet 20, which also results in a malformed DNSresponse and is discarded. Note that this request, inpacket 48, was sent at 19:28. Based on our tests it canbe seen that when Unbound encounters a timeout twicefor the same destination IP, it stops sending furtherpackets to that destination for 15 minutes. Indeed, thenext packet that is sent to that IP is packet number 6848,at time 19:43. The same scenario was observed with IP162.138.191.11. The queries between 19:28 and 19:43 weresent only to 162.138.183.11, avoiding 162.138.191.11 and162.183.191.23. Note that even if some of the responses(between packets 33 and 49) were valid and acceptedby resolver, e.g., if they were not fragmented, it did notmake a difference, and two timed-out responses in a15 minute interval were sufficient for Unbound to stopquerying those IP addresses.

3.4 Improved IP Address RandomisationThe attack we presented holds against a specific DNSresolver software, however we caution that variations ofour ideas may apply to other server selection algorithms,and we believe that in the long term best answer to ourderandomisation attacks is to deploy DNSSEC.

In the meanwhile we suggest (1) increasing the num-ber of IP addresses, both of the name server and ofthe DNS resolver, e.g., an approach recently proposedby [47] is to superficially increase the number of IPaddresses of the resolver for its DNS requests by reusingthe available IP addresses allocated to the network.Derandomising the IP addresses of the resolver seems tobe a challenging task for the attacker; and (2) improvingname server selection mechanisms, in particular, it seemsthat further investigation of server selection mechanismis required to adjust the recommendations in [38], [37]to enhance the robustness of resolvers against such (orsimilar) attacks.

4 DNS QUERY (DE)RANDOMISATION

In this section we describe two prominent defenses,‘case toggling’ and random prefix, which are known toadd significant extra entropy to DNS requests and showsimple ways to circumvent them.

‘CASE TOGGLING’. Dagon et al. [14] present 0x20encoding for prevention of DNS poisoning. The techniqueis to randomly toggle the case of letters of which thedomain name consists, and validate them in response.

13

Fig. 10. The wireshark capture of the attack, presenting only the packets exchanged between the name server 162.183.191.23 and the resolver. As can be observed,after two malformed responses the resolver refrains from sending further queries to that name server for 15 minutes. Fragmented packets are coloured in white, DNSrequests in black, and reassembled DNS fragments in blue.

However, we believe that the distribution of domainqueries with sufficient 0x20 characters, as reported byDagon et al., is not indicative of the number of char-acters in queries that attackers will try to poison, andhence the impact of 0x20 encoding can be easily cir-cumvented. In fact, in Kaminsky-style attacks, the queryis intentionally for a non-existing domain name chosenby the attacker, e.g., .com and .uk; indeed the attack-ers prefer to poison a response to com rather than towww.google.com. Also note that poisoning com allowsthe attacker a control over all subdomains of com (in-cluding www.google.com).

RANDOM PREFIX. Prepending a random prefix to aDNS query20 can ensure that a sufficiently large DNSquery is sent, allowing to apply the 0x20 encoding onmore letters and also making it more difficult for theattacker to guess the query (and the case of each letter).

The DNS query is composed of subdomains, at most63 bytes each, separated by dots, s.t., the total numberof characters cannot exceed 255 bytes. So, prepending arandom string $1 to query abc.tld, results in $1.abc.tldand increases the query by the size of $1.

A naive implementation of this protection mechanismcan be foiled by the attacker. The attacker that wishes topoison an entry for some top level domain, e.g., com, canissue a maximal size DNS query, i.e., 255 bytes, consist-ing of numbers, that will not allow prepending any morecharacters: 1-36.1-36.1-36.1-33.com (the ‘1-36’ denotesa string containing all numbers between 1 and 36). Asa result, the attacker circumvents the 0x20 protection(which does not apply to numbers) and further avoidsthe addition of a random prefix to DNS request (sincethe query is already of maximal size). A slight variationof this attack, see [48], also foils protection offered byWSEC DNS [17].

The size of queries to top level domains should berestricted, to prevent circumventing the query randomi-sation defenses by attackers.

5 CONCLUSIONS

Currently, the popular protection used by most DNS re-solvers against poisoning relies on echoing the validationfields in DNS response. Such mechanisms are clearlyinsufficient to prevent poisoning by MitM attackers. A

20. A random prefix is a variation of the defense proposed in [17].

secure standard alternative exists: DNSSEC, which usescryptography to achieve verifiable security. However, thedeployment of DNSSEC is quite slow. One reason aresignificant interoperability and performance concerns;another reason may be the existence of several ‘patches’,adding more ‘unpredictable’ identifiers. Such ‘patches’are trivial to deploy and involve no or negligible over-head, hence, administrators may prefer to deploy theminstead of deploying DNSSEC.

We study the major proposed ‘patches’, and findvulnerabilities in all of them. Our ‘trap’ and ‘predict’attacks show that source ports may be disclosed orimpacted by network devices such as NAT gateways.We show that the attacker can also nullify IP addressrandomisation of standard-conforming resolvers such asUnbound, forcing the resolver to query a specific nameserver. We also describe simple techniques to circumventthe DNS query randomisation via a random prefix and0x20 encoding. We validated our attacks against popularNAT devices and standard DNS resolver software. Ourderandomisation attacks are deployed ‘sequentially’ inphases, removing the randomisation of each identifierindependently, and eventually strip the DNS request ofthe entropy offered by those ‘unpredictability’ fields, ex-posing the caching DNS resolvers to efficient poisoningattacks by off-path spoofing adversaries.

We show simple and effective countermeasures to ourattacks. However, while using such ‘patched patches’is tempting and easy, we believe that our work showsthe importance of basing security on solid, strong foun-dations, as provided by DNSSEC, i.e., cryptographicprotocols designed and analysed to ensure security evenagainst MitM attackers.

ACKNOWLEDGEMENTS

We are grateful to Wenke Lee and Dieter Gollmann fortheir extensive and elaborate feedback on the earlierversion of this work. We also thank the anonymousreferees for their comments on the conference version.This research was supported by grant 1354/11 from theIsraeli Science Foundation (ISF).

REFERENCES[1] S. Son and V. Shmatikov, “The hitchhikers guide to dns cache

poisoning,” Security and Privacy in Communication Networks, pp.466–483, 2010.

14

[2] A. Hubert and R. van Mook, “Measures for Making DNSMore Resilient against Forged Answers,” RFC 5452 (ProposedStandard), Internet Engineering Task Force, Jan. 2009. [Online].Available: http://www.ietf.org/rfc/rfc5452.txt

[3] A. Klein, “BIND 9 DNS cache poisoning,” Trusteer, Ltd., 3 Hayet-zira Street, Ramat Gan 52521, Israel, Report, 2007.

[4] P. Vixie, “DNS and BIND security issues,” in Proceedings of the5th Symposium on UNIX Security. Berkeley, CA, USA: USENIXAssociation, jun 1995, pp. 209–216.

[5] R. Arends, R. Austein, M. Larson, D. Massey, and S. Rose, “DNSSecurity Introduction and Requirements,” RFC 4033 (ProposedStandard), Internet Engineering Task Force, Mar. 2005, updatedby RFC 6014. [Online]. Available: http://www.ietf.org/rfc/rfc4033.txt

[6] ——, “Resource Records for the DNS Security Extensions,”RFC 4034 (Proposed Standard), Internet Engineering Task Force,Mar. 2005, updated by RFCs 4470, 6014. [Online]. Available:http://www.ietf.org/rfc/rfc4034.txt

[7] ——, “Protocol Modifications for the DNS Security Extensions,”RFC 4035 (Proposed Standard), Internet Engineering Task Force,Mar. 2005, updated by RFCs 4470, 6014. [Online]. Available:http://www.ietf.org/rfc/rfc4035.txt

[8] D. Eastlake 3rd and C. Kaufman, “Domain Name System SecurityExtensions,” RFC 2065 (Proposed Standard), Internet EngineeringTask Force, Jan. 1997, obsoleted by RFC 2535. [Online]. Available:http://www.ietf.org/rfc/rfc2065.txt

[9] L. Eggert, “DNSSEC deployment trends,” At:http:\\http://eggert.org/meter/dnssec.

[10] O. Gudmundsson and S. D. Crocker, “Observing DNSSEC Vali-dation in the Wild,” in SATIN, March 2011.

[11] A. Herzberg and H. Shulman, “Security of Patched DNS,technical report 12-04,” http://u.cs.biu.ac.il/∼herzbea/security/12-04-derandomisation.pdf, April 2012.

[12] D. Kaminsky, “It’s the End of the Cache As We Know It,”Presentation at Blackhat Briefings, 2008.

[13] CERT, “Multiple DNS implementations vulnerable to cachepoisoning,” CERT, Tech. Rep. Vulnerability Note 800113, 2008.[Online]. Available: http://www.kb.cert.org/vuls/id/800113

[14] D. Dagon, M. Antonakakis, P. Vixie, T. Jinmei, and W. Lee,“Increased DNS forgery resistance through 0x20-bit encoding:security via leet queries,” in ACM Conference on Computerand Communications Security, P. Ning, P. F. Syverson, andS. Jha, Eds. ACM, 2008, pp. 211–222. [Online]. Available:http://doi.acm.org/10.1145/1455770.1455798

[15] J. Bau and J. C. Mitchell, “A security evaluation of DNSSECwith NSEC3,” in Network and Distributed Systems Security (NDSS)Symposium. The Internet Society, 2010. [Online]. Available:http://www.isoc.org/isoc/conferences/ndss/10/

[16] D. J. Bernstein, “DNS Forgery,” Internet publication athttp://cr.yp.to/djbdns/forgery.html, November 2002.

[17] R. Perdisci, M. Antonakakis, X. Luo, and W. Lee, “WSEC DNS:Protecting recursive DNS resolvers from poisoning attacks,” inDSN. IEEE, 2009, pp. 3–12.

[18] H. Sun, W. Chang, S. Chang, and Y. Lin, “DepenDNS: Dependablemechanism against DNS cache poisoning,” Cryptology and NetworkSecurity, pp. 174–188, 2009.

[19] A. Herzberg and H. Shulman, “Unilateral antidotes to DNS cachepoisoning,” in SecureComm, 2011.

[20] S. Tzur-David, K. Lashchiver, D. Dolev, and T. Anker, “Delay fastpackets (dfp): Prevention of dns cache poisoning,” in SecureComm,2011.

[21] N. AlFardan and K. Paterson, “An analysis of DepenDNS,”Information Security, pp. 31–38, 2011.

[22] D. Dagon, M. Antonakakis, K. Day, X. Luo, C. P. Lee, and W. Lee,“Recursive DNS architectures and vulnerability implications,”in Sixteenth Network and Distributed Systems Security (NDSS)Symposium. The Internet Society, 2009. [Online]. Available:http://www.isoc.org/isoc/conferences/ndss/09/pdf/15.pdf

[23] T. Cross, “(updated) DNS cache poisoning and networkaddress translation,” Post at IBM’s Frequency X blog(http://blogs.iss.net/archive/dnsnat.html), July 2008.

[24] Wikipedia, “Network address translation,” September 2010.[Online]. Available: http://en.wikipedia.org/wiki/Network\address\ translation

[25] B. Ford, P. Srisuresh, and D. Kegel, “Peer-to-peer communicationacross network address translators,” in USENIX AnnualTechnical Conference, General Track. USENIX, 2005, pp. 179–192.

[Online]. Available: http://www.usenix.org/events/usenix05/tech/general/ford.html

[26] J. Rosenberg, J. Weinberger, C. Huitema, and R. Mahy, “STUN- Simple Traversal of User Datagram Protocol (UDP) ThroughNetwork Address Translators (NATs),” RFC 3489 (ProposedStandard), Internet Engineering Task Force, Mar. 2003, obsoletedby RFC 5389. [Online]. Available: http://www.ietf.org/rfc/rfc3489.txt

[27] G. Maier, F. Schneider, and A. Feldmann, “Nat usage in resi-dential broadband networks,” in Passive and Active Measurement.Springer, 2011, pp. 32–41.

[28] P. Dan Tynan, “Your PC may be a haven for spies,” 2004.[Online]. Available: http://www.pcworld.com/article/116526/your\ pc\ may\ be\ a\ haven\ forspies.html

[29] Arbor Networks, “Worldwide infrastructure security report,”http://dns.measurement-factory.com/surveys/201010/, 2010.

[30] DNS-OARC, “Domain Name System Operations Analysisand Research Center,” https://www.dns-oarc.net/oarc/services/porttest, 2008.

[31] A. Herzberg and H. Shulman, “Security of Patched DNS,” inESORICS, ser. Lecture Notes in Computer Science. Springer,2012.

[32] F. Audet and C. Jennings, “Network Address Translation (NAT)Behavioral Requirements for Unicast UDP,” RFC 4787 (BestCurrent Practice), Internet Engineering Task Force, Jan. 2007.[Online]. Available: http://www.ietf.org/rfc/rfc4787.txt

[33] Juniper Networks, “Carrier Grade NAT Implementation Guide,”2011. [Online]. Available: http://www.juniper.net/us/en/local/pdf/implementation-guides/8010076-en.pdf

[34] S. Bradner, “RFC 3978 Update to Recognize the IETF Trust,”RFC 4748 (Best Current Practice), Internet Engineering TaskForce, Oct. 2006, obsoleted by RFC 5378. [Online]. Available:http://www.ietf.org/rfc/rfc4748.txt

[35] Internet Corporation for Assigned Names and Numbers, “TopLevel Domains List,” www.iana.org, April 2012.

[36] P. Mockapetris, “Domain names - concepts and facilities,” RFC1034 (Standard), Internet Engineering Task Force, Nov. 1987,updated by RFCs 1101, 1183, 1348, 1876, 1982, 2065, 2181, 2308,2535, 4033, 4034, 4035, 4343, 4035, 4592, 5936. [Online]. Available:http://www.ietf.org/rfc/rfc1034.txt

[37] M. Larson and P. Barber, “Observed DNS ResolutionMisbehavior,” RFC 4697 (Best Current Practice), InternetEngineering Task Force, Oct. 2006. [Online]. Available:http://www.ietf.org/rfc/rfc4697.txt

[38] Y. Yu, D. Wessels, M. Larson, and L. Zhang, “Authority serverselection of dns caching resolvers,” ACM SIGCOMM ComputerCommunication Reviews, April 2012.

[39] C. Kaufman, R. Perlman, and B. Sommerfeld, “DoS Protection forUDP-Based Protocols,” in Proceedings of the 10th ACM Conferenceon Computer and Communication Security (CCS-03), V. Atluri andP. Liu, Eds. New York: ACM Press, oct 2003.

[40] J. Heffner, M. Mathis, and B. Chandler, “IPv4 ReassemblyErrors at High Data Rates,” RFC 4963 (Informational), InternetEngineering Task Force, Jul. 2007. [Online]. Available: http://www.ietf.org/rfc/rfc4963.txt

[41] Y. Gilad and A. Herzberg, “Fragmentation ConsideredVulnerable: Blindly Intercepting and Discarding Fragments,” inProc. USENIX Workshop on Offensive Technologies, Aug 2011.[Online]. Available: http://www.usenix.org/events/woot11/tech/final/files/Gilad.pdf

[42] J. Postel, “Internet Protocol,” RFC 791 (Standard), InternetEngineering Task Force, Sep. 1981, updated by RFC 1349.[Online]. Available: http://www.ietf.org/rfc/rfc791.txt

[43] Kernel.org, “Linux Kernel Documentation,”http://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt, 2011.

[44] T. Brisco, “DNS Support for Load Balancing,” RFC 1794(Informational), Internet Engineering Task Force, Apr. 1995.[Online]. Available: http://www.ietf.org/rfc/rfc1794.txt

[45] D. Wessels and M. Fomenkov, “Wow, thatsa lot of packets,” inProceedings of Passive and Active Measurement Workshop (PAM),2003.

[46] S. Sanfilippo, “About the IP Header ID,” http://www.kyuzz.org/antirez/papers/ipid.html, Dec 1998.

[47] A. Herzberg and H. Shulman, “Unilateral Antidotes to DNSPoisoning,” in Security and Privacy in Communication Networks -7th International ICST Conference, SecureComm 2011, London, UK,

15

September 7-9, 2011, Proceedings, ser. Lecture Notes of the Insti-tute for Computer Sciences, Social Informatics and Telecomm.(LNICST), Springer, Ed. Springer, 2011.

[48] ——, “Antidotes for DNS Poisoning by Off-Path Adversaries,” inARES, 2012.