Attempting to make a Rust API for Mythic

[Techno-Fox]

Last time we've talked about making a Golang API, for Mythic, you wanted me start an issue/pr on here to keep the code all in one place, one problem I've realized however is the file structure. Obviously this was made with python in mind, so in order to create a Golang API, we would first need to change the file structure if we want to keep all the code in the same place.

[its-a-feature]

Yeah, you could take all of the current stuff and put it in a pypi folder? and then make a new folder for go?

[Techno-Fox]

yes, I was just making sure that you were alright with that.

[Techno-Fox]

I've created a fork at https://github.com/Techno-Fox/Mythic_Scripting haven't updated yet, getting the basic structure of the project down first.

[Techno-Fox]

After a while of research on GraphQL, and trial and error. I've got an example that can send request and receive data.

[Techno-Fox]

I took the idea of http_post from the python version, and made a function like that to get access, and refresh tokens, then using an example query from the python version to test receiving data (GetAPITokens in this case).

package main

import (
	"bytes"
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"

	"github.com/machinebox/graphql"
)

type Auth struct {
	Username         string  `json:"username"`
	Password         string  `json:"password"`
	ScriptingVersion float64 `json:"scripting_version"`
}

type Tokens struct {
	AccessToken  string `json:"access_token"`
	RefreshToken string `json:"refresh_token"`
}

func HTTPPost(data []byte) Tokens {
	req, err := http.NewRequest("POST", "https://127.0.0.1:7443/auth", bytes.NewBuffer(data))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", "application/json")

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client := &http.Client{Transport: tr}

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	tokens := Tokens{}
	json.Unmarshal(body, &tokens)
	return tokens
}

func main() {
	auth := Auth{
		Username:         "<username>",
		Password:         "<password>",
		ScriptingVersion: 1.4,
	}
	data, _ := json.MarshalIndent(auth, "", "    ")

	tokens := HTTPPost(data)
	fmt.Println("Access token: ", tokens.AccessToken)

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	httpClient := &http.Client{Transport: tr}

	client := graphql.NewClient("https://127.0.0.1:7443/graphql/", graphql.WithHTTPClient(httpClient))

	req := graphql.NewRequest(`
		query GetAPITokens {
			apitokens(where: {active: {_eq: true}}) {
				token_value
				active
				id
			}
		}
	`)

	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", tokens.AccessToken))
	var response interface{}
	err := client.Run(context.Background(), req, &response)
	if err != nil {
		panic(err)
	}
	fmt.Println(response)
}

[Techno-Fox]

Just laying the ground work for this at the moment, but know I know how to handle (somewhat) GraphQL queries, (Next is mutations).

[Techno-Fox]

I figured that I should update you that I've dropped to golang api, and started creating the api in Rust. We should maybe rename this thread.