Free dns test software for linux

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

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 name parser is a Java utility library for parsing dns names, ip and hw addresses.

Synopsis

import su.netdb.parser.*;

Parser parser = new Parser();

Hashtable result = parser.parse(str);

System.out.println("string: "+result.get("string"));
System.out.println("hw: "+result.get("hw"));
System.out.println("name: "+result.get("name"));
System.out.println("domain: "+result.get("domain"));
System.out.println("ip_low: "+result.get("ip_low"));
System.out.println("ip_high: "+result.get("ip_high"));

"DNS name parser" is an utility library created to be used in a search application. Given a single input field its function is to differentiate between several types of possible input strings. Namely if it a dns name, IP address (exact, ip range or ip with wildcards) or hardware address. The result of the parsing is a Hashtable with possible keys "string", "hw", "name", "domain", "ip_low" and "ip_high".

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

DNS::Zone contains a collection of Perl modules which provide an abstraction of name service zones as well as server specific adaptors for concrete file representations.

The modules origin is the ZoneMaster project which make heavy use of the module for comprehensive zone file management. Go to http://www.zonemaster.org for further information.

Installation:

You install DNS::Zone as you would install any perl module library, by running these command:

If you have CPAN.pm installed and are connected to the Internet

perl -MCPAN -e shell
> install DNS::Zone

or even

perl -MCPAN -e install DNS::Zone

otherwise

perl Makefile.PL
make
make test
make install

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

Test::Parser is a collection of parsers for different test output file formats. These parse the data into a general purpose data structure that can then be used to create reports, do post-processing analysis, etc.

Test-Parser can also export tests in SpikeSources TRPI test description XML language.