Free dns lookup software for linux

slookup is a simple program to do parallelized DNS lookups in a convenient way (useful for log parsing scripts and one-liners).
slookup project reads names (A/MX/NS lookups) or addresses (in dotted-quad format for PTR) on stdin and writes the results on stdout. One record per line. It can run up to 128 parallel DNS lookup processes (easily overloading a slow DNS server) which makes for Really Fast lookups for a large number of records.
Beware, output is written in the order the DNS replies are received, which is usually different from the input order if parallel lookups are done.
It has been tested on the following platforms:
Solaris 2.6 / UltraSparc / gcc 2.7.2.3
RedHat Linux 7.0 / 2.2.17 / glibc-2.1.94 / gcc 2.96
Debian sarge / 2.6.8.1 / glibc-2.3.2 / gcc 3.3.5
Debian etch / 2.6.15 / glibc-2.3.6 / gcc 4.0.3
FreeBSD 5.3-RELEASE / gcc 3.4.2
FreeBSD 6.0-RELEASE / gcc 3.4.4
Enhancements:
- Support for looking up NS records was added.

DNSA and DNSA-NG are swiss knife tools for Linux designed to test several DNS security issues.

The most important one is a full wifi support using 2 cards:

- The first in monitor mode which capture 802.11 traffic
- The second associated to the AP and injecting DNS forged packets

Host-ap and madwifi drivers are already supported by DNSA-NG.

DNSA was initially thought because of a lack in DNS auditing tools. It uses libnet and libpcap :

"Libnet is a high-level API (toolkit) allowing the application programmer to construct and inject network packets. It provides a portable and simplified interface for low-level network packet shaping, handling and injection. Libnet hides much of the tedium of packet creation from the application programmer such as multiplexing, buffer management, arcane packet header information, byte-ordering, OS-dependent issues, and much more.

Libnet features portable packet creation interfaces at the IP layer and link layer, as well as a host of supplementary and complementary functionality. Using libnet, quick and simple packet assembly applications can be whipped up with little effort. With a bit more time, more complex programs can be written (Traceroute and ping were easily rewritten using libnet and libpcap).

Usage :

Usage: ./dnsa [ARGS]
DNS Swiss knife tool

-1 DNS ID spoofing [ Required : -S ]
-D [www.domain.org] Hostname query to fool. Dont use it if every DNS request sniffed has to be spoofed
-S [IP] IP address to send for dns queries
-s [IP] IP address of the host to fool
-i [interface] IP address to send for dns queries
-2 DNS IDs Sniffing [ Required : -s ]
-s [IP] IP address of the server which makes queries
-w [file] Output file for DNS IDs
-3 DNS cache poisoning [ Required : -S AND -b AND -a ]
-a [host.domain.org] Hostname to send in the additional record
-b [IP] IP to send in the additional record
-D [www.domain.org] Hostname for query. Use it if you want to fool just on
-S [IP] IP address to send for DNS queries (the normal one)
-s [IP] IP address of the server to fool
-i [interface] IP address to send for DNS queries

dnsutl package is a collection tools to make administering DNS easier. These include:
dns-rev
Take the forward DNS mapping and generate the reverse mapping. This is useful for producing a self-consistent DNS configuration.
dns-ethers
By using a bogus record type, you can keep the MAC address with the IP address, and generate the /etc/ethers file.
dns-hosts
Take the forward DNS mapping and generate the /etc/hosts file.
dns-bootp
Using the MAC and IP information, you can generate the /etc/bootptab file.
dns-ng
Take the forward DNS mapping and generate the /etc/netgroup file.
dns- bootparams
Using the MAC and IP information, you can generate the Sun /etc/bootparams file.
dns-boot- check
Check your named(8) configuration for self- consistency.
dns-hosts-import
Turn your /etc/hosts file into a DNS forward map, as a first step to configuring your DNS server.
dns-dhcp
Using the MAC and IP information, you can generate the /etc/dhcp.conf file.
All of these programs are both faster than shell scripts, and more robust when faced with all the peculiar semantics of DNS resource files. They even understand the $include directive.
dnsutl runs on almost any flavor of UNIX. The source distribution is self configuring using a GNU Autoconf generated configure script.
Enhancements:
- A bug has been fixed in the SRRF parser, so it more closely follows RFC 1035.
- A bug has been fixed in the name server (ns) record validation.

Net::DNS::ToolKit are tools for working with DNS packets.

SYNOPSIS

use Net::DNS::ToolKit qw(

get1char
get16
get32
put1char
put16
put32
getIPv4
putIPv4
putIPv6
getIPv6
getstring
putstring
dn_comp
dn_expand
parse_char
gethead
newhead
getflags
get_qdcount
get_ancount
get_nscount
get_arcount
put_qdcount
put_ancount
put_nscount
put_arcount
inet_aton
inet_ntoa
ipv6_aton
ipv6_n2x
ipv6_n2d
sec2time
ttlAlpha2Num
collapse
strip
get_ns
gettimeofday
);

