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 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 main() { flag.Parse() var config ScanCollectorTestConfigFile err := utils.ReadConfigFile(configFilePath, &config) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( []string{config.Database.URI}, config.Database.Name, false, "", "", ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() // Remove all data before starting the test. This is necessary because maybe in the last // test there was an error and the data wasn't removed from the database utils.ClearDatabase(database) domainWithErrors(config, database) domainWithNoErrors(config, database) utils.Println("SUCCESS!") }
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 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 main() { flag.Parse() err := utils.ReadConfigFile(configFilePath, &config.ShelterConfig) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( config.ShelterConfig.Database.URIs, config.ShelterConfig.Database.Name, false, "", "", ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() // If there was some problem in the last test, there could be some data in the // database, so let's clear it to don't affect this test. We avoid checking the error, // because if the collection does not exist yet, it will be created in the first // insert utils.ClearDatabase(database) invalidFQDN(database) createDomain(database) updateDomain(database) retrieveDomain(database) retrieveDomainMetadata(database) retrieveDomainIfModifiedSince(database) retrieveDomainIfUnmodifiedSince(database) retrieveDomainIfMatch(database) retrieveDomainIfNoneMatch(database) updateDomainIfModifiedSince(database) updateDomainIfUnmodifiedSince(database) updateDomainIfMatch(database) updateDomainIfNoneMatch(database) deleteDomainIfModifiedSince(database) deleteDomainIfUnmodifiedSince(database) deleteDomainIfMatch(database) deleteDomainIfNoneMatch(database) deleteDomain(database) retrieveUnknownDomain(database) utils.Println("SUCCESS!") }
func main() { flag.Parse() var config DomainDAOTestConfigFile err := utils.ReadConfigFile(configFilePath, &config) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( []string{config.Database.URI}, config.Database.Name, false, "", "", ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() domainDAO := dao.DomainDAO{ Database: database, } // If there was some problem in the last test, there could be some data in the // database, so let's clear it to don't affect this test. We avoid checking the error, // because if the collection does not exist yet, it will be created in the first // insert domainDAO.RemoveAll() domainLifeCycle(domainDAO) domainsLifeCycle(domainDAO) domainUniqueFQDN(domainDAO) domainConcurrency(domainDAO) domainsPagination(domainDAO) domainsNotification(domainDAO) domainsExpand(domainDAO) domainFilter(domainDAO) // Domain DAO performance report is optional and only generated when the report file // path parameter is given if report { domainDAOPerformanceReport(config.Report.ReportFile, domainDAO) } utils.Println("SUCCESS!") }
func main() { flag.Parse() err := utils.ReadConfigFile(configFilePath, &config.ShelterConfig) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( config.ShelterConfig.Database.URIs, config.ShelterConfig.Database.Name, config.ShelterConfig.Database.Auth.Enabled, config.ShelterConfig.Database.Auth.Username, config.ShelterConfig.Database.Auth.Password, ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() // If there was some problem in the last test, there could be some data in the database, // so let's clear it to don't affect this test. We avoid checking the error, because if // the collection does not exist yet, it will be created in the first insert utils.ClearDatabase(database) messageChannel, errorChannel, err := utils.StartMailServer(config.ShelterConfig.Notification.SMTPServer.Port) if err != nil { utils.Fatalln("Error starting the mail server", err) } domainDAO := dao.DomainDAO{ Database: database, } templateName := createTemplateFile() defer removeTemplateFile(templateName) simpleNotification(domainDAO, templateName, messageChannel, errorChannel) utils.Println("SUCCESS!") }
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 updateDomainIfNoneMatch(database *mgo.Database) { requestContent := `{ "Nameservers": [ { "host": "ns1.example.com.br.", "ipv4": "127.0.0.1" }, { "host": "ns3.example.com.br.", "ipv6": "::1" } ], "Owners": [ { "email": "*****@*****.**", "language": "en-us" } ] }` r, err := http.NewRequest("PUT", "/domain/example.com.br.", strings.NewReader(requestContent)) if err != nil { utils.Fatalln("Error creating the HTTP request", err) } domainCacheTest(database, r, requestContent, "If-None-Match", []DomainCacheTestData{ { HeaderValue: "3", ExpectedHTTPStatus: http.StatusPreconditionFailed, }, { HeaderValue: "abcdef", ExpectedHTTPStatus: http.StatusNoContent, }, }) }
func main() { flag.Parse() var clientConfig ClientDomainVerificationTestConfigFile err := utils.ReadConfigFile(configFilePath, &clientConfig) config.ShelterConfig = clientConfig.Config if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } utils.StartDNSServer(clientConfig.DNSServerPort, clientConfig.Scan.UDPMaxSize) finishRESTServer := utils.StartRESTServer() defer finishRESTServer() utils.StartWebClient() scanDomain() queryDomain() utils.Println("SUCCESS!") }
// Function to mock a domain func generateAndSaveDomain(fqdn string, domainDAO dao.DomainDAO, language string) { lastOKAt := time.Now().Add(time.Duration(-config.ShelterConfig.Notification.NameserverErrorAlertDays*24) * time.Hour) owner, _ := mail.ParseAddress("*****@*****.**") domain := model.Domain{ FQDN: fqdn, Nameservers: []model.Nameserver{ { Host: fmt.Sprintf("ns1.%s", fqdn), IPv4: net.ParseIP("127.0.0.1"), LastStatus: model.NameserverStatusServerFailure, LastOKAt: lastOKAt, }, }, Owners: []model.Owner{ { Email: owner, Language: language, }, }, } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln(fmt.Sprintf("Fail to save domain %s", domain.FQDN), err) } }
func main() { flag.Parse() var config ScanQuerierTestConfigFile err := utils.ReadConfigFile(configFilePath, &config) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } utils.StartDNSServer(config.Server.Port, config.Scan.UDPMaxSize) domainWithNoDNSErrors(config) domainWithNoDNSSECErrors(config) domainDNSTimeout(config) domainDNSUnknownHost(config) // Scan querier performance report is optional and only generated when the report file // path parameter is given if report { scanQuerierReport(config) } if inputReport { inputScanReport(config) } utils.Println("SUCCESS!") }
func createScan(database *mgo.Database) time.Time { scan := model.Scan{ Status: model.ScanStatusExecuted, StartedAt: time.Now().Add(-60 * time.Minute), FinishedAt: time.Now().Add(-10 * time.Minute), DomainsScanned: 5000000, DomainsWithDNSSECScanned: 250000, NameserverStatistics: map[string]uint64{ "OK": 4800000, "TIMEOUT": 200000, }, DSStatistics: map[string]uint64{ "OK": 220000, "EXPSIG": 30000, }, } scanDAO := dao.ScanDAO{ Database: database, } if err := scanDAO.Save(&scan); err != nil { utils.Fatalln("Error creating scan", err) } return scan.StartedAt }
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 createScans(database *mgo.Database) { scanDAO := dao.ScanDAO{ Database: database, } for i := 0; i < 100; i++ { scan := model.Scan{ Status: model.ScanStatusExecuted, StartedAt: time.Now().Add(time.Duration(-i*2) * time.Minute), FinishedAt: time.Now().Add(time.Duration(-i) * time.Minute), DomainsScanned: 5000000, DomainsWithDNSSECScanned: 250000, NameserverStatistics: map[string]uint64{ "OK": 4800000, "TIMEOUT": 200000, }, DSStatistics: map[string]uint64{ "OK": 220000, "EXPSIG": 30000, }, } if err := scanDAO.Save(&scan); err != nil { utils.Fatalln("Error creating scan", err) } } }
func updateDomainIfUnmodifiedSince(database *mgo.Database) { 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) } domainCacheTest(database, r, requestContent, "If-Unmodified-Since", []DomainCacheTestData{ { HeaderValue: "abcdef", ExpectedHTTPStatus: http.StatusBadRequest, }, { HeaderValue: time.Now().Add(-10 * time.Second).UTC().Format(time.RFC1123), ExpectedHTTPStatus: http.StatusPreconditionFailed, }, }) }
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 main() { flag.Parse() var restConfig RESTHandlerDomainVerificationTestConfigFile err := utils.ReadConfigFile(configFilePath, &restConfig) config.ShelterConfig = restConfig.Config if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( restConfig.Database.URIs, restConfig.Database.Name, false, "", "", ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() domainDAO := dao.DomainDAO{ Database: database, } // If there was some problem in the last test, there could be some data in the // database, so let's clear it to don't affect this test. We avoid checking the error, // because if the collection does not exist yet, it will be created in the first // insert domainDAO.RemoveAll() utils.StartDNSServer(restConfig.DNSServerPort, restConfig.Scan.UDPMaxSize) scanDomain() scanPersistedDomain(domainDAO) queryDomain() utils.Println("SUCCESS!") }
func main() { flag.Parse() err := utils.ReadConfigFile(configFilePath, &config.ShelterConfig) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } finishRESTServer := utils.StartRESTServer() defer finishRESTServer() utils.StartWebClient() database, databaseSession, err := mongodb.Open( config.ShelterConfig.Database.URIs, config.ShelterConfig.Database.Name, config.ShelterConfig.Database.Auth.Enabled, config.ShelterConfig.Database.Auth.Username, config.ShelterConfig.Database.Auth.Password, ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() // If there was some problem in the last test, there could be some data in the // database, so let's clear it to don't affect this test. We avoid checking the error, // because if the collection does not exist yet, it will be created in the first // insert utils.ClearDatabase(database) createScans(database) retrieveScans() retrieveScansWithPagination() retrieveScansWithCache() retrieveCurrentScan() utils.Println("SUCCESS!") }
func main() { flag.Parse() var config ScanDAOTestConfigFile err := utils.ReadConfigFile(configFilePath, &config) if err == utils.ErrConfigFileUndefined { fmt.Println(err.Error()) fmt.Println("Usage:") flag.PrintDefaults() return } else if err != nil { utils.Fatalln("Error reading configuration file", err) } database, databaseSession, err := mongodb.Open( []string{config.Database.URI}, config.Database.Name, false, "", "", ) if err != nil { utils.Fatalln("Error connecting the database", err) } defer databaseSession.Close() scanDAO := dao.ScanDAO{ Database: database, } // If there was some problem in the last test, there could be some data in the // database, so let's clear it to don't affect this test. We avoid checking the error, // because if the collection does not exist yet, it will be created in the first // insert scanDAO.RemoveAll() scanLifeCycle(scanDAO) scanConcurrency(scanDAO) scanStatistics(scanDAO) scansPagination(scanDAO) scansExpand(scanDAO) utils.Println("SUCCESS!") }
func domainFilter(domainDAO dao.DomainDAO) { numberOfItems := 20 for i := 0; i < numberOfItems; i++ { domain := model.Domain{ FQDN: fmt.Sprintf("example%d.com.br", i), } if err := domainDAO.Save(&domain); err != nil { utils.Fatalln("Error saving domain in database", err) } } pagination := dao.DomainDAOPagination{ PageSize: 10, Page: 5, OrderBy: []dao.DomainDAOSort{ { Field: dao.DomainDAOOrderByFieldFQDN, Direction: dao.DAOOrderByDirectionAscending, }, }, } domains, err := domainDAO.FindAll(&pagination, true, "example1\\.com.*") if err != nil { utils.Fatalln("Error retrieving domains", err) } if len(domains) != 1 { utils.Fatalln(fmt.Sprintf("Wrong number of domains when there's filter. "+ "Expected '1' and got '%d'", len(domains)), nil) } if domains[0].FQDN != "example1.com.br" { utils.Fatalln("Wrong domain returned", nil) } for i := 0; i < numberOfItems; i++ { fqdn := fmt.Sprintf("example%d.com.br", i) if err := domainDAO.RemoveByFQDN(fqdn); err != nil { utils.Fatalln("Error removing domain from database", err) } } }
func deleteScan(database *mgo.Database, startedAt time.Time) { scanDAO := dao.ScanDAO{ Database: database, } if err := scanDAO.RemoveByStartedAt(startedAt); err != nil { utils.Fatalln("Error removing scan", err) } }
func deleteScans(database *mgo.Database) { scanDAO := dao.ScanDAO{ Database: database, } if err := scanDAO.RemoveAll(); err != nil { utils.Fatalln("Error removing scans", err) } }
func generateAndSignDomain(fqdn string) ( model.Domain, *dns.DNSKEY, *dns.RRSIG, time.Time, time.Time, ) { dnskey, rrsig, err := utils.GenerateKSKAndSignZone(fqdn) if err != nil { utils.Fatalln("Error creating KSK DNSSEC keys and signatures", err) } ds := dnskey.ToDS(uint8(model.DSDigestTypeSHA1)) domain := model.Domain{ FQDN: fqdn, Nameservers: []model.Nameserver{ { Host: fmt.Sprintf("ns1.%s", 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, }, }, } owner, _ := mail.ParseAddress("*****@*****.**") domain.Owners = []model.Owner{ { Email: owner, Language: "pt-BR", }, } lastCheckAt := time.Now().Add(-72 * time.Hour) lastOKAt := lastCheckAt.Add(-24 * time.Hour) // Set all nameservers with error and the last check equal of the error check interval, // this will force the domain to be checked for index, _ := range domain.Nameservers { domain.Nameservers[index].LastCheckAt = lastCheckAt domain.Nameservers[index].LastOKAt = lastOKAt domain.Nameservers[index].LastStatus = model.NameserverStatusServerFailure } // Set all DS records with error and the last check equal of the error check interval, // this will force the domain to be checked for index, _ := range domain.DSSet { domain.DSSet[index].LastCheckAt = lastCheckAt domain.DSSet[index].LastOKAt = lastOKAt domain.DSSet[index].LastStatus = model.DSStatusTimeout } return domain, dnskey, rrsig, lastCheckAt, lastOKAt }
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) } }
// Generates a report with the amount of time of a scan func scanReport(domainDAO dao.DomainDAO, scanDAO dao.ScanDAO, scanConfig ScanTestConfigFile) { report := " # | Total | DPS | Memory (MB)\n" + "-----------------------------------------------------\n" // Report variables scale := []int{10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000, 1000000, 5000000} dnskey, privateKey, err := utils.GenerateKey() if err != nil { utils.Fatalln("Error generating DNSKEY", err) } reportHandler := ReportHandler{ DNSKEY: dnskey, PrivateKey: privateKey, } server.Handler = reportHandler dns.DefaultServeMux = nil for _, numberOfItems := range scale { utils.Println(fmt.Sprintf("Generating report - scale %d", numberOfItems)) for i := 0; i < numberOfItems; i++ { if i%1000 == 0 { utils.PrintProgress("building scenario", (i*100)/numberOfItems) } fqdn := fmt.Sprintf("domain%d.br.", i) generateAndSaveDomain(fqdn, domainDAO, dnskey) } utils.PrintProgress("building scenario", 100) totalDuration, domainsPerSecond := calculateScanDurations(numberOfItems, scanDAO) var memStats runtime.MemStats runtime.ReadMemStats(&memStats) report += fmt.Sprintf("% -8d | %16s | %4d | %14.2f\n", numberOfItems, time.Duration(int64(totalDuration)).String(), domainsPerSecond, float64(memStats.Alloc)/float64(MB), ) if err := domainDAO.RemoveAll(); err != nil { // When the result set is too big to remove, we got a timeout error from the // connection, but it's ok //utils.Fatalln("Error removing domains generated for report", err) } } utils.WriteReport(scanConfig.Report.File, report) }
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) } }