利用收集的DNS数据搭建C段和子域名查询库

0X00:思路概述

渗透的本质就是信息收集。因此，前期信息的收集的完整性直接影响到渗透目标是否能够做下。

本文是尝试利用一些互联网公开的DNS数据来搭建一个本地的查询数据库，不求能完整的建立，只尝试这样的思路是否可行。

数据来源：https://opendata.rapid7.com/

数据样例：

2019-03-27-1553712188-rdns.json.gz 11.4GB

2019-03-29-1553861003-fdns_a.json.gz 19.8GB

实验主机配置(虚拟机)：

内存 64GB

Windows Server 2016 X64

CPU E5-2678 v3 2.5GHz

0X01:数据库的选择

2019-03-27-1553712188-rdns.json.gz 解压后 128G内容大概如下：

{“timestamp”:”1553746651″,”name”:”1.10.147.153″,”value”:”node-3vd.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

{“timestamp”:”1553772228″,”name”:”1.10.147.154″,”value”:”node-3ve.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

{“timestamp”:”1553744853″,”name”:”1.10.147.155″,”value”:”node-3vf.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

……

数据是单行的json格式文件。

前期猜想:

	mongodb	mysql(myisam)	mysql(innodb)
导入	方便	不方便	不方便
查询速度	最快	快	慢
存储占用	最大	小	大

实际测试过程中

1)mongodb

mongoimport –db dns –collection testDns –file E:\testDns.json

mongoimport –db dns –collection testRdns –file E:\testRdns.json

导入很方便，存储空间却是三种中占用最少的。

> db.testDns.storageSize()

87838519296 (91.8GB)

> db.testRdns.storageSize()

51861549056 (48.2GB)

2)mysql(myisam)和mysql(innodb)

{“timestamp”:”1553746651″,”name”:”1.10.147.153″,”value”:”node-3vd.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

{“timestamp”:”1553772228″,”name”:”1.10.147.154″,”value”:”node-3ve.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

{“timestamp”:”1553744853″,”name”:”1.10.147.155″,”value”:”node-3vf.pool-1-10.dynamic.totbroadband.com”,”type”:”ptr”}

……

中我们想要的其实也就是name和value的值，其他的数值并不重要。（这里需要节约存储空间）

因此处理之后的数据应该是这样的：

1.10.147.153₡node-3vd.pool-1-10.dynamic.totbroadband.com

1.10.147.154₡node-3ve.pool-1-10.dynamic.totbroadband.com

1.10.147.155₡node-3vf.pool-1-10.dynamic.totbroadband.com

…..

再通过load data local infile的方式快速将数据导入

myisam

> Affected rows: 1276329672

> 时间: 4141.457s

innodb

> Affected rows: 1276329672

> 时间: 8245.99s

innodb导入数据的速度比起myisam差不多要慢一倍的时间

myisam 20190327rdns.MYD 64.9GB

innodb 20190327rdns.ibd 98GB

这样看起来应该优先使用 mongodb 数据库，它不仅导入方便而且占用空间小。

0X02:查询速度的对比

1）建立索引速度

没有记录具体的时间作为供参考，印象中innodb和mongodb建立索引的速度会比myisam快很多。

使用myisam对1276329672数据建立索引，几乎用了二十多个小时。

这可能和测试机器是虚拟机搭建的，I/O处理性能没那么高有关。

2）测试查询的速度

a.精确查询：

myisam和innodb的查询速度几乎一样，都是0.033s左右

mongodb使用时间特别长（可能优势在于分布式，也可能是虚拟机不行，最可能是因为以前没用过配置有问题）

b.模糊查询：

模糊查询C段：

‘127.0.0.%’ 这种形式会使用到索引。

查询子域名：

‘%.test.com’ 这种形式不会使用索引，会整个遍历匹配。

解决方法:

在处理原始数据的时候，我们将包含域名的那一列字符串反转存入数据库中，如下：

1.10.147.153,moc.dnabdaorbtot.cimanyd.01-1-loop.dv3-edon

1.10.147.154,moc.dnabdaorbtot.cimanyd.01-1-loop.ev3-edon

1.10.147.155,moc.dnabdaorbtot.cimanyd.01-1-loop.fv3-edon

…

查询的时候使用’moc.tset.%’这样的格式就可以触发索引了。

0X03:实际对比效果

	mongodb	mysql(myisam)	mysql(innodb)
导入	方便	不方便	不方便
查询速度	最慢	快	快
存储占用	小	大	最大

通过对比，就直接把mongodb排除，可能是以前没接触过，也可能是没优化好，它就是最慢的。

myisam占用空间和查询速度的优势都不是特别明显，再加上索引建立的速度太慢了，因此它也被排除。

最终决定使用innodb引擎建立数据库。

0X04:innodb搭建流程简介

1)处理原始数据

E:\>DnsProcess.exe -f testRdns.json

35

1h26m22.7345813s

success!

DnsProcess.exe源代码如下：

package main
 
import (
	"bufio"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"
 
	"github.com/json-iterator/go"
)
 
type Dns struct {
	Timestamp string
	Name      string
	Value     string
	Type      string
}
 
func main() {
	startTime := time.Now()
	filename := flag.String("f", "test.txt", "filename")
	flag.Parse()
	ProcessJson(*filename)
	endTime := time.Now()
	fmt.Println(endTime.Sub(startTime))
	fmt.Println("success!")
}
func ProcessJson(filename string) {
	n := 0    //统计最大长度，方便建立数据表
	SP := "₡" //列分隔符，以免原始数据中存在脏数据包含了','，导致无法正确导入数据
	var err error
	if !checkFileIsExist(filename) {
		fmt.Println(filename + " does not exist!")
		os.Exit(0)
	}
	var f2 *os.File
	filename2 := "p_" + strings.Split(filename, ".")[0] + ".txt"
	if checkFileIsExist(filename2) {
		fmt.Println(filename2 + " exists!")
		os.Exit(0)
	} else {
		f2, err = os.Create(filename2)
		check(err)
	}
	defer f2.Close()
	f1, err := os.Open(filename)
	check(err)
	defer f1.Close()
	r := bufio.NewReader(f1)
	w2 := bufio.NewWriter(f2)
	for {
		o_l, err := readLine(r)
		if err != nil {
			break
		} else {
 
			var dns Dns
			if err := jsoniter.Unmarshal(o_l, &dns); err != nil {
				fmt.Println("error: ", err)
			}
			if len(dns.Name) > n {
				n = len(dns.Name)
			}
			if len(dns.Value) > n {
				n = len(dns.Value)
			}
			//_, err2 := w2.WriteString(dns.Name + SP + reverseString(dns.Value) + "\r\n") //rdns
			_, err2 := w2.WriteString(reverseString(dns.Name) + SP + dns.Value + "\r\n") //fdns
			check(err2)
			w2.Flush()
		}
	}
	fmt.Println(n)
}
 
func reverseString(s string) string {
	runes := []rune(s)
	for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
		runes[from], runes[to] = runes[to], runes[from]
	}
	return string(runes)
}
 
func readLine(r *bufio.Reader) ([]byte, error) {
	line, isprefix, err := r.ReadLine()
	for isprefix && err == nil {
		var bs []byte
		bs, isprefix, err = r.ReadLine()
		line = append(line, bs...)
	}
	return line, err
}
func check(e error) {
	if e != nil {
		panic(e)
	}
}
func checkFileIsExist(filename string) bool {
	var exist = true
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		exist = false
	}
	return exist
}

2)根据统计最大长度建立数据表

3)load data导入数据

load data local infile “E:\\p_testRdns.txt” into table 20190327rdns fields terminated by “₡” (name,value)

4)对两个字段建立索引

5)当导入完所有数据时，可以建立视图，编写查询程序。

0X05:结束：

这个数据库最后完整的搭建出来可能能查处一些东西，也可能查不出什么东西，并且查询到的很多子域名可能是很久之前用过的。这种数据看似是没有什么用。但是，我们通过分析这些数据，过对旧的子域名进行关键字的替换，进行爆破处理，有一定几率可以找到一些隐蔽的子域名。当然，这个是一个小概率事件，但至少也为我们的信息收集提供了一种思路。