func domainCacheTest(database *mgo.Database, r *http.Request, requestContent, header string, domainCacheTestData []DomainCacheTestData) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) for _, item := range domainCacheTestData { r.Header.Set(header, item.HeaderValue) if len(requestContent) > 0 { utils.BuildHTTPHeader(r, []byte(requestContent)) } else { 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 != item.ExpectedHTTPStatus { utils.Fatalln(fmt.Sprintf("Error in %s test using %s [%s] "+ "HTTP header. Expected HTTP status code %d and got %d", r.Method, header, item.HeaderValue, item.ExpectedHTTPStatus, w.Code), errors.New(string(responseContent))) } } }
func retrieveScansMetadata(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.ScansHandler) mux.Handle("/scans", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/scans/?orderby=startedat:desc&pagesize=10&page=1", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) response1 := *h.Response responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving scans", errors.New(string(responseContent))) } r, err = http.NewRequest("HEAD", "/scans/?orderby=startedat:desc&pagesize=10&page=1", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) mux.ServeHTTP(w, r) response2 := *h.Response responseContent, err = ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving scans", errors.New(string(responseContent))) } if !utils.CompareProtocolScans(response1, response2) { utils.Fatalln("At this point the GET and HEAD method should "+ "return the same body content", nil) } }
func retrieveScanMetadata(database *mgo.Database, startedAt time.Time) { mux := handy.NewHandy() h := new(handler.ScanHandler) mux.Handle("/scan/{started-at}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", fmt.Sprintf("/scan/%s", startedAt.Format(time.RFC3339Nano)), nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) response1 := *h.Response responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving scan", errors.New(string(responseContent))) } r, err = http.NewRequest("HEAD", fmt.Sprintf("/scan/%s", startedAt.Format(time.RFC3339Nano)), nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) mux.ServeHTTP(w, r) response2 := *h.Response responseContent, err = ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving scan", errors.New(string(responseContent))) } if !utils.CompareProtocolScan(response1, response2) { utils.Fatalln("At this point the GET and HEAD method should "+ "return the same body content", nil) } }
func retrieveDomainMetadata(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/domain/example.com.br.", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) response1 := *h.Response responseContent, err := ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body from GET", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving domain", errors.New(string(responseContent))) } r, err = http.NewRequest("HEAD", "/domain/example.com.br.", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) mux.ServeHTTP(w, r) response2 := *h.Response responseContent, err = ioutil.ReadAll(w.Body) if err != nil { utils.Fatalln("Error reading response body from HEAD", err) } if w.Code != http.StatusOK { utils.Fatalln("Error retrieving domain", errors.New(string(responseContent))) } if !utils.CompareProtocolDomain(response1, response2) { utils.Fatalln("At this point the GET and HEAD method should "+ "return the same body content", nil) } }
func retrieveScansIfNoneMatch(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.ScansHandler) mux.Handle("/scans", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/scans", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) scansCacheTest(database, r, "If-None-Match", []ScansCacheTestData{ { HeaderValue: w.Header().Get("ETag"), ExpectedHTTPStatus: http.StatusNotModified, }, { HeaderValue: w.Header().Get("ETag") + "x", ExpectedHTTPStatus: http.StatusOK, }, }) }
func retrieveUnknownScan(database *mgo.Database, startedAt time.Time) { mux := handy.NewHandy() h := new(handler.ScanHandler) mux.Handle("/scan/{started-at}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", fmt.Sprintf("/scan/%s", startedAt.Add(-1*time.Millisecond).Format(time.RFC3339Nano)), 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.StatusNotFound { utils.Fatalln("Error retrieving unknown scan", errors.New(string(responseContent))) } }
func deleteDomains(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) for i := 0; i < 100; i++ { r, err := http.NewRequest("DELETE", fmt.Sprintf("/domain/example%d.com.br.", i), 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.StatusNoContent { utils.Fatalln("Error removing domain", errors.New(string(responseContent))) } } }
func retrieveUnknownDomain(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/domain/example.com.br.", 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.StatusNotFound { utils.Fatalln("Error retrieving unknown domain", errors.New(string(responseContent))) } }
func retrieveDomainsWithCache() { 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) } var r *http.Request var err error r, err = http.NewRequest("GET", fmt.Sprintf("%s%s", url, "/domains"), 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) } r, err = http.NewRequest("GET", fmt.Sprintf("%s%s", url, "/domains"), nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } r.Header.Add("If-None-Match", response.Header.Get("ETag")) utils.BuildHTTPHeader(r, nil) response, err = client.Do(r) if err != nil { utils.Fatalln("Error sending request", err) } if response.StatusCode != http.StatusNotModified { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method GET and URI /domains", http.StatusNotModified, response.StatusCode), nil) } }
func createDomains() { 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) } var r *http.Request var err error for i := 0; i < 100; i++ { uri := fmt.Sprintf("/domain/example%d.com.br.", i) content := `{ "Nameservers": [ { "host": "a.dns.br." }, { "host": "b.dns.br." } ], "Owners": [ { "email": "*****@*****.**", "language": "pt-br" } ] }` r, err = http.NewRequest("PUT", fmt.Sprintf("%s%s", url, uri), bytes.NewReader([]byte(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) } if response.StatusCode != http.StatusCreated { responseContent, err := ioutil.ReadAll(response.Body) if err == nil { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method PUT and URI %s", http.StatusCreated, response.StatusCode, uri), errors.New(string(responseContent)), ) } else { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method PUT and URI %s", http.StatusCreated, response.StatusCode, uri), nil) } } } }
func retrieveScan(database *mgo.Database, startedAt time.Time) { mux := handy.NewHandy() h := new(handler.ScanHandler) mux.Handle("/scan/{started-at}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", fmt.Sprintf("/scan/%s", startedAt.Format(time.RFC3339Nano)), 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("Error retrieving scan", errors.New(string(responseContent))) } if w.Header().Get("ETag") != "1" { utils.Fatalln("Not setting ETag in scan retrieve response", nil) } if len(w.Header().Get("Last-Modified")) == 0 { utils.Fatalln("Not setting Last-Modified in scan retrieve response", nil) } if h.Response.Status != "EXECUTED" { utils.Fatalln("Scan's status was not persisted correctly", nil) } if h.Response.DomainsScanned != 5000000 { utils.Fatalln("Scan's domains scanned information is wrong", nil) } if h.Response.DomainsWithDNSSECScanned != 250000 { utils.Fatalln("Scan's domains with DNSSEC scanned information is wrong", nil) } if h.Response.NameserverStatistics["OK"] != 4800000 || h.Response.NameserverStatistics["TIMEOUT"] != 200000 { utils.Fatalln("Scan's nameserver statistics are wrong", nil) } if h.Response.DSStatistics["OK"] != 220000 || h.Response.DSStatistics["EXPSIG"] != 30000 { utils.Fatalln("Scan's nameserver statistics are wrong", nil) } }
func retrieveCurrentScan() { 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, "/scans/?current"), 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(fmt.Sprintf("Expected HTTP status %d and got %d for method GET "+ "and URI /scan/currentscan", http.StatusOK, response.StatusCode), errors.New(string(responseContent)), ) } var scansResponse protocol.ScansResponse if err := json.Unmarshal(responseContent, &scansResponse); err != nil { utils.Fatalln("Error decoding scan response", err) } if len(scansResponse.Scans) != 1 { utils.Fatalln("Not returning the current scan in the result set or "+ "more items than expected were found", nil) } if scansResponse.Scans[0].Status != model.ScanStatusToString(model.ScanStatusWaitingExecution) { utils.Fatalln(fmt.Sprintf("Invalid status returned by current scan. Expected %s and got %s", model.ScanStatusToString(model.ScanStatusWaitingExecution), scansResponse.Scans[0].Status), nil) } }
func retrieveDomain(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/domain/example.com.br.", 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("Error retrieving domain", errors.New(string(responseContent))) } if w.Header().Get("ETag") != "2" { utils.Fatalln("Not setting ETag in domain retrieve response", nil) } if len(w.Header().Get("Last-Modified")) == 0 { utils.Fatalln("Not setting Last-Modified in domain retrieve response", nil) } if h.Response.FQDN != "example.com.br." { utils.Fatalln("Domain's FQDN was not persisted correctly", nil) } if len(h.Response.Nameservers) != 2 || h.Response.Nameservers[0].Host != "ns1.example.com.br." || h.Response.Nameservers[0].IPv4 != "127.0.0.1" || h.Response.Nameservers[1].Host != "ns3.example.com.br." || h.Response.Nameservers[1].IPv6 != "::1" { utils.Fatalln("Domain's nameservers were not persisted correctly", nil) } if len(h.Response.Owners) != 1 || h.Response.Owners[0].Email != "*****@*****.**" { utils.Fatalln("Domain's owners were not persisted correctly", nil) } }
func updateDomain(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) requestContent := `{ "Nameservers": [ { "host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "host": "ns3.example.com.br.", "ipv6": "::1" } ], "Owners": [ { "email": "*****@*****.**", "language": "pt-br" } ] }` r, err := http.NewRequest("PUT", "/domain/example.com.br.", 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.StatusNoContent { utils.Fatalln(fmt.Sprintf("Error updating domain. "+ "Expecting %d and got %d", http.StatusNoContent, w.Code), errors.New(string(responseContent))) } if w.Header().Get("ETag") != "2" { utils.Fatalln("Not setting ETag in domain update response", nil) } if len(w.Header().Get("Last-Modified")) == 0 { utils.Fatalln("Not setting Last-Modified in domain update response", nil) } if len(w.Header().Get("Location")) > 0 { utils.Fatalln("Setting Location in domain update response", nil) } }
func restActionReport(numberOfItems int, content []byte, requestBuilder func(int) (*http.Request, error), expectedStatus int, action string) string { var client http.Client totalDuration, domainsPerSecond := calculateRESTDurations(func() { for i := 0; i < numberOfItems; i++ { r, err := requestBuilder(i) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, content) response, err := client.Do(r) if err != nil { utils.Fatalln(fmt.Sprintf("Error detected when sending request for action %s"+ " and URI \"%s\"", action, r.URL.RequestURI()), err) } _, err = ioutil.ReadAll(response.Body) if err != nil { utils.Fatalln(fmt.Sprintf("Error detected when reading the response body for action %s"+ " and URI \"%s\"", action, r.URL.RequestURI()), err) } response.Body.Close() if response.StatusCode != expectedStatus { utils.Fatalln(fmt.Sprintf("Error with the domain object in the action %s. "+ "Expected HTTP status %d and got %d", action, expectedStatus, response.StatusCode), nil) } } }, numberOfItems) var memStats runtime.MemStats runtime.ReadMemStats(&memStats) return fmt.Sprintf("% -8d | %-9s | %16s | %4d | %14.2f\n", numberOfItems, action, time.Duration(int64(totalDuration)).String(), domainsPerSecond, float64(memStats.Alloc)/float64(MB), ) }
func removeDomains() { 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) } var r *http.Request var err error for i := 0; i < 100; i++ { uri := fmt.Sprintf("/domain/example%d.com.br.", i) r, err = http.NewRequest("DELETE", fmt.Sprintf("%s%s", url, uri), 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) } if response.StatusCode != http.StatusNoContent { responseContent, err := ioutil.ReadAll(response.Body) if err == nil { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method DELETE and URI %s", http.StatusCreated, response.StatusCode, uri), errors.New(string(responseContent)), ) } else { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method DELETE and URI %s", http.StatusCreated, response.StatusCode, uri), nil) } } } }
func retrieveCurrentScan(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.ScansHandler) mux.Handle("/scans", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/scans?current", 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("Error retrieving scan", errors.New(string(responseContent))) } if len(w.Header().Get("Last-Modified")) == 0 { utils.Fatalln("Current scan should return the Last-Modified header", nil) } if len(h.Response.Scans) != 1 { utils.Fatalln("Current scan not returned when it should", nil) } if h.Response.Scans[0].Status != "RUNNING" || h.Response.Scans[0].DomainsToBeScanned != 5 || h.Response.Scans[0].DomainsScanned != 4 || h.Response.Scans[0].DomainsWithDNSSECScanned != 1 { utils.Fatalln("Not retrieving current scan information correctly", nil) } }
func createDomains(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) for i := 0; i < 100; i++ { requestContent := `{ "Nameservers": [ { "host": "ns1.example.com.br." }, { "host": "ns2.example.com.br." } ], "Owners": [ { "email": "*****@*****.**", "language": "pt-br" } ] }` r, err := http.NewRequest("PUT", fmt.Sprintf("/domain/example%d.com.br.", i), 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.StatusCreated { utils.Fatalln("Error creating domain", errors.New(string(responseContent))) } } }
func invalidFQDN(database *mgo.Database) { mux := handy.NewHandy() h := new(handler.DomainHandler) mux.Handle("/domain/{fqdn}", func() handy.Handler { return h }) r, err := http.NewRequest("GET", "/domain/!!!", nil) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, nil) w := httptest.NewRecorder() mux.ServeHTTP(w, r) if w.Code != http.StatusBadRequest { utils.Fatalln(fmt.Sprintf("Not verifying if FQDN exists in the URI. "+ "Expected status %d and got %d", http.StatusBadRequest, w.Code), 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) } }
func retrieveDomains(database *mgo.Database) { data := []struct { URI string ExpectedHTTPStatus int ContentCheck func(*protocol.DomainsResponse) }{ { URI: "/domains/?orderby=xxx:desc&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/domains/?orderby=fqdn:xxx&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/domains/?orderby=fqdn:desc&pagesize=xxx&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/domains/?orderby=fqdn:desc&pagesize=10&page=xxx", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/domains/?orderby=fqdn:desc&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(domainsResponse *protocol.DomainsResponse) { if len(domainsResponse.Domains) != 10 { utils.Fatalln("Error retrieving the wrong number of domains", nil) } }, }, { URI: "/domains", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(domainsResponse *protocol.DomainsResponse) { if len(domainsResponse.Domains) == 0 { utils.Fatalln("Error retrieving domains", nil) } if len(domainsResponse.Domains[0].Nameservers) == 0 { utils.Fatalln("Error retrieving domains, no nameservers", nil) } if len(domainsResponse.Domains[0].Nameservers[0].Host) > 0 { utils.Fatalln("Not compressing domains result", nil) } }, }, { URI: "/domains?expand", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(domainsResponse *protocol.DomainsResponse) { if len(domainsResponse.Domains) == 0 { utils.Fatalln("Error retrieving domains", nil) } if len(domainsResponse.Domains[0].Nameservers) == 0 { utils.Fatalln("Error retrieving domains, no nameservers", nil) } if len(domainsResponse.Domains[0].Nameservers[0].Host) == 0 { utils.Fatalln("Compressing domains result when it's not necessary", nil) } }, }, } mux := handy.NewHandy() h := new(handler.DomainsHandler) mux.Handle("/domains", func() handy.Handler { return h }) for _, item := range data { r, err := http.NewRequest("GET", item.URI, 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 != item.ExpectedHTTPStatus { utils.Fatalln(fmt.Sprintf("Error when requesting domains using the URI [%s]. "+ "Expected HTTP status code %d but got %d", item.URI, item.ExpectedHTTPStatus, w.Code), errors.New(string(responseContent))) } if item.ContentCheck != nil { item.ContentCheck(h.Response) } } }
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 retrieveScans(database *mgo.Database) { data := []struct { URI string ExpectedHTTPStatus int ContentCheck func(*protocol.ScansResponse) }{ { URI: "/scans/?orderby=xxx:desc&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/scans/?orderby=startedat:xxx&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/scans/?orderby=startedat:desc&pagesize=xxx&page=1", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/scans/?orderby=startedat:desc&pagesize=10&page=xxx", ExpectedHTTPStatus: http.StatusBadRequest, }, { URI: "/scans/?orderby=startedat:desc&pagesize=10&page=1", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(scansResponse *protocol.ScansResponse) { if len(scansResponse.Scans) != 10 { utils.Fatalln("Error retrieving the wrong number of scans", nil) } }, }, { URI: "/scans", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(scansResponse *protocol.ScansResponse) { if len(scansResponse.Scans) == 0 { utils.Fatalln("Error retrieving scans", nil) } if scansResponse.Scans[0].DomainsScanned > 0 { utils.Fatalln("Not compressing scans result", nil) } }, }, { URI: "/scans?expand", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(scansResponse *protocol.ScansResponse) { if len(scansResponse.Scans) == 0 { utils.Fatalln("Error retrieving scans", nil) } if scansResponse.Scans[0].DomainsScanned == 0 { utils.Fatalln("Compressing scans result when it shouldn't", nil) } }, }, { URI: "/scans?current", ExpectedHTTPStatus: http.StatusOK, ContentCheck: func(scansResponse *protocol.ScansResponse) { if len(scansResponse.Scans) == 0 { utils.Fatalln("Error retrieving current scan", nil) } if scansResponse.Scans[0].Status != "WAITINGEXECUTION" { utils.Fatalln("Current scan with wrong status", nil) } }, }, } mux := handy.NewHandy() h := new(handler.ScansHandler) mux.Handle("/scans", func() handy.Handler { return h }) for _, item := range data { r, err := http.NewRequest("GET", item.URI, 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 != item.ExpectedHTTPStatus { utils.Fatalln(fmt.Sprintf("Error when requesting scans using the URI [%s]. "+ "Expected HTTP status code %d but got %d", item.URI, item.ExpectedHTTPStatus, w.Code), errors.New(string(responseContent))) } if item.ContentCheck != nil { item.ContentCheck(h.Response) } } }
func domainLifeCycle() { data := []struct { method string uri string expectedStatus int content string expectedBody string }{ { method: "PUT", uri: "/domain/example.com.br.", expectedStatus: http.StatusCreated, content: `{ "Nameservers": [ { "host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "host": "ns2.example.com.br.", "ipv6": "::1" } ], "Owners": [ { "email": "*****@*****.**", "language": "pt-br" } ] }`, }, { method: "PUT", uri: "/domain/example.com.br.", expectedStatus: http.StatusNoContent, content: `{ "Nameservers": [ { "host": "ns1.example.com.br.", "ipv4": "127.0.0.1" } ], "Owners": [ { "email": "*****@*****.**", "language": "en-us" } ] }`, }, { method: "GET", uri: "/domain/example.com.br.", expectedStatus: http.StatusOK, expectedBody: `{"fqdn":"example.com.br.","nameservers":[{"host":"ns1.example.com.br.","ipv4":"127.0.0.1","lastStatus":"NOTCHECKED","lastCheckAt":"0001-01-01T00:00:00Z","lastOKAt":"0001-01-01T00:00:00Z"}],"owners":[{"email":"*****@*****.**","language":"en-US"}],"links":[{"types":["self"],"href":"/domain/example.com.br."}]}`, }, { method: "DELETE", uri: "/domain/example.com.br.", expectedStatus: http.StatusNoContent, }, } 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) } for _, item := range data { var r *http.Request var err error if len(item.content) > 0 { r, err = http.NewRequest(item.method, fmt.Sprintf("%s%s", url, item.uri), bytes.NewReader([]byte(item.content))) } else { r, err = http.NewRequest(item.method, fmt.Sprintf("%s%s", url, item.uri), nil) } if err != nil { utils.Fatalln("Error creating the HTTP request", err) } utils.BuildHTTPHeader(r, []byte(item.content)) response, err := client.Do(r) if err != nil { utils.Fatalln("Error sending request", err) } var responseContent []byte if response.ContentLength > 0 { responseContent, err = ioutil.ReadAll(response.Body) if err != nil { utils.Fatalln(fmt.Sprintf("Error reading response for method %s and URI %s", item.method, item.uri), err, ) } } if response.StatusCode != item.expectedStatus { utils.Fatalln(fmt.Sprintf("Expected HTTP status %d and got %d for method %s and URI %s", item.expectedStatus, response.StatusCode, item.method, item.uri), errors.New(string(responseContent)), ) } else if string(responseContent) != item.expectedBody { utils.Fatalln(fmt.Sprintf("Expected HTTP body [%s] and got [%s] for method %s and URI %s", item.expectedBody, string(responseContent), item.method, item.uri), nil) } } }
func retrieveScan(startedAt time.Time) { 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) } uri := fmt.Sprintf("/scan/%s", startedAt.Format(time.RFC3339Nano)) r, err := http.NewRequest("GET", fmt.Sprintf("%s%s", url, uri), 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(fmt.Sprintf("Expected HTTP status %d and got %d for method GET "+ "and URI /scan/currentscan", http.StatusOK, response.StatusCode), errors.New(string(responseContent)), ) } var scanResponse protocol.ScanResponse if err := json.Unmarshal(responseContent, &scanResponse); err != nil { utils.Fatalln("Error decoding scan response", err) } if scanResponse.Status != model.ScanStatusToString(model.ScanStatusExecuted) { utils.Fatalln("Invalid status returned by scan", nil) } // Tolerance of one second if scanResponse.StartedAt.Sub(startedAt) > (1*time.Second) || scanResponse.StartedAt.Sub(startedAt) < (-1*time.Second) { utils.Fatalln("Invalid start date returned by scan", nil) } if scanResponse.DomainsScanned != 5000000 { utils.Fatalln("Invalid number of domains scanned returned by scan", nil) } if scanResponse.DomainsWithDNSSECScanned != 250000 { utils.Fatalln("Invalid number of domains with DNSSEC scanned returned by scan", nil) } if len(scanResponse.NameserverStatistics) != 2 { utils.Fatalln("Invalid nameserver statistics returned by scan", nil) } if len(scanResponse.DSStatistics) != 2 { utils.Fatalln("Invalid dsset statistics returned by scan", 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 retrieveScansWithPagination() { 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, "/scans?page=5&pagesize=20"), 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(fmt.Sprintf("Expected HTTP status %d and got %d for method GET "+ "and URI /scans", http.StatusOK, response.StatusCode), errors.New(string(responseContent)), ) } var scansResponse protocol.ScansResponse if err := json.Unmarshal(responseContent, &scansResponse); err != nil { utils.Fatalln("Error decoding scan response", err) } if scansResponse.PageSize != 20 { utils.Fatalln("Default page size isn't 20", nil) } if scansResponse.Page != 5 { utils.Fatalln("Default page isn't the first one", nil) } if scansResponse.NumberOfItems != 100 { utils.Fatalln("Not calculating the correct number of scans", nil) } if scansResponse.NumberOfPages != 5 { utils.Fatalln("Not calculating the correct number of pages", nil) } if len(scansResponse.Scans) != scansResponse.PageSize { utils.Fatalln("Not returning all desired scans", 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) } }