func domainWithNoDNSErrors(config ScanQuerierTestConfigFile) {
domainsToQueryChannel := make(chan *model.Domain, config.Scan.DomainsBufferSize)
domainsToQueryChannel <- &model.Domain{
FQDN: "br.",
Nameservers: []model.Nameserver{
{
Host: "ns1.br",
IPv4: net.ParseIP("127.0.0.1"),
},
},
}
domainsToQueryChannel <- nil // Poison pill
dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
})
domains := runScan(config, domainsToQueryChannel)
for _, domain := range domains {
if domain.FQDN != "br." ||
domain.Nameservers[0].LastStatus != model.NameserverStatusOK {
utils.Fatalln(fmt.Sprintf("Error checking a well configured DNS domain. "+
"Expected FQDN 'br.' with status %d and got FQDN '%s' with status %d",
model.NameserverStatusOK, domain.FQDN, domain.Nameservers[0].LastStatus), nil)
}
}
}
func scanDomain() {
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.example.com.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
})
var client http.Client
url := ""
if len(config.ShelterConfig.WebClient.Listeners) > 0 {
url = fmt.Sprintf("http://%s:%d", config.ShelterConfig.WebClient.Listeners[0].IP,
config.ShelterConfig.WebClient.Listeners[0].Port)
}
if len(url) == 0 {
utils.Fatalln("There's no interface to connect to", nil)
}
content := `{
"Nameservers": [
{ "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" },
{ "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" }
]
}`
r, err := http.NewRequest("PUT",
fmt.Sprintf("%s%s", url, "/domain/example.com.br./verification"),
strings.NewReader(content))
if err != nil {
utils.Fatalln("Error creating the HTTP request", err)
}
utils.BuildHTTPHeader(r, []byte(content))
response, err := client.Do(r)
if err != nil {
utils.Fatalln("Error sending request", err)
}
responseContent, err := ioutil.ReadAll(response.Body)
if err != nil {
utils.Fatalln("Error reading response content", err)
}
if response.StatusCode != http.StatusOK {
utils.Fatalln("Error scanning domain", errors.New(string(responseContent)))
}
var domainResponse protocol.DomainResponse
if err := json.Unmarshal(responseContent, &domainResponse); err != nil {
utils.Fatalln("Error decoding domain response", err)
}
if len(domainResponse.Nameservers) != 2 {
utils.Fatalln("Wrong number of nameservers", nil)
}
if domainResponse.Nameservers[0].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) {
utils.Fatalln("Scan did not work for ns1", nil)
}
if domainResponse.Nameservers[1].LastStatus != model.NameserverStatusToString(model.NameserverStatusOK) {
utils.Fatalln("Scan did not work for ns2", nil)
}
}
func queryDomain() {
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeNS {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.NS{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "a.dns.br.",
},
&dns.NS{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "b.dns.br.",
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY {
// Empty response
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
var client http.Client
url := ""
if len(config.ShelterConfig.WebClient.Listeners) > 0 {
url = fmt.Sprintf("http://%s:%d", config.ShelterConfig.WebClient.Listeners[0].IP,
config.ShelterConfig.WebClient.Listeners[0].Port)
}
if len(url) == 0 {
utils.Fatalln("There's no interface to connect to", nil)
}
r, err := http.NewRequest("GET",
fmt.Sprintf("%s%s", url, "/domain/example.com.br./verification"), nil)
if err != nil {
utils.Fatalln("Error creating the HTTP request", err)
}
utils.BuildHTTPHeader(r, nil)
response, err := client.Do(r)
if err != nil {
utils.Fatalln("Error sending request", err)
}
responseContent, err := ioutil.ReadAll(response.Body)
if err != nil {
utils.Fatalln("Error reading response content", err)
}
if response.StatusCode != http.StatusOK {
utils.Fatalln("Error querying domain", errors.New(string(responseContent)))
}
var domainResponse protocol.DomainResponse
if err := json.Unmarshal(responseContent, &domainResponse); err != nil {
utils.Fatalln("Error decoding domain response", err)
}
if len(domainResponse.Nameservers) != 2 {
utils.Fatalln("Wrong number of nameservers", nil)
}
if len(domainResponse.DSSet) != 0 {
utils.Fatalln("Wrong number of DS records", nil)
}
}
// Generates a report with the amount of time of a scan
func scanQuerierReport(config ScanQuerierTestConfigFile) {
report := " # | Total | QPS | Memory (MB)\n" +
"-----------------------------------------------------\n"
// Report variables
scale := []int{10, 50, 100, 500, 1000, 5000,
10000, 50000, 100000, 500000, 1000000, 5000000}
fqdn := "domain.com.br."
dnskey, rrsig, err := utils.GenerateKSKAndSignZone(fqdn)
if err != nil {
utils.Fatalln("Error creating DNSSEC keys and signatures", err)
}
ds := dnskey.ToDS(uint8(model.DSDigestTypeSHA1))
dns.HandleFunc(fqdn, func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: fqdn,
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1." + fqdn,
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
dnskey,
rrsig,
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
for _, numberOfItems := range scale {
var domains []*model.Domain
for i := 0; i < numberOfItems; i++ {
// We create an object with different nameservers because we don't want to put the
// nameserver in the query rate limit check
domains = append(domains, &model.Domain{
FQDN: fqdn,
Nameservers: []model.Nameserver{
{
Host: fmt.Sprintf("ns%d.%s", i, fqdn),
IPv4: net.ParseIP("127.0.0.1"),
},
},
DSSet: []model.DS{
{
Keytag: dnskey.KeyTag(),
Algorithm: utils.ConvertKeyAlgorithm(dnskey.Algorithm),
DigestType: model.DSDigestTypeSHA1,
Digest: ds.Digest,
},
},
})
}
utils.Println(fmt.Sprintf("Generating report - scale %d", numberOfItems))
totalDuration, queriesPerSecond, _, _ :=
calculateScanQuerierDurations(config, domains)
var memStats runtime.MemStats
runtime.ReadMemStats(&memStats)
report += fmt.Sprintf("% -8d | %16s | %4d | %14.2f\n",
numberOfItems,
time.Duration(int64(totalDuration)).String(),
queriesPerSecond,
float64(memStats.Alloc)/float64(MB),
)
}
utils.WriteReport(config.Report.ReportFile, report)
}
func domainWithNoDNSSECErrors(config ScanQuerierTestConfigFile) {
dnskey, rrsig, err := utils.GenerateKSKAndSignZone("br.")
if err != nil {
utils.Fatalln("Error creating DNSSEC keys and signatures", err)
}
ds := dnskey.ToDS(uint8(model.DSDigestTypeSHA1))
domainsToQueryChannel := make(chan *model.Domain, config.Scan.DomainsBufferSize)
domainsToQueryChannel <- &model.Domain{
FQDN: "br.",
Nameservers: []model.Nameserver{
{
Host: "ns1.br",
IPv4: net.ParseIP("127.0.0.1"),
},
},
DSSet: []model.DS{
{
Keytag: dnskey.KeyTag(),
Algorithm: utils.ConvertKeyAlgorithm(dnskey.Algorithm),
DigestType: model.DSDigestTypeSHA1,
Digest: ds.Digest,
},
},
}
domainsToQueryChannel <- nil // Poison pill
dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
dnskey,
rrsig,
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
domains := runScan(config, domainsToQueryChannel)
for _, domain := range domains {
if domain.FQDN != "br." ||
domain.DSSet[0].LastStatus != model.DSStatusOK {
utils.Fatalln(fmt.Sprintf("Error checking a well configured DNSSEC domain. "+
"Expected FQDN 'br.' with status %d and got FQDN '%s' with status %d",
model.DSStatusOK, domain.FQDN, domain.DSSet[0].LastStatus), nil)
}
}
}
func domainQuery() {
_, dnskey, rrsig, _, _ := generateAndSignDomain("example.com.br.")
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeNS {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.NS{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.example.com.br.",
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
dnskey,
rrsig,
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
dns.HandleFunc("ns1.example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeA {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.A{
Hdr: dns.RR_Header{
Name: "ns1.example.com.br.",
Rrtype: dns.TypeA,
Class: dns.ClassINET,
Ttl: 86400,
},
A: net.ParseIP("127.0.0.1"),
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeAAAA {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.AAAA{
Hdr: dns.RR_Header{
Name: "ns1.example.com.br.",
Rrtype: dns.TypeAAAA,
Class: dns.ClassINET,
Ttl: 86400,
},
AAAA: net.ParseIP("::1"),
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
domain, err := scan.QueryDomain("example.com.br.")
if err != nil {
utils.Fatalln("Error resolving a domain", err)
}
if domain.FQDN != "example.com.br." {
utils.Fatalln("Did not set FQDN properly in domain query", nil)
}
if len(domain.Nameservers) != 1 {
println(len(domain.Nameservers))
utils.Fatalln("Did not return the desired nameservers in domain query", nil)
}
if domain.Nameservers[0].Host != "ns1.example.com.br." {
utils.Fatalln("Did not set a valid host in domain query", nil)
}
if domain.Nameservers[0].IPv4.String() != "127.0.0.1" {
utils.Fatalln("Did not set a valid IPv4 in domain query", nil)
}
if domain.Nameservers[0].IPv6.String() != "::1" {
utils.Fatalln("Did not set a valid IPv6 in domain query", nil)
}
if len(domain.DSSet) != 1 {
utils.Fatalln("Did not return the desired DS set in domain query", nil)
}
if domain.DSSet[0].Keytag != dnskey.KeyTag() {
utils.Fatalln("Did not set a valid keytag in domain query", nil)
}
if domain.DSSet[0].Algorithm != model.DSAlgorithm(dnskey.Algorithm) {
utils.Fatalln("Did not set a valid algorithm in domain query", nil)
}
}
func domainWithNoErrorsOnTheFly() {
domain, dnskey, rrsig, lastCheckAt, lastOKAt := generateAndSignDomain("br.")
dns.HandleFunc("br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
if dnsRequestMessage.Question[0].Qtype == dns.TypeSOA {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
} else if dnsRequestMessage.Question[0].Qtype == dns.TypeDNSKEY {
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
dnskey,
rrsig,
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
}
})
scan.ScanDomain(&domain)
for _, nameserver := range domain.Nameservers {
if nameserver.LastStatus != model.NameserverStatusOK {
utils.Fatalln(fmt.Sprintf("Fail to validate a supposedly well configured nameserver '%s'. Found status: %s",
nameserver.Host, model.NameserverStatusToString(nameserver.LastStatus)), nil)
}
if nameserver.LastCheckAt.Before(lastCheckAt) ||
nameserver.LastCheckAt.Equal(lastCheckAt) {
utils.Fatalln(fmt.Sprintf("Last check date was not updated in nameserver '%s'",
nameserver.Host), nil)
}
if nameserver.LastOKAt.Before(lastOKAt) || nameserver.LastOKAt.Equal(lastOKAt) {
utils.Fatalln(fmt.Sprintf("Last OK date was not updated in nameserver '%s'",
nameserver.Host), nil)
}
}
for _, ds := range domain.DSSet {
if ds.LastStatus != model.DSStatusOK {
utils.Fatalln(fmt.Sprintf("Fail to validate a supposedly well configured DS %d. "+
"Found status: %s", ds.Keytag, model.DSStatusToString(ds.LastStatus)), nil)
}
if ds.LastCheckAt.Before(lastCheckAt) || ds.LastCheckAt.Equal(lastCheckAt) {
utils.Fatalln(fmt.Sprintf("Last check date was not updated in DS %d",
ds.Keytag), nil)
}
if ds.LastOKAt.Before(lastOKAt) || ds.LastOKAt.Equal(lastOKAt) {
utils.Fatalln(fmt.Sprintf("Last OK date was not updated in DS %d",
ds.Keytag), nil)
}
}
}
func scanDomain() {
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.example.com.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
})
mux := handy.NewHandy()
h := new(handler.DomainVerificationHandler)
mux.Handle("/domain/{fqdn}/verification", func() handy.Handler {
return h
})
requestContent := `{
"Nameservers": [
{ "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" },
{ "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" }
]
}`
r, err := http.NewRequest("PUT", "/domain/example.com.br./verification",
strings.NewReader(requestContent))
if err != nil {
utils.Fatalln("Error creating the HTTP request", err)
}
utils.BuildHTTPHeader(r, []byte(requestContent))
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
responseContent, err := ioutil.ReadAll(w.Body)
if err != nil {
utils.Fatalln("Error reading response body", err)
}
if w.Code != http.StatusOK {
utils.Fatalln(fmt.Sprintf("Error scanning domain. "+
"Expected %d and got %d", http.StatusOK, w.Code),
errors.New(string(responseContent)))
}
if len(h.Response.Nameservers) != 2 {
utils.Fatalln("Wrong number of nameservers", nil)
}
if h.Response.Nameservers[0].LastStatus !=
model.NameserverStatusToString(model.NameserverStatusOK) {
utils.Fatalln("Scan did not work for ns1", nil)
}
if h.Response.Nameservers[1].LastStatus !=
model.NameserverStatusToString(model.NameserverStatusOK) {
utils.Fatalln("Scan did not work for ns2", nil)
}
}
func queryDomain() {
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.NS{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "a.dns.br.",
},
&dns.NS{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "b.dns.br.",
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
})
mux := handy.NewHandy()
h := new(handler.DomainVerificationHandler)
mux.Handle("/domain/{fqdn}/verification", func() handy.Handler {
return h
})
r, err := http.NewRequest("GET", "/domain/example.com.br./verification", nil)
if err != nil {
utils.Fatalln("Error creating the HTTP request", err)
}
utils.BuildHTTPHeader(r, nil)
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
responseContent, err := ioutil.ReadAll(w.Body)
if err != nil {
utils.Fatalln("Error reading response body", err)
}
if w.Code != http.StatusOK {
utils.Fatalln(fmt.Sprintf("Error scanning domain. "+
"Expected %d and got %d", http.StatusOK, w.Code),
errors.New(string(responseContent)))
}
if len(h.Response.Nameservers) != 2 {
utils.Fatalln("Wrong number of nameservers", nil)
}
}
func scanPersistedDomain(domainDAO dao.DomainDAO) {
dns.HandleFunc("example.com.br.", func(w dns.ResponseWriter, dnsRequestMessage *dns.Msg) {
defer w.Close()
dnsResponseMessage := &dns.Msg{
MsgHdr: dns.MsgHdr{
Authoritative: true,
},
Question: dnsRequestMessage.Question,
Answer: []dns.RR{
&dns.SOA{
Hdr: dns.RR_Header{
Name: "example.com.br.",
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: 86400,
},
Ns: "ns1.example.com.br.",
Mbox: "rafael.justo.net.br.",
Serial: 2013112600,
Refresh: 86400,
Retry: 86400,
Expire: 86400,
Minttl: 900,
},
},
}
dnsResponseMessage.SetReply(dnsRequestMessage)
w.WriteMsg(dnsResponseMessage)
})
mux := handy.NewHandy()
h := new(handler.DomainVerificationHandler)
mux.Handle("/domain/{fqdn}/verification", func() handy.Handler {
return h
})
requestContent := `{
"Nameservers": [
{ "Host": "ns1.example.com.br.", "ipv4": "127.0.0.1" },
{ "Host": "ns2.example.com.br.", "ipv4": "127.0.0.1" }
]
}`
domain := model.Domain{
FQDN: "example.com.br.",
Nameservers: []model.Nameserver{
{
Host: "ns1.example.com.br.",
IPv4: net.ParseIP("127.0.0.1"),
},
{
Host: "ns2.example.com.br.",
IPv4: net.ParseIP("127.0.0.1"),
},
},
}
if err := domainDAO.Save(&domain); err != nil {
utils.Fatalln("Error saving domain", err)
}
r, err := http.NewRequest("PUT", "/domain/example.com.br./verification",
strings.NewReader(requestContent))
if err != nil {
utils.Fatalln("Error creating the HTTP request", err)
}
utils.BuildHTTPHeader(r, []byte(requestContent))
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
responseContent, err := ioutil.ReadAll(w.Body)
if err != nil {
utils.Fatalln("Error reading response body", err)
}
if w.Code != http.StatusOK {
utils.Fatalln(fmt.Sprintf("Error scanning domain. "+
"Expected %d and got %d", http.StatusOK, w.Code),
errors.New(string(responseContent)))
}
domain, err = domainDAO.FindByFQDN(domain.FQDN)
if err != nil {
utils.Fatalln("Error retrieving the domain", err)
}
if len(domain.Nameservers) != 2 ||
domain.Nameservers[0].LastStatus != model.NameserverStatusOK ||
domain.Nameservers[1].LastStatus != model.NameserverStatusOK {
utils.Fatalln("Not updating domain on a scan", nil)
}
// Now we are going to test when the database domain is different from the scanned domain
if err := domainDAO.RemoveByFQDN(domain.FQDN); err != nil {
utils.Fatalln("Error removing domain", err)
}
domain = model.Domain{
FQDN: "example.com.br.",
Nameservers: []model.Nameserver{
{
Host: "ns1.example.com.br.",
IPv4: net.ParseIP("127.0.0.1"),
},
{
Host: "ns3.example.com.br.",
IPv4: net.ParseIP("127.0.0.1"),
},
},
}
if err := domainDAO.Save(&domain); err != nil {
utils.Fatalln("Error saving domain", err)
}
mux.ServeHTTP(w, r)
responseContent, err = ioutil.ReadAll(w.Body)
if err != nil {
utils.Fatalln("Error reading response body", err)
}
if w.Code != http.StatusOK {
utils.Fatalln(fmt.Sprintf("Error scanning domain. "+
"Expected %d and got %d", http.StatusOK, w.Code),
errors.New(string(responseContent)))
}
domain, err = domainDAO.FindByFQDN(domain.FQDN)
if err != nil {
utils.Fatalln("Error retrieving the domain", err)
}
if len(domain.Nameservers) != 2 ||
domain.Nameservers[0].LastStatus != model.NameserverStatusNotChecked ||
domain.Nameservers[1].LastStatus != model.NameserverStatusNotChecked {
utils.Fatalln("Updating domain on a scan when it shouldn't", nil)
}
}