Bugfix/139 capabilities dont have the correct variable type on returning

internal/capability/http/http.go

@@ -58,7 +58,9 @@ func (httpCapability *HttpCapability) Execute(
 		return cacao.NewVariables(), err
 	}
 	respString := string(responseBytes)
-	variable := cacao.Variable{Name: httpApiResultVariableName, Value: respString}
+	variable := cacao.Variable{Type: cacao.VariableTypeString,
+		Name:  httpApiResultVariableName,
+		Value: respString}
 
 	return cacao.NewVariables(variable), nil
 

internal/capability/openc2/openc2.go

@@ -57,7 +57,9 @@ func (OpenC2Capability *OpenC2Capability) Execute(
 		return cacao.NewVariables(), err
 	}
 
-	results := cacao.NewVariables(cacao.Variable{Name: openc2ResultVariableName, Value: string(response)})
+	results := cacao.NewVariables(cacao.Variable{Type: cacao.VariableTypeString,
+		Name:  openc2ResultVariableName,
+		Value: string(response)})
 	log.Trace("Finished openc2 execution, will return the variables: ", results)
 	return results, nil
 }

internal/capability/ssh/ssh.go

@@ -99,7 +99,9 @@ func (sshCapability *SshCapability) Execute(metadata execution.Metadata,
 		log.Error(err)
 		return cacao.NewVariables(), err
 	}
-	results := cacao.NewVariables(cacao.Variable{Name: sshResultVariableName, Value: string(response)})
+	results := cacao.NewVariables(cacao.Variable{Type: cacao.VariableTypeString,
+		Name:  sshResultVariableName,
+		Value: string(response)})
 	log.Trace("Finished ssh execution will return the variables: ", results)
 	return results, err
 }

internal/fin/protocol/protocol.go

@@ -83,15 +83,15 @@ func (protocol *FinProtocol) SendCommand(command fin.Command) (cacao.Variables,
 	err = protocol.Publish(client, command)
 	if err != nil {
 		protocol.Disconnect(client)
-		return map[string]cacao.Variable{}, err
+		return cacao.NewVariables(), err
 	}
 	result, err := protocol.AwaitResultOrTimeout(command, client)
 	protocol.Disconnect(client)
 
 	return result, err
 }
 
-func (protocol *FinProtocol) AwaitResultOrTimeout(command fin.Command, client mqttlib.Client) (map[string]cacao.Variable, error) {
+func (protocol *FinProtocol) AwaitResultOrTimeout(command fin.Command, client mqttlib.Client) (cacao.Variables, error) {
 	timeout := command.CommandSubstructure.Context.Timeout
 
 	if command.CommandSubstructure.Context.Timeout == 0 {
@@ -107,7 +107,7 @@ func (protocol *FinProtocol) AwaitResultOrTimeout(command fin.Command, client mq
 		select {
 		case <-timer.C:
 			err := errors.New("no message received from fin while it was expected")
-			return map[string]cacao.Variable{}, err
+			return cacao.NewVariables(), err
 		case result := <-protocol.channel:
 			finMessage := fin.Message{}
 			err := fin.Decode(result, &finMessage)
@@ -124,7 +124,7 @@ func (protocol *FinProtocol) AwaitResultOrTimeout(command fin.Command, client mq
 				err := fin.Decode(result, &finResult)
 				if err != nil {
 					log.Trace(err)
-					return map[string]cacao.Variable{}, err
+					return cacao.NewVariables(), err
 				}
 
 				if ackReceived {

models/cacao/cacao.go

@@ -51,6 +51,24 @@ type Variable struct {
 	External    bool   `bson:"external,omitempty" json:"external,omitempty"`
 }
 
+const (
+	VariableTypeBool        = "bool"
+	VariableTypeDictionary  = "dictionary"
+	VariableTypeFloat       = "float"
+	VariableTypeHexString   = "hexstring"
+	VariableTypeInt         = "integer"
+	VariableTypeIpv4Address = "ipv4-addr"
+	VariableTypeIpv6Address = "ipv6-addr"
+	VariableTypeLong        = "long"
+	VariableTypeMacAddress  = "mac-addr"
+	VariableTypeHash        = "hash"
+	VariableTypeMd5Has      = "md5-hash"
+	VariableTypeSha256      = "sha256-hash"
+	VariableTypeString      = "string"
+	VariableTypeUri         = "uri"
+	VariableTypeUuid        = "uuid"
+)
+
 type Variables map[string]Variable
 
 type Playbook struct {

test/unittest/finprotocol/finprotocol_test.go

@@ -47,7 +47,7 @@ func TestTimeoutAndCallbackTimerElaspsed(t *testing.T) {
 	result, err := prot.AwaitResultOrTimeout(expectedCommand, &mock_client)
 
 	assert.Equal(t, err, errors.New("no message received from fin while it was expected"))
-	assert.Equal(t, result, map[string]cacao.Variable{})
+	assert.Equal(t, result, cacao.NewVariables())
 }
 
 func TestTimeoutAndCallbackHandlerCalled(t *testing.T) {
@@ -76,7 +76,7 @@ func TestTimeoutAndCallbackHandlerCalled(t *testing.T) {
 	fmt.Println("done waiting")
 
 	assert.Equal(t, err, nil)
-	assert.Equal(t, result, map[string]cacao.Variable{"test": {Name: "test"}})
+	assert.Equal(t, result, cacao.NewVariables(cacao.Variable{Name: "test"}))
 	mock_client.AssertExpectations(t)
 	mock_token.AssertExpectations(t)
 	mock_token_ack.AssertExpectations(t)
@@ -106,7 +106,7 @@ func helper(prot *protocol.FinProtocol) {
 
 	result := fin.Result{}
 	result.Type = fin.MessageTypeResult
-	result.ResultStructure.Variables = map[string]cacao.Variable{"test": {Name: "test"}}
+	result.ResultStructure.Variables = cacao.NewVariables(cacao.Variable{Name: "test"})
 
 	payload, err := json.Marshal(result)
 	if err != nil {