$char = get1char($buffer,$offset);
($int, $newoff) = get16($buffer,$offset);
($long, $newoff) = get32($buffer,$offset);
$newoff = put1char($buffer,$offset,$u_char);
$newoff = put16($buffer,$offset,$int);
$newoff = put32($buffer,$offset,$long);
$flags = getflags($buffer);
$int = get_qdcount($buffer);
$int = get_ancount($buffer);
$int = get_nscount($buffer);
$int = get_arcount($buffer);
$newoff = put_qdcount($buffer,$int);
$newoff = put_ancount($buffer,$int);
$newoff = put_nscount($buffer,$int);
$newoff = put_arcount($buffer,$int);
($netaddr,$newoff)=getIPv4($buffer,$offset);
$newoff = putIPv4($buffer,$offset,$netaddr);
($ipv6addr,$newoff)=getIPv6($buffer,$offset);
$newoff = putIPv6($buffer,$offset,$ipv6addr);
($offset,
$id,$qr,$opcode,$aa,$tc,$rd,$ra,$mbz,$ad,$cd,$rcode,
$qdcount,$ancount,$nscount,$arcount)
= gethead($buffer);
$newoff = newhead($buffer,$id,$flags,
$qdcount,$ancount,$nscount,$arcount);
($b,$h,$d,$a)=parse_char($char);
($newoff,$name) = dn_expand($buffer,$offset);
($newoff,@dnptrs)=dn_comp($buffer,$offset,$name,@dnptrs);
$dotquad = inet_ntoa($netaddr);
$netaddr = inet_aton($dotquad);
$ipv6addr = ipv6_aton($ipv6_text);
$hex_text = ipv6_n2x($ipv6addr);
$dec_text = ipv6_n2d($ipv6addr);
$timetxt = sec2time($seconds);
$seconds = ttlAlpha2Num($timetext);
$shorthost = collapse($zonename,$longhost);
$tag = strip($P_tag);
@nameservers = get_ns();
($secs,$usecs) = gettimeofday();

Routines to pick apart, examine and put together DNS packets. They can be used for diagnostic purposes or as building blocks for DNS applications such as DNS servers and clients or to allow user applications to interact directly with remote DNS servers.

popdns is a small daemon that aims at simplifying the use of DHCP-configured machines by allowing them to dynamically update their DNS entry using (nearly) any POP3-capable e-mail tool.

After having configured a new e-mail source (with the POP3 protocol), users are authenticated using their system password and popdns automatically updates the specified (or implied) DNS entry with the IP address of the connecting machine.

popdns makes all DNS modifications with plugins. The plugins are external programs (scripts or compiled programs) simply launched with the following arguments:

plugin ipaddress name [ name ... ]

DNS::ZoneParse is a Perl module to parse and manipulate DNS Zone Files.

SYNOPSIS

use DNS::ZoneParse;

my $zonefile = DNS::ZoneParse->new("/path/to/dns/zonefile.db", $origin);

# Get a reference to the MX records
my $mx = $zonefile->mx;

# Change the first mailserver on the list
$mx->[0] = { host => mail.localhost.com,
priority => 10,
name => @ };

# update the serial number
$zonefile->new_serial();

# write the new zone file to disk
open NEWZONE, ">/path/to/dns/zonefile.db" or die "error";
print NEWZONE $zonefile->output();
close NEWZONE;

INSTALLATION

perl Makefile.PL
make
make test
make install

Geo::Lookup::ByTime is a Perl module to lookup location by time.

SYNOPSIS

use Geo::Lookup::ByTime;

$lookup = Geo::Lookup::ByTime->new( @points );
my $pt = $lookup->nearest( $tm );

Given a set of timestamped locations guess the location at a particular time. This is a useful operation for, e.g., adding location information to pictures based on their timestamp and a GPS trace that covers the same time period.

INTERFACE

new( [ points ] )

Create a new object optionally supplying a list of points. The points may be supplied as an array or as a reference to an array. Each point may be a reference to a hash containing at least the keys lat, lon and time or a reference to an object that supports accessor methods called latitude, longitude and time.

If a coderef is supplied it is assumed to be an iterator that may be called repeatedly to yield a set of points.

add_points( [ points ] )

Add points. The specification for what constitutes a point is the same as for new.

nearest( $time [ , $max_dist ] )

Return a hash indicating the estimated position at the specified time. The returned hash has lat, lon and time keys like this:

my $best = {
lat => 54.29344,
lon => -2.02393,
time => $time
};

Returns undef if the position cant be computed. By default a position will be calculated for any point that lies within the range of time covered by the reference points. Optionally $max_dist may be specified in which case undef will be returned if the closest real point is more than that many metres away from the computed point.
If the requested time coincides exactly with the timestamp of one of the points the returned point will be at the same location as the matching point. If the time falls between the timestamps of two points the returned point will be linearly interpolated from those two points.

In an array context returns a list containing the synthetic point at the specified time (i.e. the value that would be returned in scalar context), the closest real point and the distance between the two in metres

my ($best, $nearest, $dist) = $lookup->nearest( $tm );

get_points()

Return a reference to an array containing all the points in ascending time order.

time_range()

Return as a two element list the time range from earliest to latest of the points in the index. Returns undef if the index is empty.

hav_distance($pt, ...)

Exportable function. Computes the Haversine distance in metres along the line described by the points passed in. Points must be references to hashes with keys lat and lon.