From 18b1529871011650b348d52e3a53fcd15771cfb6 Mon Sep 17 00:00:00 2001
From: Delecroix Gustave <114912684+57ave@users.noreply.github.com>
Date: Fri, 31 May 2024 17:04:13 +0200
Subject: [PATCH 01/35] chore: delete the template explanation

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 5845db1..2804b5a 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,3 @@
-> If you see this section, you've just created a repository using [PoC Innovation's Open-Source project template](https://github.com/PoCInnovation/open-source-project-template). Check the [getting started guide](./.github/getting-started.md).
-
 # Brut Forcer Next-Gen
 
 Brut Forcer next generation written in go

From 4f7ca8af0bb02220d7ddf81f723efa7cb6d81049 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Mon, 24 Jun 2024 17:24:40 +0200
Subject: [PATCH 02/35] feat(match): test parse arg to proceed with match
 option

---
 src/main.go | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/main.go b/src/main.go
index 6ffde47..165cd0b 100644
--- a/src/main.go
+++ b/src/main.go
@@ -1,9 +1,30 @@
 package main
 
 import (
+	"flag"
+	"log"
 	"fmt"
+	// "BruteForce/src/matcher"
+)
+
+var (
+    WarningLogger *log.Logger
+    InfoLogger    *log.Logger
+    ErrorLogger   *log.Logger
 )
 
 func main() {
-	fmt.Println("Hello World")
+	matchPtr := flag.String("match", "", "a string")
+	usagePtr := flag.Bool("help", false, "a bool")
+
+	flag.Parse()
+	if *usagePtr {
+		fmt.Println("Usage: use flag match=<option>")
+		return;
+	}
+	if *matchPtr != "" {
+		log.Println("match:", *matchPtr)
+		return;
+	}
+	log.Println("No match indicated.")
 }

From 1ab304d1aadb5abda6223e044b9dab60599e1780 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 25 Jun 2024 15:17:13 +0200
Subject: [PATCH 03/35] featt(matcher): main architect for initiation parsed
 matching options

---
 go.mod                  |  2 +-
 src/main.go             | 15 +++++----------
 src/matching/matcher.go |  7 +++++++
 3 files changed, 13 insertions(+), 11 deletions(-)
 create mode 100644 src/matching/matcher.go

diff --git a/go.mod b/go.mod
index 2c08b2c..a88057d 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
-module BruteForce
+module bruteforce
 
 go 1.19
diff --git a/src/main.go b/src/main.go
index 165cd0b..43696f0 100644
--- a/src/main.go
+++ b/src/main.go
@@ -4,13 +4,7 @@ import (
 	"flag"
 	"log"
 	"fmt"
-	// "BruteForce/src/matcher"
-)
-
-var (
-    WarningLogger *log.Logger
-    InfoLogger    *log.Logger
-    ErrorLogger   *log.Logger
+	"bruteforce/src/matching"
 )
 
 func main() {
@@ -20,11 +14,12 @@ func main() {
 	flag.Parse()
 	if *usagePtr {
 		fmt.Println("Usage: use flag match=<option>")
+		fmt.Println("	option	status[100-599|all]")
 		return;
 	}
 	if *matchPtr != "" {
-		log.Println("match:", *matchPtr)
-		return;
+		matcher.MatchParser(*matchPtr)
+	} else {
+		log.Fatal("No match indicated.")
 	}
-	log.Println("No match indicated.")
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
new file mode 100644
index 0000000..d7acb2c
--- /dev/null
+++ b/src/matching/matcher.go
@@ -0,0 +1,7 @@
+package matcher
+
+import "fmt"
+
+func MatchParser(matchType string) {
+	fmt.Println("matching option:", matchType)
+}

From b3158a4ca837e99ecbce8cbe6440f2c76e5b4e16 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 25 Jun 2024 16:36:41 +0200
Subject: [PATCH 04/35] feat(matcher): parse through status code as argument

prase and match functions
---
 src/main.go             | 15 +++++-------
 src/matching/matcher.go | 51 ++++++++++++++++++++++++++++++++++++++---
 2 files changed, 54 insertions(+), 12 deletions(-)

diff --git a/src/main.go b/src/main.go
index 43696f0..9ef54a6 100644
--- a/src/main.go
+++ b/src/main.go
@@ -2,24 +2,21 @@ package main
 
 import (
 	"flag"
-	"log"
 	"fmt"
 	"bruteforce/src/matching"
 )
 
 func main() {
-	matchPtr := flag.String("match", "", "a string")
 	usagePtr := flag.Bool("help", false, "a bool")
+	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
 
 	flag.Parse()
 	if *usagePtr {
-		fmt.Println("Usage: use flag match=<option>")
-		fmt.Println("	option	status[100-599|all]")
+		fmt.Println("Usage for matching options:\n\nuse flag -status-codes=\"<status-options>\"")
+		fmt.Println("\tstatus-options\t200,202,400,404 (Comma-separated list)")
+		fmt.Println("\t\t\tall")
+		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
 		return;
 	}
-	if *matchPtr != "" {
-		matcher.MatchParser(*matchPtr)
-	} else {
-		log.Fatal("No match indicated.")
-	}
+	matcher.MatchParser(*statusPtr)
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index d7acb2c..982c024 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -1,7 +1,52 @@
 package matcher
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+	"log"
+	"net/http"
+)
 
-func MatchParser(matchType string) {
-	fmt.Println("matching option:", matchType)
+func matchStatusCode(url string, matchCodes []int) (bool, string) {
+    resp, err := http.Get(url)
+    if err != nil {
+        return false, ""
+    }
+    defer resp.Body.Close()
+
+    for _, code := range matchCodes {
+        if resp.StatusCode == code {
+            return true, fmt.Sprintf("Status Code: %d", code)
+        }
+    }
+    return false, fmt.Sprintf("Status Code: %d", resp.StatusCode)
+}
+
+func parseStatusCodes(statusCodeList string) ([]int, error) {
+    codeStrs := strings.Split(statusCodeList, ",")
+    var codes []int
+    for _, codeStr := range codeStrs {
+        var code int
+		if _, err := fmt.Sscanf(codeStr, "%d", &code); err != nil {
+            return nil, err
+        }
+		if code < 600 && code >= 100 {
+        	codes = append(codes, code)
+		} else {
+			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
+		}
+    }
+	if len(codes) == 1 && codes[0] == 0 {
+		return nil, fmt.Errorf("no valid status code given")
+	}
+    return codes, nil
+}
+
+func MatchParser(statuses string) {
+	log.Println("Matching using the following status codes:", statuses)
+	matchCodes, err := parseStatusCodes(statuses)
+	if err != nil {
+        log.Fatal("Error parsing status codes:", err)
+    }
+	log.Println("Matching status codes:", matchCodes)
 }

From 8f0ce4725c0b41274be7efb5d33243eb4bce900b Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 25 Jun 2024 17:30:10 +0200
Subject: [PATCH 05/35] feat(match-doc): add usage to read me to be more user
 friendly

---
 README.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 68e6395..470f49c 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,17 @@ go run src/main.go
 
 ### Usage
 
-No usage so far
+```bash
+./bruteforce [OPTIONS]
+```
+
+### Matching
+
+For matching usage, the following flags are available:
+
+`-status-codes` : match based on a list of status codes.
+
+For example, `bruteforce -status-codes="200,201,202,401,404". By default : 200, 401, 403, 404, 429, 500
 
 ## Get involved
 

From 4413b02a6333ac6ddfdcb964c30466637a60dc07 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Tue, 25 Jun 2024 23:17:29 +0200
Subject: [PATCH 06/35] feat(cmd): function create to parse wordlist file line
 by line

---
 cmd/getFile.go | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 cmd/getFile.go

diff --git a/cmd/getFile.go b/cmd/getFile.go
new file mode 100644
index 0000000..01d14cc
--- /dev/null
+++ b/cmd/getFile.go
@@ -0,0 +1,16 @@
+import (
+    "os"
+    "fmt"
+    "log"
+	"strings"
+)
+
+func GetFileContent(filePath string) []string{
+    body, err := os.ReadFile(filePath)
+    if err != nil {
+        log.Fatalf("unable to read file: %v", err)
+    }
+	dataTab := strings.Split(string(body), "\n")
+    fmt.Println(dataTab[0])
+	return dataTab
+}
\ No newline at end of file

From 38ea84509e3c3cad5031576be0941a1bb3a8d678 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Tue, 25 Jun 2024 23:20:39 +0200
Subject: [PATCH 07/35] feat(cmd): function to create channel and assign worker

---
 cmd/callWorker.go | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 cmd/callWorker.go

diff --git a/cmd/callWorker.go b/cmd/callWorker.go
new file mode 100644
index 0000000..1242de9
--- /dev/null
+++ b/cmd/callWorker.go
@@ -0,0 +1,35 @@
+
+import (
+  "fmt"
+  "time"
+  "strings"
+)
+
+type forceData struct {
+	worker int
+	wordList string
+	url string
+}
+
+func executeQueryFromFile(filePathQuery []string, filePathRoot chan string, worker int) {
+  for eachtask := range filePathRoot {
+    for i := 0 ; i < worker ; i++ {
+      fmt.Println(splitData)
+    }
+  }
+}
+
+func mainRequest(worker int) {
+  channel := make(chan string)
+  wordArray := GetFileContent("./wordList/rootList")
+
+  for i := 0 ;i < len(data_tab); i++ {
+		go executeQueryFromFile(wordArray, channel)
+	}
+
+  for i := 0; i < len(data_tab); i++ {
+    channel <- data_tab[i]
+  }
+  time.Sleep(1 * time.Second)
+  close(channel)
+}

From 9daf216253d5eb2781cbe18c2b57c8d3714b040a Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Thu, 27 Jun 2024 22:07:57 +0200
Subject: [PATCH 08/35] refactor(matcher): separate different matching types
 from main MatchParser

---
 src/main.go                  |  2 +-
 src/matching/matcher.go      | 50 ++++++++----------------------------
 src/matching/status_codes.go | 43 +++++++++++++++++++++++++++++++
 3 files changed, 54 insertions(+), 41 deletions(-)
 create mode 100644 src/matching/status_codes.go

diff --git a/src/main.go b/src/main.go
index 9ef54a6..efa588f 100644
--- a/src/main.go
+++ b/src/main.go
@@ -18,5 +18,5 @@ func main() {
 		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
 		return;
 	}
-	matcher.MatchParser(*statusPtr)
+	matcher.MatchParser("http://example.com", *statusPtr)
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 982c024..134d120 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -1,52 +1,22 @@
 package matcher
 
 import (
-	"fmt"
-	"strings"
 	"log"
-	"net/http"
 )
 
-func matchStatusCode(url string, matchCodes []int) (bool, string) {
-    resp, err := http.Get(url)
-    if err != nil {
-        return false, ""
-    }
-    defer resp.Body.Close()
-
-    for _, code := range matchCodes {
-        if resp.StatusCode == code {
-            return true, fmt.Sprintf("Status Code: %d", code)
-        }
-    }
-    return false, fmt.Sprintf("Status Code: %d", resp.StatusCode)
-}
-
-func parseStatusCodes(statusCodeList string) ([]int, error) {
-    codeStrs := strings.Split(statusCodeList, ",")
-    var codes []int
-    for _, codeStr := range codeStrs {
-        var code int
-		if _, err := fmt.Sscanf(codeStr, "%d", &code); err != nil {
-            return nil, err
-        }
-		if code < 600 && code >= 100 {
-        	codes = append(codes, code)
-		} else {
-			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
-		}
-    }
-	if len(codes) == 1 && codes[0] == 0 {
-		return nil, fmt.Errorf("no valid status code given")
-	}
-    return codes, nil
-}
-
-func MatchParser(statuses string) {
+func MatchParser(url string, statuses string) {
 	log.Println("Matching using the following status codes:", statuses)
+
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
         log.Fatal("Error parsing status codes:", err)
     }
-	log.Println("Matching status codes:", matchCodes)
+	log.Printf("Matching status codes %d...", matchCodes)
+
+    matched, msg := matchStatusCode(url, matchCodes)
+    if matched {
+        log.Println("Matched:", msg)
+    } else {
+        log.Println("Not matched:", msg)
+    }
 }
diff --git a/src/matching/status_codes.go b/src/matching/status_codes.go
new file mode 100644
index 0000000..addb77b
--- /dev/null
+++ b/src/matching/status_codes.go
@@ -0,0 +1,43 @@
+package matcher
+
+import (
+	"fmt"
+	"strings"
+	"net/http"
+)
+
+
+func matchStatusCode(url string, matchCodes []int) (bool, string) {
+    resp, err := http.Get(url)
+    if err != nil {
+        return false, ""
+    }
+    defer resp.Body.Close()
+
+    for _, code := range matchCodes {
+        if resp.StatusCode == code {
+            return true, fmt.Sprintf("status code is %d", code)
+        }
+    }
+    return false, fmt.Sprintf("status code is %d", resp.StatusCode)
+}
+
+func parseStatusCodes(statusCodeList string) ([]int, error) {
+    codeStrs := strings.Split(statusCodeList, ",")
+    var codes []int
+    for _, codeStr := range codeStrs {
+        var code int
+		if _, err := fmt.Sscanf(codeStr, "%d", &code); err != nil {
+            return nil, err
+        }
+		if code < 600 && code >= 100 {
+        	codes = append(codes, code)
+		} else {
+			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
+		}
+    }
+	if len(codes) == 1 && codes[0] == 0 {
+		return nil, fmt.Errorf("no valid status code given")
+	}
+    return codes, nil
+}

From 957b4e4e725aae191f36d60df5d4c8f972491eda Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Thu, 27 Jun 2024 22:09:48 +0200
Subject: [PATCH 09/35] fix(matcher): forward Get request from net/http in
 match

---
 README.md                    | 4 +++-
 src/main.go                  | 2 +-
 src/matching/status_codes.go | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 470f49c..2ec94a5 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,9 @@ For matching usage, the following flags are available:
 
 `-status-codes` : match based on a list of status codes.
 
-For example, `bruteforce -status-codes="200,201,202,401,404". By default : 200, 401, 403, 404, 429, 500
+For example, `./bruteforce -status-codes="200,201,202,401,404"`.
+
+*By default* : 200, 401, 403, 404, 429, 500
 
 ## Get involved
 
diff --git a/src/main.go b/src/main.go
index efa588f..4937f38 100644
--- a/src/main.go
+++ b/src/main.go
@@ -18,5 +18,5 @@ func main() {
 		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
 		return;
 	}
-	matcher.MatchParser("http://example.com", *statusPtr)
+	matcher.MatchParser("http://r.com", *statusPtr)
 }
diff --git a/src/matching/status_codes.go b/src/matching/status_codes.go
index addb77b..fa4b997 100644
--- a/src/matching/status_codes.go
+++ b/src/matching/status_codes.go
@@ -10,7 +10,7 @@ import (
 func matchStatusCode(url string, matchCodes []int) (bool, string) {
     resp, err := http.Get(url)
     if err != nil {
-        return false, ""
+        return false, err.Error()
     }
     defer resp.Body.Close()
 

From fa7f27f49081d3b0bb1f2d8c2cf2bdcf083a548f Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Fri, 28 Jun 2024 18:33:12 +0200
Subject: [PATCH 10/35] build: add package main to file

---
 cmd/getFile.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cmd/getFile.go b/cmd/getFile.go
index 01d14cc..7accbb0 100644
--- a/cmd/getFile.go
+++ b/cmd/getFile.go
@@ -1,3 +1,5 @@
+package main
+
 import (
     "os"
     "fmt"

From fcb8c2f13abc8e8ed48593040820bee9c1278cfc Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Fri, 28 Jun 2024 18:36:48 +0200
Subject: [PATCH 11/35] feat(cmd): implement worker correctly task depend now
 on it

---
 cmd/callWorker.go | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/cmd/callWorker.go b/cmd/callWorker.go
index 1242de9..25ed72e 100644
--- a/cmd/callWorker.go
+++ b/cmd/callWorker.go
@@ -1,8 +1,8 @@
+package main
 
 import (
   "fmt"
   "time"
-  "strings"
 )
 
 type forceData struct {
@@ -11,25 +11,26 @@ type forceData struct {
 	url string
 }
 
-func executeQueryFromFile(filePathQuery []string, filePathRoot chan string, worker int) {
-  for eachtask := range filePathRoot {
-    for i := 0 ; i < worker ; i++ {
-      fmt.Println(splitData)
-    }
+func executeQueryFromFile(currentPath chan string) {
+  for eachtask := range currentPath{
+      fmt.Printf("eachtask %s \n", eachtask)
   }
 }
 
 func mainRequest(worker int) {
   channel := make(chan string)
-  wordArray := GetFileContent("./wordList/rootList")
+  wordArray := GetFileContent("../wordList/rootList")
 
-  for i := 0 ;i < len(data_tab); i++ {
-		go executeQueryFromFile(wordArray, channel)
+  for i := 0 ;i < worker; i++ {
+		go executeQueryFromFile(channel)
 	}
-
-  for i := 0; i < len(data_tab); i++ {
-    channel <- data_tab[i]
+  for i := 0; i < len(wordArray); i++ {
+    channel <- wordArray[i]
   }
   time.Sleep(1 * time.Second)
   close(channel)
 }
+
+func main () {
+  mainRequest(3);
+}
\ No newline at end of file

From 5a93954c197dada8ceb60736f9e84ed2d10aff59 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Fri, 28 Jun 2024 18:45:21 +0200
Subject: [PATCH 12/35] feat(cmd): add execute query file and call it in
 routine

---
 cmd/callWorker.go   |  7 +++----
 cmd/queryExecute.go | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 4 deletions(-)
 create mode 100644 cmd/queryExecute.go

diff --git a/cmd/callWorker.go b/cmd/callWorker.go
index 25ed72e..02721d7 100644
--- a/cmd/callWorker.go
+++ b/cmd/callWorker.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-  "fmt"
   "time"
 )
 
@@ -12,9 +11,9 @@ type forceData struct {
 }
 
 func executeQueryFromFile(currentPath chan string) {
-  for eachtask := range currentPath{
-      fmt.Printf("eachtask %s \n", eachtask)
-  }
+  for taskData := range currentPath{
+    queryExecute(taskData, "POST")
+    }
 }
 
 func mainRequest(worker int) {
diff --git a/cmd/queryExecute.go b/cmd/queryExecute.go
new file mode 100644
index 0000000..8a8c245
--- /dev/null
+++ b/cmd/queryExecute.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"io/ioutil"
+	"net/http"
+)
+
+func queryExecute(path string, method string) {
+
+	client := &http.Client{}
+	req, err := http.NewRequest(method, "http://localhost:3333" + path, nil)
+	if err != nil {
+	  log.Fatal(err)
+	}
+
+	q := req.URL.Query()
+
+	req.URL.RawQuery = q.Encode()
+
+	resp, err := client.Do(req)
+	if err != nil {
+	  fmt.Println(err)
+	}
+
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+	  log.Fatal(err)
+	}
+
+	fmt.Println(string(body))
+  }
\ No newline at end of file

From 681cde157229c30713c457fc24a3fa4b621ad161 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Fri, 28 Jun 2024 19:03:56 +0200
Subject: [PATCH 13/35] feat(cmd): implement struct forceData with neccesary
 data for brutforcer's request

---
 cmd/callWorker.go   | 17 +++++++++++------
 cmd/queryExecute.go |  4 ++--
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/cmd/callWorker.go b/cmd/callWorker.go
index 02721d7..4c9d7d3 100644
--- a/cmd/callWorker.go
+++ b/cmd/callWorker.go
@@ -10,18 +10,18 @@ type forceData struct {
 	url string
 }
 
-func executeQueryFromFile(currentPath chan string) {
+func executeQueryFromFile(data forceData, currentPath chan string) {
   for taskData := range currentPath{
-    queryExecute(taskData, "POST")
+    queryExecute(data, taskData, "POST")
     }
 }
 
-func mainRequest(worker int) {
+func mainRequest(data forceData) {
   channel := make(chan string)
   wordArray := GetFileContent("../wordList/rootList")
 
-  for i := 0 ;i < worker; i++ {
-		go executeQueryFromFile(channel)
+  for i := 0 ;i < data.worker; i++ {
+		go executeQueryFromFile(data, channel)
 	}
   for i := 0; i < len(wordArray); i++ {
     channel <- wordArray[i]
@@ -31,5 +31,10 @@ func mainRequest(worker int) {
 }
 
 func main () {
-  mainRequest(3);
+  data := forceData {
+    worker: 3,
+    wordList: "../wordList/rootList",
+    url: "http://localhost:3333",
+  }
+  mainRequest(data);
 }
\ No newline at end of file
diff --git a/cmd/queryExecute.go b/cmd/queryExecute.go
index 8a8c245..42b7021 100644
--- a/cmd/queryExecute.go
+++ b/cmd/queryExecute.go
@@ -7,10 +7,10 @@ import (
 	"net/http"
 )
 
-func queryExecute(path string, method string) {
+func queryExecute(data forceData, path string, method string) {
 
 	client := &http.Client{}
-	req, err := http.NewRequest(method, "http://localhost:3333" + path, nil)
+	req, err := http.NewRequest(method, data.url + path, nil)
 	if err != nil {
 	  log.Fatal(err)
 	}

From 18834ea50f1faf2f9e98db7c560c7e60d8cb8d72 Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Thu, 4 Jul 2024 16:55:25 +0200
Subject: [PATCH 14/35] feat: cli arguments handling

---
 src/cli/cli.go       | 23 +++++++++++++++++++++++
 src/main.go          |  8 +++++++-
 src/models/models.go | 11 +++++++++++
 3 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 src/cli/cli.go
 create mode 100644 src/models/models.go

diff --git a/src/cli/cli.go b/src/cli/cli.go
new file mode 100644
index 0000000..caf3330
--- /dev/null
+++ b/src/cli/cli.go
@@ -0,0 +1,23 @@
+package cli
+
+import (
+	"bruteforce/src/models"
+	"errors"
+	"flag"
+)
+
+func Parse_cli_args() (models.Forcing_params, error) {
+	var params models.Forcing_params
+	myError := errors.New("Wrong parameters")
+	forkptr := flag.Bool("v", false, "Verbose program")
+
+	flag.IntVar(&params.Threads, "threads", 1, "Number of threads to be used")
+	flag.Parse()
+
+	if len(flag.Args()) != 1 {
+		return params, myError
+	}
+	params.Url = flag.Args()[0]
+	params.BoolFlags.Verbose = *forkptr
+	return params, nil
+}
diff --git a/src/main.go b/src/main.go
index 6ffde47..24e3727 100644
--- a/src/main.go
+++ b/src/main.go
@@ -1,9 +1,15 @@
 package main
 
 import (
+	"bruteforce/src/cli"
 	"fmt"
 )
 
 func main() {
-	fmt.Println("Hello World")
+	forcing_params, err := cli.Parse_cli_args()
+
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(forcing_params)
 }
diff --git a/src/models/models.go b/src/models/models.go
new file mode 100644
index 0000000..69c4085
--- /dev/null
+++ b/src/models/models.go
@@ -0,0 +1,11 @@
+package models
+
+type boolflags struct {
+	Verbose bool
+}
+
+type Forcing_params struct {
+	Threads   int
+	Url       string
+	BoolFlags boolflags
+}

From 67fbe65cf821a439c3aeabe0bf68b55fc2610a7a Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Mon, 15 Jul 2024 16:10:07 +0200
Subject: [PATCH 15/35] fix: handle all status codes as option

---
 src/main.go                  |  2 +-
 src/matching/matcher.go      |  3 ---
 src/matching/status_codes.go | 18 ++++++++++++++++--
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/main.go b/src/main.go
index 4937f38..efa588f 100644
--- a/src/main.go
+++ b/src/main.go
@@ -18,5 +18,5 @@ func main() {
 		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
 		return;
 	}
-	matcher.MatchParser("http://r.com", *statusPtr)
+	matcher.MatchParser("http://example.com", *statusPtr)
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 134d120..ce6b834 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -5,13 +5,10 @@ import (
 )
 
 func MatchParser(url string, statuses string) {
-	log.Println("Matching using the following status codes:", statuses)
-
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
         log.Fatal("Error parsing status codes:", err)
     }
-	log.Printf("Matching status codes %d...", matchCodes)
 
     matched, msg := matchStatusCode(url, matchCodes)
     if matched {
diff --git a/src/matching/status_codes.go b/src/matching/status_codes.go
index fa4b997..68354c5 100644
--- a/src/matching/status_codes.go
+++ b/src/matching/status_codes.go
@@ -4,19 +4,26 @@ import (
 	"fmt"
 	"strings"
 	"net/http"
+    "log"
 )
 
 
 func matchStatusCode(url string, matchCodes []int) (bool, string) {
+    isAll := false
     resp, err := http.Get(url)
     if err != nil {
         return false, err.Error()
     }
     defer resp.Body.Close()
 
+    if matchCodes[0] == 0 {
+        isAll = !isAll;
+    } else {
+        log.Printf("Matching status codes %d...", matchCodes)
+    }
     for _, code := range matchCodes {
-        if resp.StatusCode == code {
-            return true, fmt.Sprintf("status code is %d", code)
+        if resp.StatusCode == code  || isAll {
+            return true, fmt.Sprintf("status code is %d", resp.StatusCode)
         }
     }
     return false, fmt.Sprintf("status code is %d", resp.StatusCode)
@@ -24,6 +31,12 @@ func matchStatusCode(url string, matchCodes []int) (bool, string) {
 
 func parseStatusCodes(statusCodeList string) ([]int, error) {
     codeStrs := strings.Split(statusCodeList, ",")
+
+    if statusCodeList == "all" {
+        log.Println("Matching all status codes")
+        return []int{0}, nil
+    }
+
     var codes []int
     for _, codeStr := range codeStrs {
         var code int
@@ -36,6 +49,7 @@ func parseStatusCodes(statusCodeList string) ([]int, error) {
 			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
 		}
     }
+
 	if len(codes) == 1 && codes[0] == 0 {
 		return nil, fmt.Errorf("no valid status code given")
 	}

From 80bb47e63f9fa14bc0c8b2589e542fae0cfba6f8 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 16 Jul 2024 14:08:23 +0200
Subject: [PATCH 16/35] feat: add matching for headers and body

---
 README.md                    |  8 ++++++++
 src/main.go                  |  4 +++-
 src/matching/body.go         | 10 +++++++++
 src/matching/headers.go      | 36 +++++++++++++++++++++++++++++++++
 src/matching/matcher.go      | 39 ++++++++++++++++++++++++++++++++++--
 src/matching/status_codes.go |  9 +--------
 6 files changed, 95 insertions(+), 11 deletions(-)
 create mode 100644 src/matching/body.go
 create mode 100644 src/matching/headers.go

diff --git a/README.md b/README.md
index 2ec94a5..80b8046 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,14 @@ For example, `./bruteforce -status-codes="200,201,202,401,404"`.
 
 *By default* : 200, 401, 403, 404, 429, 500
 
+`-header` : match based on a header.
+
+For example, `./bruteforce -header="Content-Type: application/json"`.
+
+`-body` : match based on a body.
+
+For example, `./bruteforce -body="Hello World"`.
+
 ## Get involved
 
 You're invited to join this project ! Check out the [contributing guide](./CONTRIBUTING.md).
diff --git a/src/main.go b/src/main.go
index efa588f..8dd2027 100644
--- a/src/main.go
+++ b/src/main.go
@@ -9,6 +9,8 @@ import (
 func main() {
 	usagePtr := flag.Bool("help", false, "a bool")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
+	headerPtr := flag.String("header", "", "Header to match")
+	bodyPtr := flag.String("body", "", "String to match in response body")
 
 	flag.Parse()
 	if *usagePtr {
@@ -18,5 +20,5 @@ func main() {
 		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
 		return;
 	}
-	matcher.MatchParser("http://example.com", *statusPtr)
+	matcher.MatchParser("http://example.com", *statusPtr, *headerPtr, *bodyPtr)
 }
diff --git a/src/matching/body.go b/src/matching/body.go
new file mode 100644
index 0000000..54a1dce
--- /dev/null
+++ b/src/matching/body.go
@@ -0,0 +1,10 @@
+package matcher
+
+import "strings"
+
+func matchContents(body []byte, criteria MatchCriteria) (bool, string) {
+	if criteria.BodyContains != "" && !strings.Contains(string(body), criteria.BodyContains) {
+		return false, "body content mismatch"
+	}
+	return true, "body content matches"
+}
diff --git a/src/matching/headers.go b/src/matching/headers.go
new file mode 100644
index 0000000..1514f37
--- /dev/null
+++ b/src/matching/headers.go
@@ -0,0 +1,36 @@
+package matcher
+
+import (
+	"fmt"
+	"strings"
+	"net/http"
+	"log"
+)
+
+func matchHeaders(resp *http.Response, criteria MatchCriteria) (bool, string) {
+	for key, value := range criteria.Headers {
+		if resp.Header.Get(key) != value {
+			return false, fmt.Sprintf("header mismatch: %s=%s", key, value)
+		}
+	}
+	return true, "headers match"
+}
+
+func parseHeaders(headersList string) map[string]string {
+	if headersList == "" {
+		return nil
+	}
+
+	headers := make(map[string]string)
+	headerPairs := strings.Split(headersList, ",")
+
+	for _, pair := range headerPairs {
+		parts := strings.SplitN(pair, ":", 2)
+		if len(parts) == 2 {
+			headers[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+		} else {
+			log.Printf("[WARN] Invalid header format: %s", pair)
+		}
+	}
+	return headers
+}
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index ce6b834..46ef078 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -2,15 +2,50 @@ package matcher
 
 import (
 	"log"
+    "io/ioutil"
+    "fmt"
+    "net/http"
 )
 
-func MatchParser(url string, statuses string) {
+type MatchCriteria struct {
+	StatusCodes  []int
+	Headers      map[string]string
+	BodyContains string
+}
+
+func matchResponse(url string, criteria MatchCriteria) (bool, string) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return false, err.Error()
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return false, err.Error()
+	}
+
+	matchStatusCode(resp, criteria.StatusCodes)
+	matchHeaders(resp, criteria)
+	matchContents(body, criteria)
+
+	return false, fmt.Sprintf("status code is %d", resp.StatusCode)
+}
+
+func MatchParser(url string, statuses string, headers string, bodyContains string) {
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
         log.Fatal("Error parsing status codes:", err)
     }
 
-    matched, msg := matchStatusCode(url, matchCodes)
+	matchHeaders := parseHeaders(headers)
+	criteria := MatchCriteria{
+		StatusCodes:  matchCodes,
+		Headers:      matchHeaders,
+		BodyContains: bodyContains,
+	}
+
+	matched, msg := matchResponse(url, criteria)
     if matched {
         log.Println("Matched:", msg)
     } else {
diff --git a/src/matching/status_codes.go b/src/matching/status_codes.go
index 68354c5..732b2d9 100644
--- a/src/matching/status_codes.go
+++ b/src/matching/status_codes.go
@@ -7,14 +7,8 @@ import (
     "log"
 )
 
-
-func matchStatusCode(url string, matchCodes []int) (bool, string) {
+func matchStatusCode(resp *http.Response, matchCodes []int) (bool, string) {
     isAll := false
-    resp, err := http.Get(url)
-    if err != nil {
-        return false, err.Error()
-    }
-    defer resp.Body.Close()
 
     if matchCodes[0] == 0 {
         isAll = !isAll;
@@ -31,7 +25,6 @@ func matchStatusCode(url string, matchCodes []int) (bool, string) {
 
 func parseStatusCodes(statusCodeList string) ([]int, error) {
     codeStrs := strings.Split(statusCodeList, ",")
-
     if statusCodeList == "all" {
         log.Println("Matching all status codes")
         return []int{0}, nil

From 075062f054de0d7675192d67b654157acc6dabd2 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 16 Jul 2024 15:09:13 +0200
Subject: [PATCH 17/35] style: refactor code and make sure each match quit

---
 src/main.go                  |  6 +++--
 src/matching/headers.go      |  6 ++---
 src/matching/matcher.go      | 39 ++++++++++++++++++----------
 src/matching/status.go       | 50 ++++++++++++++++++++++++++++++++++++
 src/matching/status_codes.go | 50 ------------------------------------
 5 files changed, 82 insertions(+), 69 deletions(-)
 create mode 100644 src/matching/status.go
 delete mode 100644 src/matching/status_codes.go

diff --git a/src/main.go b/src/main.go
index 8dd2027..55a5ba3 100644
--- a/src/main.go
+++ b/src/main.go
@@ -1,9 +1,9 @@
 package main
 
 import (
+	"bruteforce/src/matching"
 	"flag"
 	"fmt"
-	"bruteforce/src/matching"
 )
 
 func main() {
@@ -18,7 +18,9 @@ func main() {
 		fmt.Println("\tstatus-options\t200,202,400,404 (Comma-separated list)")
 		fmt.Println("\t\t\tall")
 		fmt.Println("\t\t\t[By default: 200,401,403,404,429,500]")
-		return;
+		fmt.Println("\nuse flag -header=\"<key:value>\"")
+		fmt.Println("use flag -body=\"<string-in-body>\"")
+		return
 	}
 	matcher.MatchParser("http://example.com", *statusPtr, *headerPtr, *bodyPtr)
 }
diff --git a/src/matching/headers.go b/src/matching/headers.go
index 1514f37..54431f1 100644
--- a/src/matching/headers.go
+++ b/src/matching/headers.go
@@ -2,15 +2,15 @@ package matcher
 
 import (
 	"fmt"
-	"strings"
-	"net/http"
 	"log"
+	"net/http"
+	"strings"
 )
 
 func matchHeaders(resp *http.Response, criteria MatchCriteria) (bool, string) {
 	for key, value := range criteria.Headers {
 		if resp.Header.Get(key) != value {
-			return false, fmt.Sprintf("header mismatch: %s=%s", key, value)
+			return false, fmt.Sprintf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
 		}
 	}
 	return true, "headers match"
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 46ef078..24ff9bd 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -1,10 +1,9 @@
 package matcher
 
 import (
+	"io/ioutil"
 	"log"
-    "io/ioutil"
-    "fmt"
-    "net/http"
+	"net/http"
 )
 
 type MatchCriteria struct {
@@ -14,6 +13,9 @@ type MatchCriteria struct {
 }
 
 func matchResponse(url string, criteria MatchCriteria) (bool, string) {
+	status := true
+	matchError := ""
+
 	resp, err := http.Get(url)
 	if err != nil {
 		return false, err.Error()
@@ -25,18 +27,27 @@ func matchResponse(url string, criteria MatchCriteria) (bool, string) {
 		return false, err.Error()
 	}
 
-	matchStatusCode(resp, criteria.StatusCodes)
-	matchHeaders(resp, criteria)
-	matchContents(body, criteria)
+	status, matchError = matchStatusCode(resp, criteria.StatusCodes)
+	if !status {
+		return false, matchError
+	}
+	status, matchError = matchHeaders(resp, criteria)
+	if !status {
+		return false, matchError
+	}
+	status, matchError = matchContents(body, criteria)
+	if !status {
+		return false, matchError
+	}
 
-	return false, fmt.Sprintf("status code is %d", resp.StatusCode)
+	return true, "Matched successfully for " + url
 }
 
 func MatchParser(url string, statuses string, headers string, bodyContains string) {
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
-        log.Fatal("Error parsing status codes:", err)
-    }
+		log.Fatal("Error parsing status codes:", err)
+	}
 
 	matchHeaders := parseHeaders(headers)
 	criteria := MatchCriteria{
@@ -46,9 +57,9 @@ func MatchParser(url string, statuses string, headers string, bodyContains strin
 	}
 
 	matched, msg := matchResponse(url, criteria)
-    if matched {
-        log.Println("Matched:", msg)
-    } else {
-        log.Println("Not matched:", msg)
-    }
+	if matched {
+		log.Println("Matched:", msg)
+	} else {
+		log.Println("Not matched:", msg)
+	}
 }
diff --git a/src/matching/status.go b/src/matching/status.go
new file mode 100644
index 0000000..5a004a9
--- /dev/null
+++ b/src/matching/status.go
@@ -0,0 +1,50 @@
+package matcher
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func matchStatusCode(resp *http.Response, matchCodes []int) (bool, string) {
+	isAll := false
+
+	if matchCodes[0] == 0 {
+		isAll = !isAll
+	} else {
+		log.Printf("Matching status codes %d...", matchCodes)
+	}
+	for _, code := range matchCodes {
+		if resp.StatusCode == code || isAll {
+			return true, fmt.Sprintf("status code is %d", resp.StatusCode)
+		}
+	}
+	return false, fmt.Sprintf("status code is %d", resp.StatusCode)
+}
+
+func parseStatusCodes(statusCodeList string) ([]int, error) {
+	codeStrs := strings.Split(statusCodeList, ",")
+	if statusCodeList == "all" {
+		log.Println("Matching all status codes")
+		return []int{0}, nil
+	}
+
+	var codes []int
+	for _, codeStr := range codeStrs {
+		var code int
+		if _, err := fmt.Sscanf(codeStr, "%d", &code); err != nil {
+			return nil, err
+		}
+		if code < 600 && code >= 100 {
+			codes = append(codes, code)
+		} else {
+			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
+		}
+	}
+
+	if len(codes) == 1 && codes[0] == 0 {
+		return nil, fmt.Errorf("no valid status code given")
+	}
+	return codes, nil
+}
diff --git a/src/matching/status_codes.go b/src/matching/status_codes.go
deleted file mode 100644
index 732b2d9..0000000
--- a/src/matching/status_codes.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package matcher
-
-import (
-	"fmt"
-	"strings"
-	"net/http"
-    "log"
-)
-
-func matchStatusCode(resp *http.Response, matchCodes []int) (bool, string) {
-    isAll := false
-
-    if matchCodes[0] == 0 {
-        isAll = !isAll;
-    } else {
-        log.Printf("Matching status codes %d...", matchCodes)
-    }
-    for _, code := range matchCodes {
-        if resp.StatusCode == code  || isAll {
-            return true, fmt.Sprintf("status code is %d", resp.StatusCode)
-        }
-    }
-    return false, fmt.Sprintf("status code is %d", resp.StatusCode)
-}
-
-func parseStatusCodes(statusCodeList string) ([]int, error) {
-    codeStrs := strings.Split(statusCodeList, ",")
-    if statusCodeList == "all" {
-        log.Println("Matching all status codes")
-        return []int{0}, nil
-    }
-
-    var codes []int
-    for _, codeStr := range codeStrs {
-        var code int
-		if _, err := fmt.Sscanf(codeStr, "%d", &code); err != nil {
-            return nil, err
-        }
-		if code < 600 && code >= 100 {
-        	codes = append(codes, code)
-		} else {
-			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
-		}
-    }
-
-	if len(codes) == 1 && codes[0] == 0 {
-		return nil, fmt.Errorf("no valid status code given")
-	}
-    return codes, nil
-}

From cb9577595e94f8a8d5423f46a50c82d61b3e8dd3 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Tue, 16 Jul 2024 16:52:29 +0200
Subject: [PATCH 18/35] chore: update dirs to match main

---
 src/query/callWorker.go   | 32 ++++++++++++++++++++++++++++++++
 src/query/queryExecute.go | 35 +++++++++++++++++++++++++++++++++++
 src/utils/getFile.go      | 18 ++++++++++++++++++
 3 files changed, 85 insertions(+)
 create mode 100644 src/query/callWorker.go
 create mode 100644 src/query/queryExecute.go
 create mode 100644 src/utils/getFile.go

diff --git a/src/query/callWorker.go b/src/query/callWorker.go
new file mode 100644
index 0000000..1a5b24b
--- /dev/null
+++ b/src/query/callWorker.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+  "time"
+)
+
+type forceData struct {
+	worker int
+	wordList string
+	url string
+}
+
+func executeQueryFromFile(data forceData, currentPath chan string) {
+  for taskData := range currentPath{
+    queryExecute(data, taskData, "POST")
+    }
+}
+
+func mainRequest(data forceData) {
+  channel := make(chan string)
+  wordArray := GetFileContent("../wordList/rootList")
+
+  for i := 0 ;i < data.worker; i++ {
+		go executeQueryFromFile(data, channel)
+	}
+  for i := 0; i < len(wordArray); i++ {
+    channel <- wordArray[i]
+  }
+  time.Sleep(1 * time.Second)
+  close(channel)
+}
+
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
new file mode 100644
index 0000000..42b7021
--- /dev/null
+++ b/src/query/queryExecute.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"io/ioutil"
+	"net/http"
+)
+
+func queryExecute(data forceData, path string, method string) {
+
+	client := &http.Client{}
+	req, err := http.NewRequest(method, data.url + path, nil)
+	if err != nil {
+	  log.Fatal(err)
+	}
+
+	q := req.URL.Query()
+
+	req.URL.RawQuery = q.Encode()
+
+	resp, err := client.Do(req)
+	if err != nil {
+	  fmt.Println(err)
+	}
+
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+	  log.Fatal(err)
+	}
+
+	fmt.Println(string(body))
+  }
\ No newline at end of file
diff --git a/src/utils/getFile.go b/src/utils/getFile.go
new file mode 100644
index 0000000..7accbb0
--- /dev/null
+++ b/src/utils/getFile.go
@@ -0,0 +1,18 @@
+package main
+
+import (
+    "os"
+    "fmt"
+    "log"
+	"strings"
+)
+
+func GetFileContent(filePath string) []string{
+    body, err := os.ReadFile(filePath)
+    if err != nil {
+        log.Fatalf("unable to read file: %v", err)
+    }
+	dataTab := strings.Split(string(body), "\n")
+    fmt.Println(dataTab[0])
+	return dataTab
+}
\ No newline at end of file

From 173293d79f987808ca14fb1cf4f766c9f8ab59f2 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 16 Jul 2024 17:28:50 +0200
Subject: [PATCH 19/35] refactor: main management of matchers is cleaned up

---
 src/matching/body.go    | 11 +++++++----
 src/matching/headers.go |  6 +++---
 src/matching/matcher.go | 22 ++++++++--------------
 src/matching/status.go  |  8 ++++----
 4 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/src/matching/body.go b/src/matching/body.go
index 54a1dce..c6734b9 100644
--- a/src/matching/body.go
+++ b/src/matching/body.go
@@ -1,10 +1,13 @@
 package matcher
 
-import "strings"
+import (
+	"errors"
+	"strings"
+)
 
-func matchContents(body []byte, criteria MatchCriteria) (bool, string) {
+func matchContents(body []byte, criteria MatchCriteria) (bool, error) {
 	if criteria.BodyContains != "" && !strings.Contains(string(body), criteria.BodyContains) {
-		return false, "body content mismatch"
+		return false, errors.New("body content mismatch")
 	}
-	return true, "body content matches"
+	return true, nil
 }
diff --git a/src/matching/headers.go b/src/matching/headers.go
index 54431f1..88f2c09 100644
--- a/src/matching/headers.go
+++ b/src/matching/headers.go
@@ -7,13 +7,13 @@ import (
 	"strings"
 )
 
-func matchHeaders(resp *http.Response, criteria MatchCriteria) (bool, string) {
+func matchHeaders(resp *http.Response, criteria MatchCriteria) (bool, error) {
 	for key, value := range criteria.Headers {
 		if resp.Header.Get(key) != value {
-			return false, fmt.Sprintf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
+			return false, fmt.Errorf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
 		}
 	}
-	return true, "headers match"
+	return true, nil
 }
 
 func parseHeaders(headersList string) map[string]string {
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 24ff9bd..963700d 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -1,7 +1,7 @@
 package matcher
 
 import (
-	"io/ioutil"
+	"io"
 	"log"
 	"net/http"
 )
@@ -13,31 +13,25 @@ type MatchCriteria struct {
 }
 
 func matchResponse(url string, criteria MatchCriteria) (bool, string) {
-	status := true
-	matchError := ""
-
 	resp, err := http.Get(url)
 	if err != nil {
 		return false, err.Error()
 	}
 	defer resp.Body.Close()
 
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return false, err.Error()
 	}
 
-	status, matchError = matchStatusCode(resp, criteria.StatusCodes)
-	if !status {
-		return false, matchError
+	if matched, err := matchStatusCode(resp, criteria.StatusCodes); !matched {
+		return false, err.Error()
 	}
-	status, matchError = matchHeaders(resp, criteria)
-	if !status {
-		return false, matchError
+	if matched, err := matchHeaders(resp, criteria); !matched {
+		return false, err.Error()
 	}
-	status, matchError = matchContents(body, criteria)
-	if !status {
-		return false, matchError
+	if matched, err := matchContents(body, criteria); !matched {
+		return false, err.Error()
 	}
 
 	return true, "Matched successfully for " + url
diff --git a/src/matching/status.go b/src/matching/status.go
index 5a004a9..e60c746 100644
--- a/src/matching/status.go
+++ b/src/matching/status.go
@@ -7,7 +7,7 @@ import (
 	"strings"
 )
 
-func matchStatusCode(resp *http.Response, matchCodes []int) (bool, string) {
+func matchStatusCode(resp *http.Response, matchCodes []int) (bool, error) {
 	isAll := false
 
 	if matchCodes[0] == 0 {
@@ -17,10 +17,10 @@ func matchStatusCode(resp *http.Response, matchCodes []int) (bool, string) {
 	}
 	for _, code := range matchCodes {
 		if resp.StatusCode == code || isAll {
-			return true, fmt.Sprintf("status code is %d", resp.StatusCode)
+			return true, nil
 		}
 	}
-	return false, fmt.Sprintf("status code is %d", resp.StatusCode)
+	return false, fmt.Errorf("status code is %d", resp.StatusCode)
 }
 
 func parseStatusCodes(statusCodeList string) ([]int, error) {
@@ -39,7 +39,7 @@ func parseStatusCodes(statusCodeList string) ([]int, error) {
 		if code < 600 && code >= 100 {
 			codes = append(codes, code)
 		} else {
-			fmt.Printf("[WARN] `%d` not considered, invalid status code.", code)
+			log.Printf("[WARN] `%d` not considered, invalid status code.", code)
 		}
 	}
 

From bcdb37390a2444f46919494584db86c6c3f51514 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 16 Jul 2024 20:05:43 +0200
Subject: [PATCH 20/35] feat(matcher): temporary main is adapted to separate
 parser from start of req

---
 src/main.go             |  8 +++++++-
 src/matching/matcher.go | 11 +++--------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/main.go b/src/main.go
index 55a5ba3..be8b77a 100644
--- a/src/main.go
+++ b/src/main.go
@@ -4,6 +4,7 @@ import (
 	"bruteforce/src/matching"
 	"flag"
 	"fmt"
+	"log"
 )
 
 func main() {
@@ -22,5 +23,10 @@ func main() {
 		fmt.Println("use flag -body=\"<string-in-body>\"")
 		return
 	}
-	matcher.MatchParser("http://example.com", *statusPtr, *headerPtr, *bodyPtr)
+
+	criteria := matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
+	result, err := matcher.MatchResponse("http://example.com", criteria)
+	if !result {
+		log.Fatal(err)
+	}
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 963700d..3b0c744 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -12,7 +12,7 @@ type MatchCriteria struct {
 	BodyContains string
 }
 
-func matchResponse(url string, criteria MatchCriteria) (bool, string) {
+func MatchResponse(url string, criteria MatchCriteria) (bool, string) {
 	resp, err := http.Get(url)
 	if err != nil {
 		return false, err.Error()
@@ -37,7 +37,7 @@ func matchResponse(url string, criteria MatchCriteria) (bool, string) {
 	return true, "Matched successfully for " + url
 }
 
-func MatchParser(url string, statuses string, headers string, bodyContains string) {
+func MatchParser(statuses string, headers string, bodyContains string) (MatchCriteria) {
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
 		log.Fatal("Error parsing status codes:", err)
@@ -50,10 +50,5 @@ func MatchParser(url string, statuses string, headers string, bodyContains strin
 		BodyContains: bodyContains,
 	}
 
-	matched, msg := matchResponse(url, criteria)
-	if matched {
-		log.Println("Matched:", msg)
-	} else {
-		log.Println("Not matched:", msg)
-	}
+	return criteria;
 }

From fbbf50618f567236be3d4f1518cb97b91e918c20 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Tue, 16 Jul 2024 20:10:49 +0200
Subject: [PATCH 21/35] fix(matcher): adapt MatchResponse for Gustave query
 execution

---
 src/main.go             |  8 +++-----
 src/matching/matcher.go | 20 +++++++-------------
 2 files changed, 10 insertions(+), 18 deletions(-)

diff --git a/src/main.go b/src/main.go
index be8b77a..27369e9 100644
--- a/src/main.go
+++ b/src/main.go
@@ -4,7 +4,6 @@ import (
 	"bruteforce/src/matching"
 	"flag"
 	"fmt"
-	"log"
 )
 
 func main() {
@@ -25,8 +24,7 @@ func main() {
 	}
 
 	criteria := matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
-	result, err := matcher.MatchResponse("http://example.com", criteria)
-	if !result {
-		log.Fatal(err)
-	}
+	// Here look to implement queryExecute
+	// matcher.MatchResponse can be called with criteria (above) in parameter
+	fmt.Println(criteria)
 }
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 3b0c744..9bc5259 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -12,32 +12,26 @@ type MatchCriteria struct {
 	BodyContains string
 }
 
-func MatchResponse(url string, criteria MatchCriteria) (bool, string) {
-	resp, err := http.Get(url)
+func MatchResponse(response *http.Response, criteria MatchCriteria) (bool, string) {
+	body, err := io.ReadAll(response.Body)
 	if err != nil {
 		return false, err.Error()
 	}
-	defer resp.Body.Close()
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return false, err.Error()
-	}
-
-	if matched, err := matchStatusCode(resp, criteria.StatusCodes); !matched {
+	if matched, err := matchStatusCode(response, criteria.StatusCodes); !matched {
 		return false, err.Error()
 	}
-	if matched, err := matchHeaders(resp, criteria); !matched {
+	if matched, err := matchHeaders(response, criteria); !matched {
 		return false, err.Error()
 	}
 	if matched, err := matchContents(body, criteria); !matched {
 		return false, err.Error()
 	}
 
-	return true, "Matched successfully for " + url
+	return true, "matched successfully"
 }
 
-func MatchParser(statuses string, headers string, bodyContains string) (MatchCriteria) {
+func MatchParser(statuses string, headers string, bodyContains string) MatchCriteria {
 	matchCodes, err := parseStatusCodes(statuses)
 	if err != nil {
 		log.Fatal("Error parsing status codes:", err)
@@ -50,5 +44,5 @@ func MatchParser(statuses string, headers string, bodyContains string) (MatchCri
 		BodyContains: bodyContains,
 	}
 
-	return criteria;
+	return criteria
 }

From 570b74e7696cda91685aa8bf9900ab89972b23b4 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Wed, 17 Jul 2024 15:04:58 +0200
Subject: [PATCH 22/35] refactor: implementation of query package and utils
 with temporary main

---
 src/main.go               | 11 +++++++++--
 src/query/callWorker.go   | 41 ++++++++++++++++++++-------------------
 src/query/queryExecute.go | 21 +++++++++-----------
 src/utils/getFile.go      | 21 ++++++++++----------
 4 files changed, 49 insertions(+), 45 deletions(-)

diff --git a/src/main.go b/src/main.go
index 27369e9..6e4bf27 100644
--- a/src/main.go
+++ b/src/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"bruteforce/src/matching"
+	"bruteforce/src/query"
 	"flag"
 	"fmt"
 )
@@ -24,7 +25,13 @@ func main() {
 	}
 
 	criteria := matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
-	// Here look to implement queryExecute
-	// matcher.MatchResponse can be called with criteria (above) in parameter
 	fmt.Println(criteria)
+
+	data := query.ForceData{
+		Worker:   3,
+		WordList: "../wordList/rootList",
+		Url:      "http://localhost:3333",
+	}
+	// matcher.MatchResponse can be called with criteria (above) in parameter
+	query.MainRequest(data, criteria) // maybe like this?
 }
diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 1a5b24b..8cc5653 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -1,32 +1,33 @@
-package main
+package query
 
 import (
-  "time"
+	"bruteforce/src/matching"
+	"bruteforce/src/utils"
+	"time"
 )
 
-type forceData struct {
-	worker int
-	wordList string
-	url string
+type ForceData struct {
+	Worker   int
+	WordList string
+	Url      string
 }
 
-func executeQueryFromFile(data forceData, currentPath chan string) {
-  for taskData := range currentPath{
-    queryExecute(data, taskData, "POST")
-    }
+func executeQueryFromFile(data ForceData, currentPath chan string) {
+	for taskData := range currentPath {
+		QueryExecute(data, taskData, "POST")
+	}
 }
 
-func mainRequest(data forceData) {
-  channel := make(chan string)
-  wordArray := GetFileContent("../wordList/rootList")
+func MainRequest(data ForceData, criteria matcher.MatchCriteria) {
+	channel := make(chan string)
+	wordArray := utils.GetFileContent(data.WordList)
 
-  for i := 0 ;i < data.worker; i++ {
+	for i := 0; i < data.Worker; i++ {
 		go executeQueryFromFile(data, channel)
 	}
-  for i := 0; i < len(wordArray); i++ {
-    channel <- wordArray[i]
-  }
-  time.Sleep(1 * time.Second)
-  close(channel)
+	for i := 0; i < len(wordArray); i++ {
+		channel <- wordArray[i]
+	}
+	time.Sleep(1 * time.Second)
+	close(channel)
 }
-
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
index 42b7021..ed65812 100644
--- a/src/query/queryExecute.go
+++ b/src/query/queryExecute.go
@@ -1,35 +1,32 @@
-package main
+package query
 
 import (
 	"fmt"
+	"io"
 	"log"
-	"io/ioutil"
 	"net/http"
 )
 
-func queryExecute(data forceData, path string, method string) {
-
+func QueryExecute(data ForceData, path string, method string) {
 	client := &http.Client{}
-	req, err := http.NewRequest(method, data.url + path, nil)
+	req, err := http.NewRequest(method, data.Url+path, nil)
 	if err != nil {
-	  log.Fatal(err)
+		log.Fatal(err)
 	}
 
 	q := req.URL.Query()
-
 	req.URL.RawQuery = q.Encode()
 
 	resp, err := client.Do(req)
 	if err != nil {
-	  fmt.Println(err)
+		fmt.Println(err)
 	}
-
 	defer resp.Body.Close()
 
-	body, err := ioutil.ReadAll(resp.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-	  log.Fatal(err)
+		log.Fatal(err)
 	}
 
 	fmt.Println(string(body))
-  }
\ No newline at end of file
+}
diff --git a/src/utils/getFile.go b/src/utils/getFile.go
index 7accbb0..74be1b9 100644
--- a/src/utils/getFile.go
+++ b/src/utils/getFile.go
@@ -1,18 +1,17 @@
-package main
+package utils
 
 import (
-    "os"
-    "fmt"
-    "log"
+	"log"
+	"os"
 	"strings"
 )
 
-func GetFileContent(filePath string) []string{
-    body, err := os.ReadFile(filePath)
-    if err != nil {
-        log.Fatalf("unable to read file: %v", err)
-    }
+func GetFileContent(filePath string) []string {
+	body, err := os.ReadFile(filePath)
+	if err != nil {
+		log.Fatalf("Unable to read file: %v", err)
+	}
+
 	dataTab := strings.Split(string(body), "\n")
-    fmt.Println(dataTab[0])
 	return dataTab
-}
\ No newline at end of file
+}

From 2f5f902c743daee698f08d28721b7cea61cc66bb Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Tue, 23 Jul 2024 14:39:08 +0200
Subject: [PATCH 23/35] feat: autocompletion for cli (zsh-bash)

---
 Makefile                        |  9 +++++++--
 autocompletion/bash/_bruteforce | 24 ++++++++++++++++++++++++
 autocompletion/zsh/_bruteforce  | 19 +++++++++++++++++++
 src/cli/cli.go                  |  9 +++++++--
 4 files changed, 57 insertions(+), 4 deletions(-)
 create mode 100644 autocompletion/bash/_bruteforce
 create mode 100644 autocompletion/zsh/_bruteforce

diff --git a/Makefile b/Makefile
index dbf6383..fe4646f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,7 @@
 
 NAME	=	bruteforce
-SRC		=	src/main.go
+
+SRC		=	src/main.go	\
 
 all: $(NAME)
 
@@ -15,4 +16,8 @@ fclean:
 
 re: fclean all
 
-.PHONY: all clean fclean re
+install_program:
+	echo "source $(pwd)/autocompletion/bash/_bruteforce" >> ~/.bashrc
+	echo "source $(pwd)/autocompletion/zsh/_bruteforce" >> ~/.zshrc
+
+.PHONY: all clean fclean re install_program
diff --git a/autocompletion/bash/_bruteforce b/autocompletion/bash/_bruteforce
new file mode 100644
index 0000000..0fe6e3f
--- /dev/null
+++ b/autocompletion/bash/_bruteforce
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+_bruteforce_completion() {
+    local cur prev opts
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    opts="--threads -v"
+
+    if [[ ${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+    elif [[ ${COMP_CWORD} -eq 2 ]]; then
+        if [[ "${prev}" == "--threads" ]]; then
+            COMPREPLY=( $(compgen -W "1 2 4 8 16 32" -- "${cur}") )
+        elif [[ "${prev}" == "-v" ]]; then
+            COMPREPLY=()
+        elif [[ "${prev}" == "http://"* || "${prev}" == "https://"* ]]; then
+            COMPREPLY=()
+        fi
+    else
+        COMPREPLY=( $(compgen -W "http:// https://" -- "${cur}") )
+    fi
+}
+
+complete -F _bruteforce_completion bruteforce
diff --git a/autocompletion/zsh/_bruteforce b/autocompletion/zsh/_bruteforce
new file mode 100644
index 0000000..fb4eccd
--- /dev/null
+++ b/autocompletion/zsh/_bruteforce
@@ -0,0 +1,19 @@
+#compdef bruteforce
+
+_bruteforce() {
+    local -a args
+
+    args=(
+        '-v[verbose mode]'
+        '--threads=[number of threads]:number of threads:_sequence 1 1 64'
+        ':url:_bruteforce_urls'
+    )
+
+    _arguments -s $args
+}
+
+_bruteforce_urls() {
+    _urls -p 'http://' 'https://'
+}
+
+compdef _bruteforce bruteforce
diff --git a/src/cli/cli.go b/src/cli/cli.go
index caf3330..1dc9cb2 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -8,14 +8,19 @@ import (
 
 func Parse_cli_args() (models.Forcing_params, error) {
 	var params models.Forcing_params
-	myError := errors.New("Wrong parameters")
+	UrlError := errors.New("No url given")
+	ThreadsError := errors.New("Wrong number of threads given")
+
 	forkptr := flag.Bool("v", false, "Verbose program")
 
 	flag.IntVar(&params.Threads, "threads", 1, "Number of threads to be used")
 	flag.Parse()
 
+	if params.Threads < 1 {
+		return params, ThreadsError
+	}
 	if len(flag.Args()) != 1 {
-		return params, myError
+		return params, UrlError
 	}
 	params.Url = flag.Args()[0]
 	params.BoolFlags.Verbose = *forkptr

From ac340dc6c2080573a51ec81e8859b524e147234d Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Tue, 30 Jul 2024 19:02:45 +0200
Subject: [PATCH 24/35] fix: updated autocompletion files

---
 autocompletion/bash/_bruteforce | 20 ++++++++++++--------
 autocompletion/zsh/_bruteforce  |  8 ++++++--
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/autocompletion/bash/_bruteforce b/autocompletion/bash/_bruteforce
index 0fe6e3f..49c9bbc 100644
--- a/autocompletion/bash/_bruteforce
+++ b/autocompletion/bash/_bruteforce
@@ -4,18 +4,22 @@ _bruteforce_completion() {
     local cur prev opts
     cur="${COMP_WORDS[COMP_CWORD]}"
     prev="${COMP_WORDS[COMP_CWORD-1]}"
-    opts="--threads -v"
+    opts="--threads -v --status-codes --header --body --wordlist"
 
     if [[ ${COMP_CWORD} -eq 1 ]]; then
         COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
     elif [[ ${COMP_CWORD} -eq 2 ]]; then
-        if [[ "${prev}" == "--threads" ]]; then
-            COMPREPLY=( $(compgen -W "1 2 4 8 16 32" -- "${cur}") )
-        elif [[ "${prev}" == "-v" ]]; then
-            COMPREPLY=()
-        elif [[ "${prev}" == "http://"* || "${prev}" == "https://"* ]]; then
-            COMPREPLY=()
-        fi
+        case "${prev}" in
+            --threads)
+                COMPREPLY=( $(compgen -W "1 2 4 8 16 32" -- "${cur}") )
+                ;;
+            --status-codes)
+                COMPREPLY=( $(compgen -W "200 401 403 404 429 500" -- "${cur}") )
+                ;;
+            --header|--body|--wordlist)
+                COMPREPLY=()
+                ;;
+        esac
     else
         COMPREPLY=( $(compgen -W "http:// https://" -- "${cur}") )
     fi
diff --git a/autocompletion/zsh/_bruteforce b/autocompletion/zsh/_bruteforce
index fb4eccd..0b8c685 100644
--- a/autocompletion/zsh/_bruteforce
+++ b/autocompletion/zsh/_bruteforce
@@ -5,8 +5,12 @@ _bruteforce() {
 
     args=(
         '-v[verbose mode]'
-        '--threads=[number of threads]:number of threads:_sequence 1 1 64'
-        ':url:_bruteforce_urls'
+        '--threads=[number of threads]:number of threads:(1 2 4 8 16 32)'
+        '--status-codes=[Comma-separated list of status codes to match]:status codes:'
+        '--header=[Header to match]:header:'
+        '--body=[String to match in response body]:body:'
+        '--wordlist=[Wordlist to bruteforce URLs with]:wordlist:_files'
+        '*:url:_bruteforce_urls'
     )
 
     _arguments -s $args

From d967998e22b3011b5feb77a1cbf3eed9f7588261 Mon Sep 17 00:00:00 2001
From: 57ave <gustave.delecroix@epitech.eu>
Date: Thu, 8 Aug 2024 18:04:24 +0200
Subject: [PATCH 25/35] feat():stop worker

---
 src/query/callWorker.go | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 8cc5653..23b54f7 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -3,7 +3,7 @@ package query
 import (
 	"bruteforce/src/matching"
 	"bruteforce/src/utils"
-	"time"
+	"sync"
 )
 
 type ForceData struct {
@@ -12,22 +12,25 @@ type ForceData struct {
 	Url      string
 }
 
-func executeQueryFromFile(data ForceData, currentPath chan string) {
+func executeQueryFromFile(wg *sync.WaitGroup, data ForceData, currentPath chan string) {
+	defer wg.Done()
 	for taskData := range currentPath {
 		QueryExecute(data, taskData, "POST")
 	}
 }
 
 func MainRequest(data ForceData, criteria matcher.MatchCriteria) {
+	wg := &sync.WaitGroup{}
+    wg.Add(data.Worker)
 	channel := make(chan string)
 	wordArray := utils.GetFileContent(data.WordList)
 
 	for i := 0; i < data.Worker; i++ {
-		go executeQueryFromFile(data, channel)
+		go executeQueryFromFile(wg, data, channel)
 	}
 	for i := 0; i < len(wordArray); i++ {
 		channel <- wordArray[i]
 	}
-	time.Sleep(1 * time.Second)
+	wg.Wait()
 	close(channel)
 }

From 26f3c21fb345035284e3986e2d1b0037768056b5 Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Thu, 8 Aug 2024 18:19:10 +0200
Subject: [PATCH 26/35] fix: unable to build (typo) and now requires wordlist
 path

---
 src/cli/cli.go          | 4 ++++
 src/query/callWorker.go | 3 +--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index fa2b2c2..9c20286 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -13,6 +13,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 
 	UrlError := errors.New("No url given")
 	ThreadsError := errors.New("Wrong number of threads given")
+	WordListError := errors.New("No wordlist given")
 
 	forkptr := flag.Bool("v", false, "Verbose program")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
@@ -41,5 +42,8 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	params.Header = *headerPtr
 	params.Body = *bodyPtr
 	params.Wordlist = *wordlistPtr
+	if params.Wordlist == "" {
+		return params, WordListError
+	}
 	return params, nil
 }
diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 054b47f..7102fcc 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -7,7 +7,6 @@ import (
 	"sync"
 )
 
-
 func executeQueryFromFile(wg *sync.WaitGroup, params *models.Forcing_params, currentPath chan string) {
 	defer wg.Done()
 	for taskData := range currentPath {
@@ -17,7 +16,7 @@ func executeQueryFromFile(wg *sync.WaitGroup, params *models.Forcing_params, cur
 
 func MainRequest(params *models.Forcing_params, criteria matcher.MatchCriteria) {
 	wg := &sync.WaitGroup{}
-    wg.Add(data.Worker)
+	wg.Add(params.Workers)
 	channel := make(chan string)
 	wordArray := utils.GetFileContent(params.Wordlist)
 

From 96418447e80bebe5ffdc00c4aa9292aad6e85b7d Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Thu, 8 Aug 2024 18:32:35 +0200
Subject: [PATCH 27/35] fix: fixed url error bug

---
 src/cli/cli.go | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index 9c20286..de4c535 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -15,7 +15,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	ThreadsError := errors.New("Wrong number of threads given")
 	WordListError := errors.New("No wordlist given")
 
-	forkptr := flag.Bool("v", false, "Verbose program")
+	// forkptr := flag.Bool("v", false, "Verbose program")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
 	headerPtr := flag.String("header", "", "Header to match")
 	bodyPtr := flag.String("body", "", "String to match in response body")
@@ -33,11 +33,12 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	if params.Workers < 1 {
 		return params, ThreadsError
 	}
-	if len(flag.Args()) != 1 {
+	fmt.Print(flag.Args())
+	if len(flag.Args()) < 1 {
 		return params, UrlError
 	}
 	params.Url = flag.Args()[0]
-	params.BoolFlags.Verbose = *forkptr
+	// params.BoolFlags.Verbose = *forkptr
 	params.Status = *statusPtr
 	params.Header = *headerPtr
 	params.Body = *bodyPtr

From cbb4718feeb26ad618cd7bfa58ebf4e8b85cfc05 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Thu, 8 Aug 2024 20:15:06 +0200
Subject: [PATCH 28/35] refactor(matcher): adapt to parsing of cli for matching
 criteria

simple immigration of models and use of multiple structs
---
 src/cli/cli.go          |  5 ++---
 src/main.go             |  7 +++----
 src/matching/body.go    |  3 ++-
 src/matching/headers.go |  3 ++-
 src/matching/matcher.go | 18 ++++++------------
 src/models/models.go    | 10 +++++++---
 src/query/callWorker.go |  3 +--
 7 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index de4c535..2becae7 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"bruteforce/src/matching"
 	"bruteforce/src/models"
 	"errors"
 	"flag"
@@ -39,9 +40,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	}
 	params.Url = flag.Args()[0]
 	// params.BoolFlags.Verbose = *forkptr
-	params.Status = *statusPtr
-	params.Header = *headerPtr
-	params.Body = *bodyPtr
+	params.Criteria = matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
 	params.Wordlist = *wordlistPtr
 	if params.Wordlist == "" {
 		return params, WordListError
diff --git a/src/main.go b/src/main.go
index 2061245..53c950e 100644
--- a/src/main.go
+++ b/src/main.go
@@ -2,7 +2,7 @@ package main
 
 import (
 	"bruteforce/src/cli"
-	"bruteforce/src/matching"
+	// "bruteforce/src/matching"
 	"bruteforce/src/query"
 	"fmt"
 )
@@ -16,7 +16,6 @@ func main() {
 	}
 	fmt.Println(forcing_params)
 
-	criteria := matcher.MatchParser(&forcing_params)
-
-	query.MainRequest(&forcing_params, criteria) // maybe like this?
+	// matcher.MatchParser(&forcing_params)
+	query.MainRequest(&forcing_params)
 }
diff --git a/src/matching/body.go b/src/matching/body.go
index c6734b9..51563b7 100644
--- a/src/matching/body.go
+++ b/src/matching/body.go
@@ -1,11 +1,12 @@
 package matcher
 
 import (
+	"bruteforce/src/models"
 	"errors"
 	"strings"
 )
 
-func matchContents(body []byte, criteria MatchCriteria) (bool, error) {
+func matchContents(body []byte, criteria models.MatchCriteria) (bool, error) {
 	if criteria.BodyContains != "" && !strings.Contains(string(body), criteria.BodyContains) {
 		return false, errors.New("body content mismatch")
 	}
diff --git a/src/matching/headers.go b/src/matching/headers.go
index 88f2c09..7cdff1e 100644
--- a/src/matching/headers.go
+++ b/src/matching/headers.go
@@ -1,13 +1,14 @@
 package matcher
 
 import (
+	"bruteforce/src/models"
 	"fmt"
 	"log"
 	"net/http"
 	"strings"
 )
 
-func matchHeaders(resp *http.Response, criteria MatchCriteria) (bool, error) {
+func matchHeaders(resp *http.Response, criteria models.MatchCriteria) (bool, error) {
 	for key, value := range criteria.Headers {
 		if resp.Header.Get(key) != value {
 			return false, fmt.Errorf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index cf7d287..a330d48 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -7,13 +7,7 @@ import (
 	"net/http"
 )
 
-type MatchCriteria struct {
-	StatusCodes  []int
-	Headers      map[string]string
-	BodyContains string
-}
-
-func MatchResponse(response *http.Response, criteria MatchCriteria) (bool, string) {
+func MatchResponse(response *http.Response, criteria models.MatchCriteria) (bool, string) {
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
 		return false, err.Error()
@@ -32,17 +26,17 @@ func MatchResponse(response *http.Response, criteria MatchCriteria) (bool, strin
 	return true, "matched successfully"
 }
 
-func MatchParser(params *models.Forcing_params) MatchCriteria {
-	matchCodes, err := parseStatusCodes(params.Status)
+func MatchParser(statusPtr string, headerPtr string, bodyPtr string) models.MatchCriteria {
+	matchCodes, err := parseStatusCodes(statusPtr)
 	if err != nil {
 		log.Fatal("Error parsing status codes:", err)
 	}
 
-	matchHeaders := parseHeaders(params.Header)
-	criteria := MatchCriteria{
+	matchHeaders := parseHeaders(headerPtr)
+	criteria := models.MatchCriteria{
 		StatusCodes:  matchCodes,
 		Headers:      matchHeaders,
-		BodyContains: params.Body,
+		BodyContains: bodyPtr,
 	}
 
 	return criteria
diff --git a/src/models/models.go b/src/models/models.go
index 7e173fa..e496d22 100644
--- a/src/models/models.go
+++ b/src/models/models.go
@@ -4,12 +4,16 @@ type boolflags struct {
 	Verbose bool
 }
 
+type MatchCriteria struct {
+	StatusCodes  []int
+	Headers      map[string]string
+	BodyContains string
+}
+
 type Forcing_params struct {
 	Workers   int
 	Url       string
 	Wordlist  string
 	BoolFlags boolflags
-	Status    string
-	Header    string
-	Body      string
+	Criteria  MatchCriteria
 }
diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 7102fcc..2bd783b 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -1,7 +1,6 @@
 package query
 
 import (
-	"bruteforce/src/matching"
 	"bruteforce/src/models"
 	"bruteforce/src/utils"
 	"sync"
@@ -14,7 +13,7 @@ func executeQueryFromFile(wg *sync.WaitGroup, params *models.Forcing_params, cur
 	}
 }
 
-func MainRequest(params *models.Forcing_params, criteria matcher.MatchCriteria) {
+func MainRequest(params *models.Forcing_params) {
 	wg := &sync.WaitGroup{}
 	wg.Add(params.Workers)
 	channel := make(chan string)

From 692821cf66d58eefb6b9ee998d8ff0266d699fe3 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Thu, 8 Aug 2024 20:52:02 +0200
Subject: [PATCH 29/35] style: parsing is cleaned up for unecessary code

---
 src/cli/cli.go | 4 +++-
 src/main.go    | 2 --
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index 2becae7..567ac50 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -18,7 +18,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 
 	// forkptr := flag.Bool("v", false, "Verbose program")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
-	headerPtr := flag.String("header", "", "Header to match")
+	headerPtr := flag.String("header", "", "Header to match, formatted as \"key: value\"")
 	bodyPtr := flag.String("body", "", "String to match in response body")
 	wordlistPtr := flag.String("wordlist", "", "Wordlist to bruteforce url with")
 	flag.IntVar(&params.Workers, "threads", 1, "Number of threads to be used")
@@ -38,6 +38,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	if len(flag.Args()) < 1 {
 		return params, UrlError
 	}
+
 	params.Url = flag.Args()[0]
 	// params.BoolFlags.Verbose = *forkptr
 	params.Criteria = matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
@@ -45,5 +46,6 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	if params.Wordlist == "" {
 		return params, WordListError
 	}
+
 	return params, nil
 }
diff --git a/src/main.go b/src/main.go
index 53c950e..9642a22 100644
--- a/src/main.go
+++ b/src/main.go
@@ -2,7 +2,6 @@ package main
 
 import (
 	"bruteforce/src/cli"
-	// "bruteforce/src/matching"
 	"bruteforce/src/query"
 	"fmt"
 )
@@ -16,6 +15,5 @@ func main() {
 	}
 	fmt.Println(forcing_params)
 
-	// matcher.MatchParser(&forcing_params)
 	query.MainRequest(&forcing_params)
 }

From bb9f6dd0009330f25bf7974fed949a152e1565a1 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Mon, 12 Aug 2024 15:45:56 +0200
Subject: [PATCH 30/35] feat(matcher): implement matcher in the query execution

---
 src/matching/matcher.go   | 18 ++++++------------
 src/matching/status.go    |  9 +++++----
 src/query/queryExecute.go |  6 +++++-
 3 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index a330d48..7c5039c 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -2,28 +2,22 @@ package matcher
 
 import (
 	"bruteforce/src/models"
-	"io"
 	"log"
 	"net/http"
 )
 
-func MatchResponse(response *http.Response, criteria models.MatchCriteria) (bool, string) {
-	body, err := io.ReadAll(response.Body)
-	if err != nil {
-		return false, err.Error()
-	}
-
-	if matched, err := matchStatusCode(response, criteria.StatusCodes); !matched {
-		return false, err.Error()
+func MatchResponse(response *http.Response, body []byte, criteria models.MatchCriteria) error {
+	if matched, err := matchStatusCode(response, criteria); !matched {
+		return err
 	}
 	if matched, err := matchHeaders(response, criteria); !matched {
-		return false, err.Error()
+		return err
 	}
 	if matched, err := matchContents(body, criteria); !matched {
-		return false, err.Error()
+		return err
 	}
 
-	return true, "matched successfully"
+	return nil
 }
 
 func MatchParser(statusPtr string, headerPtr string, bodyPtr string) models.MatchCriteria {
diff --git a/src/matching/status.go b/src/matching/status.go
index e60c746..3dd681a 100644
--- a/src/matching/status.go
+++ b/src/matching/status.go
@@ -1,21 +1,22 @@
 package matcher
 
 import (
+	"bruteforce/src/models"
 	"fmt"
 	"log"
 	"net/http"
 	"strings"
 )
 
-func matchStatusCode(resp *http.Response, matchCodes []int) (bool, error) {
+func matchStatusCode(resp *http.Response, criteria models.MatchCriteria) (bool, error) {
 	isAll := false
 
-	if matchCodes[0] == 0 {
+	if criteria.StatusCodes[0] == 0 {
 		isAll = !isAll
 	} else {
-		log.Printf("Matching status codes %d...", matchCodes)
+		log.Printf("Matching status codes %d...", criteria.StatusCodes)
 	}
-	for _, code := range matchCodes {
+	for _, code := range criteria.StatusCodes {
 		if resp.StatusCode == code || isAll {
 			return true, nil
 		}
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
index 7a76c97..e2aba3c 100644
--- a/src/query/queryExecute.go
+++ b/src/query/queryExecute.go
@@ -1,6 +1,7 @@
 package query
 
 import (
+	"bruteforce/src/matching"
 	"bruteforce/src/models"
 	"fmt"
 	"io"
@@ -29,5 +30,8 @@ func QueryExecute(params *models.Forcing_params, path string, method string) {
 		log.Fatal(err)
 	}
 
-	fmt.Println(string(body))
+	if err := matcher.MatchResponse(resp, body, params.Criteria); err == nil {
+		fmt.Println(string(body))
+	}
+
 }

From c4a7249786a34c22f0218f57a19384105b9f85b8 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Mon, 12 Aug 2024 15:50:16 +0200
Subject: [PATCH 31/35] style(matcher): fixup leftover useless bool return

---
 src/matching/body.go      | 6 +++---
 src/matching/headers.go   | 6 +++---
 src/matching/matcher.go   | 6 +++---
 src/matching/status.go    | 6 +++---
 src/query/queryExecute.go | 2 ++
 5 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/matching/body.go b/src/matching/body.go
index 51563b7..9ccf9f5 100644
--- a/src/matching/body.go
+++ b/src/matching/body.go
@@ -6,9 +6,9 @@ import (
 	"strings"
 )
 
-func matchContents(body []byte, criteria models.MatchCriteria) (bool, error) {
+func matchContents(body []byte, criteria models.MatchCriteria) error {
 	if criteria.BodyContains != "" && !strings.Contains(string(body), criteria.BodyContains) {
-		return false, errors.New("body content mismatch")
+		return errors.New("body content mismatch")
 	}
-	return true, nil
+	return nil
 }
diff --git a/src/matching/headers.go b/src/matching/headers.go
index 7cdff1e..9bae1bb 100644
--- a/src/matching/headers.go
+++ b/src/matching/headers.go
@@ -8,13 +8,13 @@ import (
 	"strings"
 )
 
-func matchHeaders(resp *http.Response, criteria models.MatchCriteria) (bool, error) {
+func matchHeaders(resp *http.Response, criteria models.MatchCriteria) error {
 	for key, value := range criteria.Headers {
 		if resp.Header.Get(key) != value {
-			return false, fmt.Errorf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
+			return fmt.Errorf("header mismatch: %s=%s\nheaders: %s", key, value, resp.Header)
 		}
 	}
-	return true, nil
+	return nil
 }
 
 func parseHeaders(headersList string) map[string]string {
diff --git a/src/matching/matcher.go b/src/matching/matcher.go
index 7c5039c..687dc60 100644
--- a/src/matching/matcher.go
+++ b/src/matching/matcher.go
@@ -7,13 +7,13 @@ import (
 )
 
 func MatchResponse(response *http.Response, body []byte, criteria models.MatchCriteria) error {
-	if matched, err := matchStatusCode(response, criteria); !matched {
+	if err := matchStatusCode(response, criteria); err != nil {
 		return err
 	}
-	if matched, err := matchHeaders(response, criteria); !matched {
+	if err := matchHeaders(response, criteria); err != nil {
 		return err
 	}
-	if matched, err := matchContents(body, criteria); !matched {
+	if err := matchContents(body, criteria); err != nil {
 		return err
 	}
 
diff --git a/src/matching/status.go b/src/matching/status.go
index 3dd681a..2a90b01 100644
--- a/src/matching/status.go
+++ b/src/matching/status.go
@@ -8,7 +8,7 @@ import (
 	"strings"
 )
 
-func matchStatusCode(resp *http.Response, criteria models.MatchCriteria) (bool, error) {
+func matchStatusCode(resp *http.Response, criteria models.MatchCriteria) error {
 	isAll := false
 
 	if criteria.StatusCodes[0] == 0 {
@@ -18,10 +18,10 @@ func matchStatusCode(resp *http.Response, criteria models.MatchCriteria) (bool,
 	}
 	for _, code := range criteria.StatusCodes {
 		if resp.StatusCode == code || isAll {
-			return true, nil
+			return nil
 		}
 	}
-	return false, fmt.Errorf("status code is %d", resp.StatusCode)
+	return fmt.Errorf("status code is %d", resp.StatusCode)
 }
 
 func parseStatusCodes(statusCodeList string) ([]int, error) {
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
index e2aba3c..5185636 100644
--- a/src/query/queryExecute.go
+++ b/src/query/queryExecute.go
@@ -32,6 +32,8 @@ func QueryExecute(params *models.Forcing_params, path string, method string) {
 
 	if err := matcher.MatchResponse(resp, body, params.Criteria); err == nil {
 		fmt.Println(string(body))
+	} else {
+		log.Println(err)
 	}
 
 }

From bf1711defcd5d47b56c696d67d391101e1284d3b Mon Sep 17 00:00:00 2001
From: SIMLUKE <luc.simon@epitech.eu>
Date: Wed, 14 Aug 2024 10:28:36 +0200
Subject: [PATCH 32/35] fix: fixed verbose option added clearer help

---
 src/cli/cli.go          | 16 ++++++++--------
 src/query/callWorker.go |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index 567ac50..a373dea 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -16,7 +16,7 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	ThreadsError := errors.New("Wrong number of threads given")
 	WordListError := errors.New("No wordlist given")
 
-	// forkptr := flag.Bool("v", false, "Verbose program")
+	forkptr := flag.Bool("v", false, "Verbose program")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
 	headerPtr := flag.String("header", "", "Header to match, formatted as \"key: value\"")
 	bodyPtr := flag.String("body", "", "String to match in response body")
@@ -24,25 +24,25 @@ func Parse_cli_args() (models.Forcing_params, error) {
 	flag.IntVar(&params.Workers, "threads", 1, "Number of threads to be used")
 
 	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "Usage: bruteforce [options] <url>\n")
+		fmt.Fprintf(os.Stderr, "Usage: bruteforce [options] --wordlist=[./path/to/wordlist] <url>\n")
 		fmt.Fprintf(os.Stderr, "Options:\n")
 		flag.PrintDefaults()
 	}
 
 	flag.Parse()
 
-	if params.Workers < 1 {
-		return params, ThreadsError
-	}
-	fmt.Print(flag.Args())
 	if len(flag.Args()) < 1 {
 		return params, UrlError
 	}
 
 	params.Url = flag.Args()[0]
-	// params.BoolFlags.Verbose = *forkptr
-	params.Criteria = matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
+	params.BoolFlags.Verbose = *forkptr
 	params.Wordlist = *wordlistPtr
+	params.Criteria = matcher.MatchParser(*statusPtr, *headerPtr, *bodyPtr)
+
+	if params.Workers < 1 {
+		return params, ThreadsError
+	}
 	if params.Wordlist == "" {
 		return params, WordListError
 	}
diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 2bd783b..42ade5e 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -9,7 +9,7 @@ import (
 func executeQueryFromFile(wg *sync.WaitGroup, params *models.Forcing_params, currentPath chan string) {
 	defer wg.Done()
 	for taskData := range currentPath {
-		QueryExecute(params, taskData, "POST")
+		QueryExecute(params, taskData, "GET")
 	}
 }
 

From c52c1240d7d1f932662d41088fa2c73604c5f804 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Sat, 31 Aug 2024 14:53:04 +0200
Subject: [PATCH 33/35] chore: remove duplicate directory

useless copy code
---
 cmd/callWorker.go   | 40 ----------------------------------------
 cmd/getFile.go      | 18 ------------------
 cmd/queryExecute.go | 35 -----------------------------------
 3 files changed, 93 deletions(-)
 delete mode 100644 cmd/callWorker.go
 delete mode 100644 cmd/getFile.go
 delete mode 100644 cmd/queryExecute.go

diff --git a/cmd/callWorker.go b/cmd/callWorker.go
deleted file mode 100644
index 4c9d7d3..0000000
--- a/cmd/callWorker.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package main
-
-import (
-  "time"
-)
-
-type forceData struct {
-	worker int
-	wordList string
-	url string
-}
-
-func executeQueryFromFile(data forceData, currentPath chan string) {
-  for taskData := range currentPath{
-    queryExecute(data, taskData, "POST")
-    }
-}
-
-func mainRequest(data forceData) {
-  channel := make(chan string)
-  wordArray := GetFileContent("../wordList/rootList")
-
-  for i := 0 ;i < data.worker; i++ {
-		go executeQueryFromFile(data, channel)
-	}
-  for i := 0; i < len(wordArray); i++ {
-    channel <- wordArray[i]
-  }
-  time.Sleep(1 * time.Second)
-  close(channel)
-}
-
-func main () {
-  data := forceData {
-    worker: 3,
-    wordList: "../wordList/rootList",
-    url: "http://localhost:3333",
-  }
-  mainRequest(data);
-}
\ No newline at end of file
diff --git a/cmd/getFile.go b/cmd/getFile.go
deleted file mode 100644
index 7accbb0..0000000
--- a/cmd/getFile.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package main
-
-import (
-    "os"
-    "fmt"
-    "log"
-	"strings"
-)
-
-func GetFileContent(filePath string) []string{
-    body, err := os.ReadFile(filePath)
-    if err != nil {
-        log.Fatalf("unable to read file: %v", err)
-    }
-	dataTab := strings.Split(string(body), "\n")
-    fmt.Println(dataTab[0])
-	return dataTab
-}
\ No newline at end of file
diff --git a/cmd/queryExecute.go b/cmd/queryExecute.go
deleted file mode 100644
index 42b7021..0000000
--- a/cmd/queryExecute.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"io/ioutil"
-	"net/http"
-)
-
-func queryExecute(data forceData, path string, method string) {
-
-	client := &http.Client{}
-	req, err := http.NewRequest(method, data.url + path, nil)
-	if err != nil {
-	  log.Fatal(err)
-	}
-
-	q := req.URL.Query()
-
-	req.URL.RawQuery = q.Encode()
-
-	resp, err := client.Do(req)
-	if err != nil {
-	  fmt.Println(err)
-	}
-
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-	  log.Fatal(err)
-	}
-
-	fmt.Println(string(body))
-  }
\ No newline at end of file

From b9ad7717946daee965712eb108d2123787838609 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Sat, 31 Aug 2024 18:36:39 +0200
Subject: [PATCH 34/35] fix(query): close channel before wait to avoid panic

---
 src/query/callWorker.go   | 4 +++-
 src/query/queryExecute.go | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 42ade5e..983f0df 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -22,9 +22,11 @@ func MainRequest(params *models.Forcing_params) {
 	for i := 0; i < params.Workers; i++ {
 		go executeQueryFromFile(wg, params, channel)
 	}
+
 	for i := 0; i < len(wordArray); i++ {
 		channel <- wordArray[i]
 	}
-	wg.Wait()
+
 	close(channel)
+	wg.Wait()
 }
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
index 5185636..9f8bcc4 100644
--- a/src/query/queryExecute.go
+++ b/src/query/queryExecute.go
@@ -15,13 +15,14 @@ func QueryExecute(params *models.Forcing_params, path string, method string) {
 	if err != nil {
 		log.Fatal(err)
 	}
+	log.Printf("NewRequest(%s)", params.Url+path)
 
 	q := req.URL.Query()
 	req.URL.RawQuery = q.Encode()
 
 	resp, err := client.Do(req)
 	if err != nil {
-		fmt.Println(err)
+		log.Fatal(err)
 	}
 	defer resp.Body.Close()
 
@@ -35,5 +36,4 @@ func QueryExecute(params *models.Forcing_params, path string, method string) {
 	} else {
 		log.Println(err)
 	}
-
 }

From be582a2aa149f24e3bd26875dd959facb34aadb4 Mon Sep 17 00:00:00 2001
From: Lou Onezime <lou.onezime@epitech.eu>
Date: Sat, 31 Aug 2024 18:38:57 +0200
Subject: [PATCH 35/35] chore: fix norm to camelcase

---
 src/cli/cli.go            | 10 +++++-----
 src/main.go               |  6 +++---
 src/models/models.go      |  2 +-
 src/query/callWorker.go   |  4 ++--
 src/query/queryExecute.go |  2 +-
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/cli/cli.go b/src/cli/cli.go
index a373dea..34f3d77 100644
--- a/src/cli/cli.go
+++ b/src/cli/cli.go
@@ -9,12 +9,12 @@ import (
 	"os"
 )
 
-func Parse_cli_args() (models.Forcing_params, error) {
-	var params models.Forcing_params
+func ParseCliArgs() (models.ForcingParams, error) {
+	var params models.ForcingParams
 
-	UrlError := errors.New("No url given")
-	ThreadsError := errors.New("Wrong number of threads given")
-	WordListError := errors.New("No wordlist given")
+	UrlError := errors.New("no url given")
+	ThreadsError := errors.New("wrong number of threads given")
+	WordListError := errors.New("no wordlist given")
 
 	forkptr := flag.Bool("v", false, "Verbose program")
 	statusPtr := flag.String("status-codes", "200,401,403,404,429,500", "Comma-separated list of status codes to match")
diff --git a/src/main.go b/src/main.go
index 9642a22..5441b4f 100644
--- a/src/main.go
+++ b/src/main.go
@@ -8,12 +8,12 @@ import (
 
 func main() {
 
-	forcing_params, err := cli.Parse_cli_args()
+	forcingParams, err := cli.ParseCliArgs()
 
 	if err != nil {
 		panic(err)
 	}
-	fmt.Println(forcing_params)
+	fmt.Println(forcingParams)
 
-	query.MainRequest(&forcing_params)
+	query.MainRequest(&forcingParams)
 }
diff --git a/src/models/models.go b/src/models/models.go
index e496d22..1e8ea73 100644
--- a/src/models/models.go
+++ b/src/models/models.go
@@ -10,7 +10,7 @@ type MatchCriteria struct {
 	BodyContains string
 }
 
-type Forcing_params struct {
+type ForcingParams struct {
 	Workers   int
 	Url       string
 	Wordlist  string
diff --git a/src/query/callWorker.go b/src/query/callWorker.go
index 983f0df..56332b9 100644
--- a/src/query/callWorker.go
+++ b/src/query/callWorker.go
@@ -6,14 +6,14 @@ import (
 	"sync"
 )
 
-func executeQueryFromFile(wg *sync.WaitGroup, params *models.Forcing_params, currentPath chan string) {
+func executeQueryFromFile(wg *sync.WaitGroup, params *models.ForcingParams, currentPath chan string) {
 	defer wg.Done()
 	for taskData := range currentPath {
 		QueryExecute(params, taskData, "GET")
 	}
 }
 
-func MainRequest(params *models.Forcing_params) {
+func MainRequest(params *models.ForcingParams) {
 	wg := &sync.WaitGroup{}
 	wg.Add(params.Workers)
 	channel := make(chan string)
diff --git a/src/query/queryExecute.go b/src/query/queryExecute.go
index 9f8bcc4..ca69493 100644
--- a/src/query/queryExecute.go
+++ b/src/query/queryExecute.go
@@ -9,7 +9,7 @@ import (
 	"net/http"
 )
 
-func QueryExecute(params *models.Forcing_params, path string, method string) {
+func QueryExecute(params *models.ForcingParams, path string, method string) {
 	client := &http.Client{}
 	req, err := http.NewRequest(method, params.Url+path, nil)
 	if err != nil {