From 377dc47eace8ef71853b250e979363aa34fbe534 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 22 Mar 2023 15:46:49 +0100 Subject: [PATCH 01/28] pointer bug fix --- mtdaws/utils.go | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/mtdaws/utils.go b/mtdaws/utils.go index b59805b..8f7a2ae 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -77,11 +77,11 @@ func PrintInstanceInfo(instance *types.Instance) { } // Instances returns all instances for a config i.e. a region -func Instances(config aws.Config) ([]*types.Instance, error) { +func Instances(config aws.Config) ([]types.Instance, error) { svc := ec2.NewFromConfig(config) input := &ec2.DescribeInstancesInput{} - var instances []*types.Instance + var instances []types.Instance paginator := ec2.NewDescribeInstancesPaginator(svc, input) @@ -93,10 +93,9 @@ func Instances(config aws.Config) ([]*types.Instance, error) { for _, reservation := range page.Reservations { for _, instance := range reservation.Instances { - instances = append(instances, &instance) + instances = append(instances, instance) } } } - return instances, nil } From 83383a41568c245e4d7889307d0bc29785586175 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 22 Mar 2023 15:46:58 +0100 Subject: [PATCH 02/28] prints --- main.go | 1 + mtdaws/utils.go | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/main.go b/main.go index 3db5399..423a9a9 100644 --- a/main.go +++ b/main.go @@ -38,6 +38,7 @@ func indexInstances(config state.Config) state.Config { } newService, found := indexInstance(config, cloudID, ip) if !found { + fmt.Println("New instance found:", newService.CloudID) config.MTD.Services = append(config.MTD.Services, newService) state.SaveConf(ConfigPath, config) } diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 8f7a2ae..41356a7 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -46,8 +46,6 @@ func GetInstances(config state.Config) []AwsInstance { fmt.Println("Error listing instances:", err) continue } - - //fmt.Println("Listing instances in region:", region) for _, instance := range instances { var publicAddr string if instance.PublicIpAddress != nil { @@ -66,6 +64,7 @@ func GetInstances(config state.Config) []AwsInstance { // PrintInstanceInfo prints info about a specific instance in a region func PrintInstanceInfo(instance *types.Instance) { fmt.Println("\tInstance ID:", aws.ToString(instance.InstanceId)) + fmt.Println("\t\tInstance DNS name:", aws.ToString(instance.PublicDnsName)) fmt.Println("\t\tInstance Type:", string(instance.InstanceType)) fmt.Println("\t\tAMI ID:", aws.ToString(instance.ImageId)) fmt.Println("\t\tState:", string(instance.State.Name)) From cb7ac73acb3906785dbe2491889ea777563b1daf Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 28 Mar 2023 16:08:42 +0200 Subject: [PATCH 03/28] utils functions that *should* enable MTD --- mtdaws/utils.go | 79 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 41356a7..2f8b440 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -4,6 +4,8 @@ import ( "context" "fmt" "os" + "strings" + "time" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" @@ -36,6 +38,17 @@ func GetCloudID(instance AwsInstance) string { return "aws_" + instance.Region + "_" + instance.InstanceID } +// DecodeCloudID returns information to locate instance in aws +func DecodeCloudID(cloudID string) (string, string) { + split := strings.Split(cloudID, "_") + if len(split) != 3 { + panic(cloudID + " does not decode as AWS CloudID") + } + region := split[1] + instanceID := split[2] + return region, instanceID +} + // GetInstances scans all configured regions for instances and add them to services func GetInstances(config state.Config) []AwsInstance { awsInstances := []AwsInstance{} @@ -98,3 +111,69 @@ func Instances(config aws.Config) ([]types.Instance, error) { } return instances, nil } + +// createImage will create an AMI (amazon machine image) of a given instance +func createImage(svc *ec2.Client, instanceID string) (string, error) { + input := &ec2.CreateImageInput{ + InstanceId: aws.String(instanceID), + Name: aws.String(fmt.Sprintf("backup-%s-%d", instanceID, time.Now().Unix())), + Description: aws.String("Migration backup"), + NoReboot: aws.Bool(true), + } + + output, err := svc.CreateImage(context.TODO(), input) + if err != nil { + return "", err + } + + return aws.ToString(output.ImageId), nil +} + +// launchInstance launches a instance specified by id with parameters +func launchInstance(svc *ec2.Client, instance *types.Instance, imageID string) (string, error) { + securityGroupIds := make([]string, len(instance.SecurityGroups)) + for i, sg := range instance.SecurityGroups { + securityGroupIds[i] = aws.ToString(sg.GroupId) + } + + input := &ec2.RunInstancesInput{ + ImageId: aws.String(imageID), + InstanceType: instance.InstanceType, + MinCount: aws.Int32(1), + MaxCount: aws.Int32(1), + KeyName: instance.KeyName, + SubnetId: instance.SubnetId, + SecurityGroupIds: securityGroupIds, + } + + output, err := svc.RunInstances(context.TODO(), input) + if err != nil { + return "", err + } + + return aws.ToString(output.Instances[0].InstanceId), nil +} + +// terminateInstance kills an instance by id +func terminateInstance(svc *ec2.Client, instanceID string) error { + input := &ec2.TerminateInstancesInput{ + InstanceIds: []string{instanceID}, + } + + _, err := svc.TerminateInstances(context.TODO(), input) + return err +} + +// getInstanceDetailsFromString does what the name says +func getInstanceDetailsFromString(svc *ec2.Client, instanceID string) (*types.Instance, error) { + input := &ec2.DescribeInstancesInput{ + InstanceIds: []string{instanceID}, + } + + output, err := svc.DescribeInstances(context.TODO(), input) + if err != nil { + return nil, err + } + + return &output.Reservations[0].Instances[0], nil +} From d9aa192cd1a35c9c566765404e1c5cd26ad1c35f Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 28 Mar 2023 16:09:14 +0200 Subject: [PATCH 04/28] move a hardcoded instance (not working) --- mtdaws/mtd.go | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 mtdaws/mtd.go diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go new file mode 100644 index 0000000..cbd1d4c --- /dev/null +++ b/mtdaws/mtd.go @@ -0,0 +1,46 @@ +package mtdaws + +import ( + "fmt" + + "github.com/aws/aws-sdk-go-v2/service/ec2" + "github.com/thefeli73/polemos/state" +) + +// AWSMoveInstance moves a specified instance to a new availability region +func AWSMoveInstance(config state.Config) (state.Config) { + instance := config.MTD.Services[0] // for testing use first instance + region, instanceID := DecodeCloudID(instance.CloudID) + awsConfig := NewConfig(region, config.AWS.CredentialsPath) + svc := ec2.NewFromConfig(awsConfig) + + realInstance, err := getInstanceDetailsFromString(svc, instanceID) + if err != nil { + fmt.Println("Error getting instance details:", err) + return config + } + + imageName, err := createImage(svc, instanceID) + if err != nil { + fmt.Println("Error creating image:", err) + return config + } + fmt.Println("Created image: ", imageName) + + newInstanceID, err := launchInstance(svc, realInstance, imageName) + if err != nil { + fmt.Println("Error launching instance:", err) + return config + } + fmt.Println("Launched new instance:", newInstanceID) + + err = terminateInstance(svc, instanceID) + if err != nil { + fmt.Println("Error terminating instance:", err) + return config + } + fmt.Println("Terminated original instance:", instanceID) + + + return config +} From d0cd4340a5fd121fa1a15c2e5cb086a59b29fda2 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 28 Mar 2023 16:09:30 +0200 Subject: [PATCH 05/28] stuff --- main.go | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/main.go b/main.go index 423a9a9..a185c29 100644 --- a/main.go +++ b/main.go @@ -20,14 +20,26 @@ func main() { config := state.LoadConf(ConfigPath) state.SaveConf(ConfigPath, config) - config = indexInstances(config) + config = indexAllInstances(config) + //TODO: figure out migration (MTD) + config = movingTargetDefense(config) + + //TODO: proxy commands } -func indexInstances(config state.Config) state.Config { +func movingTargetDefense(config state.Config) state.Config{ + + mtdaws.AWSMoveInstance(config) + return config +} + +func indexAllInstances(config state.Config) state.Config { fmt.Println("Indexing instances") //index AWS instances + awsNewInstanceCounter := 0 + awsInstanceCounter := 0 awsInstances := mtdaws.GetInstances(config) for _, instance := range awsInstances { cloudID := mtdaws.GetCloudID(instance) @@ -41,8 +53,13 @@ func indexInstances(config state.Config) state.Config { fmt.Println("New instance found:", newService.CloudID) config.MTD.Services = append(config.MTD.Services, newService) state.SaveConf(ConfigPath, config) + awsNewInstanceCounter++ } + awsInstanceCounter++ } + fmt.Printf("Found %d AWS instances (%d newly added)\n", awsInstanceCounter, awsNewInstanceCounter) + + return config } From c6c26bd9146d205ca661e681d6c81d125f34fc44 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 11 Apr 2023 12:55:38 +0200 Subject: [PATCH 06/28] remove UUIDs --- main.go | 8 ++++---- state/config.go | 20 -------------------- 2 files changed, 4 insertions(+), 24 deletions(-) diff --git a/main.go b/main.go index a185c29..4ca5190 100644 --- a/main.go +++ b/main.go @@ -4,7 +4,6 @@ import ( "fmt" "net/netip" - "github.com/google/uuid" "github.com/thefeli73/polemos/mtdaws" "github.com/thefeli73/polemos/state" ) @@ -39,6 +38,7 @@ func indexAllInstances(config state.Config) state.Config { //index AWS instances awsNewInstanceCounter := 0 + awsRemovedInstanceCounter := 0 awsInstanceCounter := 0 awsInstances := mtdaws.GetInstances(config) for _, instance := range awsInstances { @@ -57,7 +57,8 @@ func indexAllInstances(config state.Config) state.Config { } awsInstanceCounter++ } - fmt.Printf("Found %d AWS instances (%d newly added)\n", awsInstanceCounter, awsNewInstanceCounter) + // TODO: Purge instances in config that are not found in the cloud + fmt.Printf("Found %d AWS instances (%d newly added, %d removed)\n", awsInstanceCounter, awsNewInstanceCounter, awsRemovedInstanceCounter) return config @@ -68,11 +69,10 @@ func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (s for _, service := range config.MTD.Services { if service.CloudID == cloudID { found = true + break; } } - u := uuid.New() newService := state.Service{ - ID: state.CustomUUID(u), CloudID: cloudID, ServiceIP: serviceIP} return newService, found diff --git a/state/config.go b/state/config.go index a74c59e..628df3f 100644 --- a/state/config.go +++ b/state/config.go @@ -6,7 +6,6 @@ import ( "net/netip" "os" - "github.com/google/uuid" "gopkg.in/yaml.v3" ) @@ -22,7 +21,6 @@ type mtdconf struct { // Service contains all necessary information about a service to identify it in the cloud as well as configuring a proxy for it type Service struct { - ID CustomUUID `yaml:"id"` CloudID string `yaml:"cloud_id"` EntryIP netip.Addr `yaml:"entry_ip"` EntryPort uint16 `yaml:"entry_port"` @@ -30,29 +28,11 @@ type Service struct { ServicePort uint16 `yaml:"service_port"` } -// CustomUUID is an alias for uuid.UUID to enable custom unmarshal function -type CustomUUID uuid.UUID - type aws struct { Regions []string `yaml:"regions"` CredentialsPath string `yaml:"credentials_path"` } -// UnmarshalYAML parses uuid in yaml to CustomUUID type -func (u *CustomUUID) UnmarshalYAML(value *yaml.Node) error { - id, err := uuid.Parse(value.Value) - if err != nil { - return err - } - *u = CustomUUID(id) - return nil -} - -// MarshalYAML parses CustomUUID type to uuid string for yaml -func (u CustomUUID) MarshalYAML() (interface{}, error) { - return uuid.UUID(u).String(), nil -} - // LoadConf loads config from a yaml file func LoadConf(filename string) (Config) { var config Config From 7bd42bc569dfd8073a951cb8974b129d90551b41 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 11 Apr 2023 12:56:07 +0200 Subject: [PATCH 07/28] Wait for image ready (migration working --- mtdaws/mtd.go | 8 ++++++++ mtdaws/utils.go | 49 +++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 49 insertions(+), 8 deletions(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index cbd1d4c..ab60d50 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -2,6 +2,7 @@ package mtdaws import ( "fmt" + "time" "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/thefeli73/polemos/state" @@ -27,6 +28,13 @@ func AWSMoveInstance(config state.Config) (state.Config) { } fmt.Println("Created image: ", imageName) + err = waitForImageReady(svc, imageName, 5*time.Minute) + if err != nil { + fmt.Println("Error waiting for image to be ready:", err) + return config + } + fmt.Println("Image is ready:", imageName) + newInstanceID, err := launchInstance(svc, realInstance, imageName) if err != nil { fmt.Println("Error launching instance:", err) diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 2f8b440..429ffb3 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -2,6 +2,7 @@ package mtdaws import ( "context" + "errors" "fmt" "os" "strings" @@ -129,21 +130,49 @@ func createImage(svc *ec2.Client, instanceID string) (string, error) { return aws.ToString(output.ImageId), nil } -// launchInstance launches a instance specified by id with parameters -func launchInstance(svc *ec2.Client, instance *types.Instance, imageID string) (string, error) { - securityGroupIds := make([]string, len(instance.SecurityGroups)) - for i, sg := range instance.SecurityGroups { +// waitForImageReady polls every second to see if the image is ready +func waitForImageReady(svc *ec2.Client, imageID string, timeout time.Duration) error { + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + + for { + select { + case <-ctx.Done(): + return errors.New("timed out waiting for image to be ready") + case <-time.After(1 * time.Second): + input := &ec2.DescribeImagesInput{ + ImageIds: []string{imageID}, + } + output, err := svc.DescribeImages(ctx, input) + if err != nil { + return err + } + + if len(output.Images) > 0 && output.Images[0].State == types.ImageStateAvailable { + return nil + } + } + } +} + +// launchInstance launches a instance based on an oldInstance and AMI (duplicating the instance) +func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string) (string, error) { + securityGroupIds := make([]string, len(oldInstance.SecurityGroups)) + for i, sg := range oldInstance.SecurityGroups { securityGroupIds[i] = aws.ToString(sg.GroupId) } - + // TODO: select random zone that is not the current one. + availabilityZone := "us-east-1d" input := &ec2.RunInstancesInput{ ImageId: aws.String(imageID), - InstanceType: instance.InstanceType, + InstanceType: oldInstance.InstanceType, MinCount: aws.Int32(1), MaxCount: aws.Int32(1), - KeyName: instance.KeyName, - SubnetId: instance.SubnetId, + KeyName: oldInstance.KeyName, SecurityGroupIds: securityGroupIds, + Placement: &types.Placement{ + AvailabilityZone: aws.String(availabilityZone), + }, } output, err := svc.RunInstances(context.TODO(), input) @@ -151,6 +180,8 @@ func launchInstance(svc *ec2.Client, instance *types.Instance, imageID string) ( return "", err } + // TODO: save/index config for the new instance + return aws.ToString(output.Instances[0].InstanceId), nil } @@ -161,6 +192,8 @@ func terminateInstance(svc *ec2.Client, instanceID string) error { } _, err := svc.TerminateInstances(context.TODO(), input) + + // TODO: remove config for old instance return err } From 65d815aa8b80836ed9ca334814d7540f18e7934c Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 12 Apr 2023 10:16:22 +0200 Subject: [PATCH 08/28] remove old image and snapshot, formatting --- main.go | 4 ++-- mtdaws/mtd.go | 41 +++++++++++++++++++++++++++++--------- mtdaws/utils.go | 52 ++++++++++++++++++++++++++++++++++++------------- 3 files changed, 72 insertions(+), 25 deletions(-) diff --git a/main.go b/main.go index 4ca5190..f7a5ef4 100644 --- a/main.go +++ b/main.go @@ -45,12 +45,12 @@ func indexAllInstances(config state.Config) state.Config { cloudID := mtdaws.GetCloudID(instance) ip, err := netip.ParseAddr(instance.PublicIP) if err != nil { - fmt.Println("Error converting ip:", err) + fmt.Println("Error converting ip:\t", err) continue } newService, found := indexInstance(config, cloudID, ip) if !found { - fmt.Println("New instance found:", newService.CloudID) + fmt.Println("New instance found:\t", newService.CloudID) config.MTD.Services = append(config.MTD.Services, newService) state.SaveConf(ConfigPath, config) awsNewInstanceCounter++ diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index ab60d50..c307f50 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -4,6 +4,7 @@ import ( "fmt" "time" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/thefeli73/polemos/state" ) @@ -17,38 +18,60 @@ func AWSMoveInstance(config state.Config) (state.Config) { realInstance, err := getInstanceDetailsFromString(svc, instanceID) if err != nil { - fmt.Println("Error getting instance details:", err) + fmt.Println("Error getting instance details:\t", err) return config } imageName, err := createImage(svc, instanceID) if err != nil { - fmt.Println("Error creating image:", err) + fmt.Println("Error creating image:\t", err) return config } - fmt.Println("Created image: ", imageName) + fmt.Println("Created image:\t", imageName) err = waitForImageReady(svc, imageName, 5*time.Minute) if err != nil { - fmt.Println("Error waiting for image to be ready:", err) + fmt.Println("Error waiting for image to be ready:\t", err) return config } - fmt.Println("Image is ready:", imageName) + fmt.Println("Image is ready:\t", imageName) newInstanceID, err := launchInstance(svc, realInstance, imageName) if err != nil { - fmt.Println("Error launching instance:", err) + fmt.Println("Error launching instance:\t", err) return config } - fmt.Println("Launched new instance:", newInstanceID) + fmt.Println("Launched new instance:\t", newInstanceID) err = terminateInstance(svc, instanceID) if err != nil { - fmt.Println("Error terminating instance:", err) + fmt.Println("Error terminating instance:\t", err) return config } - fmt.Println("Terminated original instance:", instanceID) + fmt.Println("Terminated old instance:\t", instanceID) + image, err := describeImage(svc, imageName) + if err != nil { + fmt.Println("Error describing image:\t", err) + return config + } + + err = deregisterImage(svc, imageName) + if err != nil { + fmt.Println("Error deregistering image:\t", err) + return config + } + fmt.Println("Deregistered image:\t", imageName) + + if len(image.BlockDeviceMappings) > 0 { + snapshotID := aws.ToString(image.BlockDeviceMappings[0].Ebs.SnapshotId) + err = deleteSnapshot(svc, snapshotID) + if err != nil { + fmt.Println("Error deleting snapshot:\t", err) + return config + } + fmt.Println("Deleted snapshot:\t", snapshotID) + } return config } diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 429ffb3..32e87ed 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -75,20 +75,6 @@ func GetInstances(config state.Config) []AwsInstance { return awsInstances } -// PrintInstanceInfo prints info about a specific instance in a region -func PrintInstanceInfo(instance *types.Instance) { - fmt.Println("\tInstance ID:", aws.ToString(instance.InstanceId)) - fmt.Println("\t\tInstance DNS name:", aws.ToString(instance.PublicDnsName)) - fmt.Println("\t\tInstance Type:", string(instance.InstanceType)) - fmt.Println("\t\tAMI ID:", aws.ToString(instance.ImageId)) - fmt.Println("\t\tState:", string(instance.State.Name)) - fmt.Println("\t\tAvailability Zone:", aws.ToString(instance.Placement.AvailabilityZone)) - if instance.PublicIpAddress != nil { - fmt.Println("\t\tPublic IP Address:", aws.ToString(instance.PublicIpAddress)) - } - fmt.Println("\t\tPrivate IP Address:", aws.ToString(instance.PrivateIpAddress)) -} - // Instances returns all instances for a config i.e. a region func Instances(config aws.Config) ([]types.Instance, error) { svc := ec2.NewFromConfig(config) @@ -197,6 +183,44 @@ func terminateInstance(svc *ec2.Client, instanceID string) error { return err } +// describeImage gets info about an image from string +func describeImage(svc *ec2.Client, imageID string) (*types.Image, error) { + input := &ec2.DescribeImagesInput{ + ImageIds: []string{imageID}, + } + + output, err := svc.DescribeImages(context.TODO(), input) + if err != nil { + return nil, err + } + + if len(output.Images) == 0 { + return nil, errors.New("image not found") + } + + return &output.Images[0], nil +} + +// deregisterImage deletes the AMI passed as string +func deregisterImage(svc *ec2.Client, imageID string) error { + input := &ec2.DeregisterImageInput{ + ImageId: aws.String(imageID), + } + + _, err := svc.DeregisterImage(context.TODO(), input) + return err +} + +// deleteSnapshot deletes the snapshot passed as string +func deleteSnapshot(svc *ec2.Client, snapshotID string) error { + input := &ec2.DeleteSnapshotInput{ + SnapshotId: aws.String(snapshotID), + } + + _, err := svc.DeleteSnapshot(context.TODO(), input) + return err +} + // getInstanceDetailsFromString does what the name says func getInstanceDetailsFromString(svc *ec2.Client, instanceID string) (*types.Instance, error) { input := &ec2.DescribeInstancesInput{ From c6465ec429265e0d31ef68bfe457eefa4414e76d Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 12 Apr 2023 11:13:53 +0200 Subject: [PATCH 09/28] Revert UUID purge --- main.go | 3 +++ state/config.go | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/main.go b/main.go index f7a5ef4..73e4e72 100644 --- a/main.go +++ b/main.go @@ -4,6 +4,7 @@ import ( "fmt" "net/netip" + "github.com/google/uuid" "github.com/thefeli73/polemos/mtdaws" "github.com/thefeli73/polemos/state" ) @@ -72,7 +73,9 @@ func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (s break; } } + u := uuid.New() newService := state.Service{ + ID: state.CustomUUID(u), CloudID: cloudID, ServiceIP: serviceIP} return newService, found diff --git a/state/config.go b/state/config.go index 628df3f..a74c59e 100644 --- a/state/config.go +++ b/state/config.go @@ -6,6 +6,7 @@ import ( "net/netip" "os" + "github.com/google/uuid" "gopkg.in/yaml.v3" ) @@ -21,6 +22,7 @@ type mtdconf struct { // Service contains all necessary information about a service to identify it in the cloud as well as configuring a proxy for it type Service struct { + ID CustomUUID `yaml:"id"` CloudID string `yaml:"cloud_id"` EntryIP netip.Addr `yaml:"entry_ip"` EntryPort uint16 `yaml:"entry_port"` @@ -28,11 +30,29 @@ type Service struct { ServicePort uint16 `yaml:"service_port"` } +// CustomUUID is an alias for uuid.UUID to enable custom unmarshal function +type CustomUUID uuid.UUID + type aws struct { Regions []string `yaml:"regions"` CredentialsPath string `yaml:"credentials_path"` } +// UnmarshalYAML parses uuid in yaml to CustomUUID type +func (u *CustomUUID) UnmarshalYAML(value *yaml.Node) error { + id, err := uuid.Parse(value.Value) + if err != nil { + return err + } + *u = CustomUUID(id) + return nil +} + +// MarshalYAML parses CustomUUID type to uuid string for yaml +func (u CustomUUID) MarshalYAML() (interface{}, error) { + return uuid.UUID(u).String(), nil +} + // LoadConf loads config from a yaml file func LoadConf(filename string) (Config) { var config Config From 03eff229c6045c2adce33a10b84274aabfc22f88 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 12 Apr 2023 15:31:11 +0200 Subject: [PATCH 10/28] switch from list (slice) to dict (map) --- main.go | 7 ++++++- mtdaws/mtd.go | 18 ++++++++++++++---- state/config.go | 4 ++-- 3 files changed, 22 insertions(+), 7 deletions(-) diff --git a/main.go b/main.go index 73e4e72..473b76e 100644 --- a/main.go +++ b/main.go @@ -17,9 +17,14 @@ func main() { ConfigPath = "config.yaml" - config := state.LoadConf(ConfigPath) + // Initialize the config.Services map + var config state.Config + config.MTD.Services = make(map[state.CustomUUID]state.Service) + + config = state.LoadConf(ConfigPath) state.SaveConf(ConfigPath, config) + config = indexAllInstances(config) //TODO: figure out migration (MTD) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index c307f50..e45e4ca 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -11,7 +11,17 @@ import ( // AWSMoveInstance moves a specified instance to a new availability region func AWSMoveInstance(config state.Config) (state.Config) { - instance := config.MTD.Services[0] // for testing use first instance + // pseudorandom instance from all services for testing + var serviceUUID state.CustomUUID + var instance state.Service + for key, service := range config.MTD.Services { + serviceUUID = key + instance = service + break + } + + fmt.Println("MTD move service:\t", serviceUUID) + region, instanceID := DecodeCloudID(instance.CloudID) awsConfig := NewConfig(region, config.AWS.CredentialsPath) svc := ec2.NewFromConfig(awsConfig) @@ -27,14 +37,14 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("Error creating image:\t", err) return config } - fmt.Println("Created image:\t", imageName) + fmt.Println("Created image:\t\t", imageName) err = waitForImageReady(svc, imageName, 5*time.Minute) if err != nil { fmt.Println("Error waiting for image to be ready:\t", err) return config } - fmt.Println("Image is ready:\t", imageName) + fmt.Println("Image is ready:\t\t", imageName) newInstanceID, err := launchInstance(svc, realInstance, imageName) if err != nil { @@ -48,7 +58,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("Error terminating instance:\t", err) return config } - fmt.Println("Terminated old instance:\t", instanceID) + fmt.Println("Killed old instance:\t", instanceID) image, err := describeImage(svc, imageName) if err != nil { diff --git a/state/config.go b/state/config.go index a74c59e..395f9a0 100644 --- a/state/config.go +++ b/state/config.go @@ -17,12 +17,12 @@ type Config struct { } type mtdconf struct { - Services []Service `yaml:"services"` + Services map[CustomUUID]Service `yaml:"services"` + } // Service contains all necessary information about a service to identify it in the cloud as well as configuring a proxy for it type Service struct { - ID CustomUUID `yaml:"id"` CloudID string `yaml:"cloud_id"` EntryIP netip.Addr `yaml:"entry_ip"` EntryPort uint16 `yaml:"entry_port"` From 61175acc67f8118125d53348c858d1488f0937fb Mon Sep 17 00:00:00 2001 From: schulze Date: Mon, 17 Apr 2023 15:20:40 +0200 Subject: [PATCH 11/28] update services config after MTD --- mtdaws/mtd.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index e45e4ca..3f81795 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -2,6 +2,7 @@ package mtdaws import ( "fmt" + "net/netip" "time" "github.com/aws/aws-sdk-go-v2/aws" @@ -9,6 +10,32 @@ import ( "github.com/thefeli73/polemos/state" ) +// AWSUpdateService updates a specified service config to match a newly moved instance +func AWSUpdateService(config state.Config, region string, service state.CustomUUID, newInstanceID string) (state.Config) { + awsConfig := NewConfig(region, config.AWS.CredentialsPath) + svc := ec2.NewFromConfig(awsConfig) + instance, err := getInstanceDetailsFromString(svc, newInstanceID) + if err != nil { + fmt.Println("Error getting instance details:\t", err) + return config + } + + var publicAddr string + if instance.PublicIpAddress != nil { + publicAddr = aws.ToString(instance.PublicIpAddress) + } + formattedinstance := AwsInstance{ + InstanceID: aws.ToString(instance.InstanceId), + Region: region, + PublicIP: publicAddr, + PrivateIP: aws.ToString(instance.PrivateIpAddress), + } + cloudid := GetCloudID(formattedinstance) + serviceip := netip.MustParseAddr(publicAddr) + config.MTD.Services[service] = state.Service{CloudID: cloudid, ServiceIP: serviceip} + return config +} + // AWSMoveInstance moves a specified instance to a new availability region func AWSMoveInstance(config state.Config) (state.Config) { // pseudorandom instance from all services for testing @@ -83,5 +110,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("Deleted snapshot:\t", snapshotID) } + AWSUpdateService(config, region, serviceUUID, newInstanceID) + return config } From 3fb51d8f84dba015524d671581c7362e3152fbd9 Mon Sep 17 00:00:00 2001 From: schulze Date: Mon, 17 Apr 2023 15:21:06 +0200 Subject: [PATCH 12/28] misc --- config.default.yaml | 2 +- main.go | 29 +++++++++++++++-------------- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/config.default.yaml b/config.default.yaml index 4420f39..77240ff 100644 --- a/config.default.yaml +++ b/config.default.yaml @@ -1,5 +1,5 @@ mtd: - services: [] + services: {} aws: regions: [] credentials_path: ./mtdaws/.credentials diff --git a/main.go b/main.go index 473b76e..774efbd 100644 --- a/main.go +++ b/main.go @@ -26,9 +26,11 @@ func main() { config = indexAllInstances(config) + state.SaveConf(ConfigPath, config) //TODO: figure out migration (MTD) config = movingTargetDefense(config) + state.SaveConf(ConfigPath, config) //TODO: proxy commands } @@ -54,13 +56,9 @@ func indexAllInstances(config state.Config) state.Config { fmt.Println("Error converting ip:\t", err) continue } - newService, found := indexInstance(config, cloudID, ip) - if !found { - fmt.Println("New instance found:\t", newService.CloudID) - config.MTD.Services = append(config.MTD.Services, newService) - state.SaveConf(ConfigPath, config) - awsNewInstanceCounter++ - } + var found bool + config, found = indexInstance(config, cloudID, ip) + if !found {awsNewInstanceCounter++} awsInstanceCounter++ } // TODO: Purge instances in config that are not found in the cloud @@ -70,7 +68,7 @@ func indexAllInstances(config state.Config) state.Config { return config } -func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (state.Service, bool) { +func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (state.Config, bool) { found := false for _, service := range config.MTD.Services { if service.CloudID == cloudID { @@ -78,10 +76,13 @@ func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (s break; } } - u := uuid.New() - newService := state.Service{ - ID: state.CustomUUID(u), - CloudID: cloudID, - ServiceIP: serviceIP} - return newService, found + + if !found { + fmt.Println("New instance found:\t", cloudID) + u := uuid.New() + config.MTD.Services[state.CustomUUID(u)] = state.Service{CloudID: cloudID, ServiceIP: serviceIP} + state.SaveConf(ConfigPath, config) + + } + return config, found } From e8962c3cba8c47c73b7bce93466d7bd6e44231fe Mon Sep 17 00:00:00 2001 From: schulze Date: Mon, 17 Apr 2023 15:54:42 +0200 Subject: [PATCH 13/28] Availability zone randomisation --- mtdaws/mtd.go | 6 ++++-- mtdaws/utils.go | 54 ++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 55 insertions(+), 5 deletions(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index 3f81795..8e428ae 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -7,6 +7,7 @@ import ( "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/ec2" + "github.com/google/uuid" "github.com/thefeli73/polemos/state" ) @@ -38,6 +39,7 @@ func AWSUpdateService(config state.Config, region string, service state.CustomUU // AWSMoveInstance moves a specified instance to a new availability region func AWSMoveInstance(config state.Config) (state.Config) { + // pseudorandom instance from all services for testing var serviceUUID state.CustomUUID var instance state.Service @@ -47,7 +49,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { break } - fmt.Println("MTD move service:\t", serviceUUID) + fmt.Println("MTD move service:\t", uuid.UUID.String(uuid.UUID(serviceUUID))) region, instanceID := DecodeCloudID(instance.CloudID) awsConfig := NewConfig(region, config.AWS.CredentialsPath) @@ -73,7 +75,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { } fmt.Println("Image is ready:\t\t", imageName) - newInstanceID, err := launchInstance(svc, realInstance, imageName) + newInstanceID, err := launchInstance(svc, realInstance, imageName, region) if err != nil { fmt.Println("Error launching instance:\t", err) return config diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 32e87ed..2d4d5a4 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "math/rand" "os" "strings" "time" @@ -141,14 +142,18 @@ func waitForImageReady(svc *ec2.Client, imageID string, timeout time.Duration) e } } -// launchInstance launches a instance based on an oldInstance and AMI (duplicating the instance) -func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string) (string, error) { +// launchInstance launches a instance IN RANDOM AVAILABILITY ZONE within the same region, based on an oldInstance and AMI (duplicating the instance) +func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string, region string) (string, error) { securityGroupIds := make([]string, len(oldInstance.SecurityGroups)) for i, sg := range oldInstance.SecurityGroups { securityGroupIds[i] = aws.ToString(sg.GroupId) } // TODO: select random zone that is not the current one. - availabilityZone := "us-east-1d" + availabilityZone, err := getRandomDifferentAvailabilityZone(svc, oldInstance, region) + if err != nil { + return "", err + } + input := &ec2.RunInstancesInput{ ImageId: aws.String(imageID), InstanceType: oldInstance.InstanceType, @@ -171,6 +176,49 @@ func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string return aws.ToString(output.Instances[0].InstanceId), nil } +// getRandomDifferentAvailabilityZone fetches all AZ from the same region as the instance and returns a random AZ that is not equal to the one used by the instance +func getRandomDifferentAvailabilityZone(svc *ec2.Client, instance *types.Instance, region string) (string, error) { + // Seed the random generator + rand.Seed(time.Now().UnixNano()) + + // Get the current availability zone of the instance + currentAZ := aws.ToString(instance.Placement.AvailabilityZone) + + // Describe availability zones in the region + input := &ec2.DescribeAvailabilityZonesInput{ + Filters: []types.Filter{ + { + Name: aws.String("region-name"), + Values: []string{region}, + }, + }, + } + + output, err := svc.DescribeAvailabilityZones(context.TODO(), input) + if err != nil { + return "", err + } + + // Filter out the current availability zone + availableAZs := []string{} + for _, az := range output.AvailabilityZones { + if aws.ToString(az.ZoneName) != currentAZ { + availableAZs = append(availableAZs, aws.ToString(az.ZoneName)) + } + } + + // If no other availability zones are available, return an error + if len(availableAZs) == 0 { + return "", errors.New("no other availability zones available") + } + + // Select a random availability zone from the remaining ones + randomIndex := rand.Intn(len(availableAZs)) + randomAZ := availableAZs[randomIndex] + return randomAZ, nil +} + + // terminateInstance kills an instance by id func terminateInstance(svc *ec2.Client, instanceID string) error { input := &ec2.TerminateInstancesInput{ From 143e839e78118ca07cc1b19f6210e4aea5e70546 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 18 Apr 2023 11:08:31 +0200 Subject: [PATCH 14/28] loop MTD, checks before doing mtd to service --- main.go | 15 +++++++++++---- mtdaws/mtd.go | 20 ++++++++++++++++++++ state/config.go | 2 ++ 3 files changed, 33 insertions(+), 4 deletions(-) diff --git a/main.go b/main.go index 774efbd..f4f9c15 100644 --- a/main.go +++ b/main.go @@ -28,11 +28,18 @@ func main() { config = indexAllInstances(config) state.SaveConf(ConfigPath, config) - //TODO: figure out migration (MTD) - config = movingTargetDefense(config) - state.SaveConf(ConfigPath, config) + // START DOING MTD + mtdLoop(config) +} - //TODO: proxy commands +func mtdLoop(config state.Config) { + for true { + //TODO: figure out migration (MTD) + config = movingTargetDefense(config) + state.SaveConf(ConfigPath, config) + + //TODO: proxy commands + } } func movingTargetDefense(config state.Config) state.Config{ diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index 8e428ae..7811a34 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -7,6 +7,7 @@ import ( "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/ec2" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/google/uuid" "github.com/thefeli73/polemos/state" ) @@ -37,6 +38,12 @@ func AWSUpdateService(config state.Config, region string, service state.CustomUU return config } + +// isInstanceRunning returns if an instance is running (true=running) +func isInstanceRunning(instance *types.Instance) bool { + return instance.State.Name == types.InstanceStateNameRunning +} + // AWSMoveInstance moves a specified instance to a new availability region func AWSMoveInstance(config state.Config) (state.Config) { @@ -61,6 +68,19 @@ func AWSMoveInstance(config state.Config) (state.Config) { return config } + if !isInstanceRunning(realInstance) { + fmt.Println("Error, Instance is not running!") + return config + } + if instance.AdminDisabled { + fmt.Println("Error, Service is Disabled!") + return config + } + if instance.Inactive { + fmt.Println("Error, Service is Inactive!") + return config + } + imageName, err := createImage(svc, instanceID) if err != nil { fmt.Println("Error creating image:\t", err) diff --git a/state/config.go b/state/config.go index 395f9a0..e96bfdb 100644 --- a/state/config.go +++ b/state/config.go @@ -24,6 +24,8 @@ type mtdconf struct { // Service contains all necessary information about a service to identify it in the cloud as well as configuring a proxy for it type Service struct { CloudID string `yaml:"cloud_id"` + AdminDisabled bool `yaml:"admin_disabled"` + Inactive bool `yaml:"inactive"` EntryIP netip.Addr `yaml:"entry_ip"` EntryPort uint16 `yaml:"entry_port"` ServiceIP netip.Addr `yaml:"service_ip"` From 5571b66d52f7d569aa29d312e4b28a6594be961a Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 18 Apr 2023 15:03:34 +0200 Subject: [PATCH 15/28] disregard inactive instances --- main.go | 13 +++++++++++-- mtdaws/mtd.go | 14 +++++++------- state/config.go | 4 ++-- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/main.go b/main.go index f4f9c15..3e0cfc5 100644 --- a/main.go +++ b/main.go @@ -51,6 +51,10 @@ func movingTargetDefense(config state.Config) state.Config{ func indexAllInstances(config state.Config) state.Config { fmt.Println("Indexing instances") + for _, service := range config.MTD.Services { + service.Active = false + } + //index AWS instances awsNewInstanceCounter := 0 awsRemovedInstanceCounter := 0 @@ -77,9 +81,11 @@ func indexAllInstances(config state.Config) state.Config { func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (state.Config, bool) { found := false - for _, service := range config.MTD.Services { + var foundUUID state.CustomUUID + for u, service := range config.MTD.Services { if service.CloudID == cloudID { found = true + foundUUID = u break; } } @@ -87,9 +93,12 @@ func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (s if !found { fmt.Println("New instance found:\t", cloudID) u := uuid.New() - config.MTD.Services[state.CustomUUID(u)] = state.Service{CloudID: cloudID, ServiceIP: serviceIP} + config.MTD.Services[state.CustomUUID(u)] = state.Service{CloudID: cloudID, ServiceIP: serviceIP, Active: true, AdminEnabled: true} state.SaveConf(ConfigPath, config) + } else { + config.MTD.Services[foundUUID] = state.Service{Active: true} + state.SaveConf(ConfigPath, config) } return config, found } diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index 7811a34..57633ca 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -68,16 +68,16 @@ func AWSMoveInstance(config state.Config) (state.Config) { return config } - if !isInstanceRunning(realInstance) { - fmt.Println("Error, Instance is not running!") - return config - } - if instance.AdminDisabled { + if !instance.AdminEnabled { fmt.Println("Error, Service is Disabled!") return config } - if instance.Inactive { - fmt.Println("Error, Service is Inactive!") + if !instance.Active { + fmt.Println("Error, Service is not active!") + return config + } + if !isInstanceRunning(realInstance) { + fmt.Println("Error, Instance is not running!") return config } diff --git a/state/config.go b/state/config.go index e96bfdb..67e3bee 100644 --- a/state/config.go +++ b/state/config.go @@ -24,8 +24,8 @@ type mtdconf struct { // Service contains all necessary information about a service to identify it in the cloud as well as configuring a proxy for it type Service struct { CloudID string `yaml:"cloud_id"` - AdminDisabled bool `yaml:"admin_disabled"` - Inactive bool `yaml:"inactive"` + AdminEnabled bool `yaml:"admin_enabled"` + Active bool `yaml:"active"` EntryIP netip.Addr `yaml:"entry_ip"` EntryPort uint16 `yaml:"entry_port"` ServiceIP netip.Addr `yaml:"service_ip"` From e8bb5506f5b4e1a4ac97084def9b17834bd84dd0 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 19 Apr 2023 11:39:11 +0200 Subject: [PATCH 16/28] timers, counters, misc --- main.go | 20 ++++++++++++++++---- mtdaws/mtd.go | 36 ++++++++++++++++++++---------------- mtdaws/utils.go | 3 --- 3 files changed, 36 insertions(+), 23 deletions(-) diff --git a/main.go b/main.go index 3e0cfc5..0387f45 100644 --- a/main.go +++ b/main.go @@ -3,6 +3,7 @@ package main import ( "fmt" "net/netip" + "time" "github.com/google/uuid" "github.com/thefeli73/polemos/mtdaws" @@ -38,6 +39,9 @@ func mtdLoop(config state.Config) { config = movingTargetDefense(config) state.SaveConf(ConfigPath, config) + fmt.Println("Sleeping for 5 seconds") + time.Sleep(5*time.Second) + //TODO: proxy commands } } @@ -50,6 +54,7 @@ func movingTargetDefense(config state.Config) state.Config{ func indexAllInstances(config state.Config) state.Config { fmt.Println("Indexing instances") + t := time.Now() for _, service := range config.MTD.Services { service.Active = false @@ -57,7 +62,7 @@ func indexAllInstances(config state.Config) state.Config { //index AWS instances awsNewInstanceCounter := 0 - awsRemovedInstanceCounter := 0 + awsInactiveInstanceCounter := len(config.MTD.Services) awsInstanceCounter := 0 awsInstances := mtdaws.GetInstances(config) for _, instance := range awsInstances { @@ -69,11 +74,16 @@ func indexAllInstances(config state.Config) state.Config { } var found bool config, found = indexInstance(config, cloudID, ip) - if !found {awsNewInstanceCounter++} + if !found { + awsNewInstanceCounter++ + } else { + awsInactiveInstanceCounter-- + } awsInstanceCounter++ } // TODO: Purge instances in config that are not found in the cloud - fmt.Printf("Found %d AWS instances (%d newly added, %d removed)\n", awsInstanceCounter, awsNewInstanceCounter, awsRemovedInstanceCounter) + fmt.Printf("Found %d active AWS instances (%d newly added, %d inactive) (took %s)\n", + awsInstanceCounter, awsNewInstanceCounter, awsInactiveInstanceCounter, time.Since(t).Round(100*time.Millisecond).String()) return config @@ -97,7 +107,9 @@ func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (s state.SaveConf(ConfigPath, config) } else { - config.MTD.Services[foundUUID] = state.Service{Active: true} + s := config.MTD.Services[foundUUID] + s.Active = true + config.MTD.Services[foundUUID] = s state.SaveConf(ConfigPath, config) } return config, found diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index 57633ca..ab69354 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -53,6 +53,8 @@ func AWSMoveInstance(config state.Config) (state.Config) { for key, service := range config.MTD.Services { serviceUUID = key instance = service + if !instance.AdminEnabled {continue} + if !instance.Active {continue} break } @@ -67,61 +69,63 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("Error getting instance details:\t", err) return config } - - if !instance.AdminEnabled { - fmt.Println("Error, Service is Disabled!") - return config - } - if !instance.Active { - fmt.Println("Error, Service is not active!") - return config - } if !isInstanceRunning(realInstance) { fmt.Println("Error, Instance is not running!") return config } + //Create image + t := time.Now() imageName, err := createImage(svc, instanceID) if err != nil { fmt.Println("Error creating image:\t", err) return config } - fmt.Println("Created image:\t\t", imageName) + fmt.Printf("Created image:\t\t%s (took %s)\n", imageName, time.Since(t).Round(100*time.Millisecond).String()) + // Wait for image + t = time.Now() err = waitForImageReady(svc, imageName, 5*time.Minute) if err != nil { fmt.Println("Error waiting for image to be ready:\t", err) return config } - fmt.Println("Image is ready:\t\t", imageName) + fmt.Printf("Image is ready:\t\t%s (took %s)\n", imageName, time.Since(t).Round(100*time.Millisecond).String()) + // Launch new instance + t = time.Now() newInstanceID, err := launchInstance(svc, realInstance, imageName, region) if err != nil { fmt.Println("Error launching instance:\t", err) return config } - fmt.Println("Launched new instance:\t", newInstanceID) + fmt.Printf("Launched new instance:\t%s (took %s)\n", newInstanceID, time.Since(t).Round(100*time.Millisecond).String()) + // Terminate old instance + t = time.Now() err = terminateInstance(svc, instanceID) if err != nil { fmt.Println("Error terminating instance:\t", err) return config } - fmt.Println("Killed old instance:\t", instanceID) + fmt.Printf("Killed old instance:\t%s (took %s)\n", instanceID, time.Since(t).Round(100*time.Millisecond).String()) + // Deregister old image + t = time.Now() image, err := describeImage(svc, imageName) if err != nil { fmt.Println("Error describing image:\t", err) return config } - err = deregisterImage(svc, imageName) if err != nil { fmt.Println("Error deregistering image:\t", err) return config } - fmt.Println("Deregistered image:\t", imageName) + fmt.Printf("Deregistered image:\t%s (took %s)\n", imageName, time.Since(t).Round(100*time.Millisecond).String()) + // Delete old snapshot + t = time.Now() if len(image.BlockDeviceMappings) > 0 { snapshotID := aws.ToString(image.BlockDeviceMappings[0].Ebs.SnapshotId) err = deleteSnapshot(svc, snapshotID) @@ -129,7 +133,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("Error deleting snapshot:\t", err) return config } - fmt.Println("Deleted snapshot:\t", snapshotID) + fmt.Printf("Deleted snapshot:\t%s (took %s)\n", snapshotID, time.Since(t).Round(100*time.Millisecond).String()) } AWSUpdateService(config, region, serviceUUID, newInstanceID) diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 2d4d5a4..f81850b 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -224,10 +224,7 @@ func terminateInstance(svc *ec2.Client, instanceID string) error { input := &ec2.TerminateInstancesInput{ InstanceIds: []string{instanceID}, } - _, err := svc.TerminateInstances(context.TODO(), input) - - // TODO: remove config for old instance return err } From d06620ca741ecb10c15e19ab7f379f9af99bb903 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 25 Apr 2023 15:50:45 +0200 Subject: [PATCH 17/28] default port for proxima centauri --- config.default.yaml | 1 + state/config.go | 1 + 2 files changed, 2 insertions(+) diff --git a/config.default.yaml b/config.default.yaml index 77240ff..147aecd 100644 --- a/config.default.yaml +++ b/config.default.yaml @@ -1,5 +1,6 @@ mtd: services: {} + management_port: 14000 aws: regions: [] credentials_path: ./mtdaws/.credentials diff --git a/state/config.go b/state/config.go index 67e3bee..88ea825 100644 --- a/state/config.go +++ b/state/config.go @@ -18,6 +18,7 @@ type Config struct { type mtdconf struct { Services map[CustomUUID]Service `yaml:"services"` + ManagementPort uint16 `yaml:"management_port"` } From 91132d0e22b21509b1fe9abb8cd6ebf0aaac36de Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 25 Apr 2023 15:52:34 +0200 Subject: [PATCH 18/28] wait for instance and send command with pcsdk --- mtdaws/mtd.go | 101 ++++++++++++++++++++++++++++++------------------ mtdaws/utils.go | 14 +++++++ 2 files changed, 78 insertions(+), 37 deletions(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index ab69354..69e3d3b 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -9,41 +9,10 @@ import ( "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/google/uuid" + "github.com/thefeli73/polemos/pcsdk" "github.com/thefeli73/polemos/state" ) -// AWSUpdateService updates a specified service config to match a newly moved instance -func AWSUpdateService(config state.Config, region string, service state.CustomUUID, newInstanceID string) (state.Config) { - awsConfig := NewConfig(region, config.AWS.CredentialsPath) - svc := ec2.NewFromConfig(awsConfig) - instance, err := getInstanceDetailsFromString(svc, newInstanceID) - if err != nil { - fmt.Println("Error getting instance details:\t", err) - return config - } - - var publicAddr string - if instance.PublicIpAddress != nil { - publicAddr = aws.ToString(instance.PublicIpAddress) - } - formattedinstance := AwsInstance{ - InstanceID: aws.ToString(instance.InstanceId), - Region: region, - PublicIP: publicAddr, - PrivateIP: aws.ToString(instance.PrivateIpAddress), - } - cloudid := GetCloudID(formattedinstance) - serviceip := netip.MustParseAddr(publicAddr) - config.MTD.Services[service] = state.Service{CloudID: cloudid, ServiceIP: serviceip} - return config -} - - -// isInstanceRunning returns if an instance is running (true=running) -func isInstanceRunning(instance *types.Instance) bool { - return instance.State.Name == types.InstanceStateNameRunning -} - // AWSMoveInstance moves a specified instance to a new availability region func AWSMoveInstance(config state.Config) (state.Config) { @@ -101,9 +70,70 @@ func AWSMoveInstance(config state.Config) (state.Config) { } fmt.Printf("Launched new instance:\t%s (took %s)\n", newInstanceID, time.Since(t).Round(100*time.Millisecond).String()) - // Terminate old instance + // Wait for instance t = time.Now() - err = terminateInstance(svc, instanceID) + err = waitForInstanceReady(svc, newInstanceID, 5*time.Minute) + if err != nil { + fmt.Println("Error waiting for instance to be ready:\t", err) + return config + } + fmt.Printf("instance is ready:\t\t%s (took %s)\n", newInstanceID, time.Since(t).Round(100*time.Millisecond).String()) + + // Reconfigure Proxy to new instance + t = time.Now() + m := pcsdk.NewCommandModify(instance.ServicePort, instance.ServiceIP, serviceUUID) + err = m.Execute(netip.AddrPortFrom(instance.EntryIP, config.MTD.ManagementPort)) + if err != nil { + fmt.Printf("error executing modify command: %s\n", err) + return config + } + fmt.Printf("Proxy modified. (took %s)\n", time.Since(t).Round(100*time.Millisecond).String()) + + + AWSUpdateService(config, region, serviceUUID, newInstanceID) + + cleanupAWS(svc, config, instanceID, imageName) + + + return config +} + +// AWSUpdateService updates a specified service config to match a newly moved instance +func AWSUpdateService(config state.Config, region string, service state.CustomUUID, newInstanceID string) (state.Config) { + awsConfig := NewConfig(region, config.AWS.CredentialsPath) + svc := ec2.NewFromConfig(awsConfig) + instance, err := getInstanceDetailsFromString(svc, newInstanceID) + if err != nil { + fmt.Println("Error getting instance details:\t", err) + return config + } + + var publicAddr string + if instance.PublicIpAddress != nil { + publicAddr = aws.ToString(instance.PublicIpAddress) + } + formattedinstance := AwsInstance{ + InstanceID: aws.ToString(instance.InstanceId), + Region: region, + PublicIP: publicAddr, + PrivateIP: aws.ToString(instance.PrivateIpAddress), + } + cloudid := GetCloudID(formattedinstance) + serviceip := netip.MustParseAddr(publicAddr) + config.MTD.Services[service] = state.Service{CloudID: cloudid, ServiceIP: serviceip} + return config +} + +// isInstanceRunning returns if an instance is running (true=running) +func isInstanceRunning(instance *types.Instance) bool { + return instance.State.Name == types.InstanceStateNameRunning +} + +// cleanupAWS terminates the old instance, deregisters the image and deletes the old snapshot +func cleanupAWS(svc *ec2.Client, config state.Config, instanceID string, imageName string) state.Config { + // Terminate old instance + t := time.Now() + err := terminateInstance(svc, instanceID) if err != nil { fmt.Println("Error terminating instance:\t", err) return config @@ -135,8 +165,5 @@ func AWSMoveInstance(config state.Config) (state.Config) { } fmt.Printf("Deleted snapshot:\t%s (took %s)\n", snapshotID, time.Since(t).Round(100*time.Millisecond).String()) } - - AWSUpdateService(config, region, serviceUUID, newInstanceID) - return config } diff --git a/mtdaws/utils.go b/mtdaws/utils.go index f81850b..1726fca 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -142,6 +142,20 @@ func waitForImageReady(svc *ec2.Client, imageID string, timeout time.Duration) e } } +// waitForInstanceReady waits for the newly launched instance to be running and ready +func waitForInstanceReady(svc *ec2.Client, newInstanceID string, timeout time.Duration) error { + // Wait for the instance to be running + waitInput := &ec2.DescribeInstancesInput{ + InstanceIds: []string{newInstanceID}, + } + waiter := ec2.NewInstanceRunningWaiter(svc) + err := waiter.Wait(context.TODO(), waitInput, timeout) + if err != nil { + return err + } + return nil +} + // launchInstance launches a instance IN RANDOM AVAILABILITY ZONE within the same region, based on an oldInstance and AMI (duplicating the instance) func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string, region string) (string, error) { securityGroupIds := make([]string, len(oldInstance.SecurityGroups)) From 6959c7c6dbe16c59c1c72550efc55872067c7e7e Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 26 Apr 2023 13:16:21 +0200 Subject: [PATCH 19/28] implement function for new status command type --- pcsdk/commands.go | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/pcsdk/commands.go b/pcsdk/commands.go index 5073da8..e96b45d 100644 --- a/pcsdk/commands.go +++ b/pcsdk/commands.go @@ -21,6 +21,49 @@ type response struct { message string `json:"message"` } +type ProxyCommandStatus struct { + Command CommandStatus `json:"status"` + // signature Signature +} + +type CommandStatus struct { +} + +func (c ProxyCommandStatus) Execute(url netip.AddrPort) error { + data, err := json.Marshal(c) + if err != nil { + return errors.New(fmt.Sprintf("could not serialize: %s\n", err)) + } + + requestURL := fmt.Sprintf("http://%s:%d/command", url.Addr().String(), url.Port()) + fmt.Println(requestURL) + bodyReader := bytes.NewReader(data) + + res, err := http.DefaultClient.Post(requestURL, "application/json", bodyReader) + if err != nil { + return errors.New(fmt.Sprintf("error making http request: %s\n", err)) + } + + fmt.Println(res) + + body, err := ioutil.ReadAll(res.Body) + fmt.Println(string(body)) + if err != nil { + return errors.New(fmt.Sprintf("error reading response: %s\n", err)) + } + + if res.StatusCode != 202 { + return errors.New(fmt.Sprintf("error processing command: (%d) %s\n", res.StatusCode, body)) + } else { + return nil + } +} + +func NewCommandStatus() ProxyCommandStatus { + c := CommandStatus{} + return ProxyCommandStatus{c} +} + type ProxyCommandCreate struct { Command CommandCreate `json:"create"` // signature Signature From 7e2fcb909fc143894c305930e1e0b7c8f173d886 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 26 Apr 2023 13:47:32 +0200 Subject: [PATCH 20/28] comments in commands.go --- pcsdk/commands.go | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/pcsdk/commands.go b/pcsdk/commands.go index e96b45d..ad1d288 100644 --- a/pcsdk/commands.go +++ b/pcsdk/commands.go @@ -13,6 +13,7 @@ import ( "github.com/thefeli73/polemos/state" ) +// ExecuteCommand is the interface that wraps the Execute method. type ExecuteCommand interface { Execute(netip.AddrPort) error } @@ -21,14 +22,16 @@ type response struct { message string `json:"message"` } +// ProxyCommandStatus is the command to get the status of a proxy type ProxyCommandStatus struct { Command CommandStatus `json:"status"` // signature Signature } -type CommandStatus struct { -} +// CommandStatus is the status of a proxy +type CommandStatus struct {} +// Execute is the method that executes the Status command func (c ProxyCommandStatus) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -59,16 +62,19 @@ func (c ProxyCommandStatus) Execute(url netip.AddrPort) error { } } +// NewCommandStatus returns a new CommandStatus func NewCommandStatus() ProxyCommandStatus { c := CommandStatus{} return ProxyCommandStatus{c} } +// ProxyCommandCreate is the command to create a proxy type ProxyCommandCreate struct { Command CommandCreate `json:"create"` // signature Signature } +// CommandCreate is the struct for the "Create" Command and contains all the info the proxy needs to create a tunnel type CommandCreate struct { IncomingPort uint16 `json:"incoming_port"` DestinationPort uint16 `json:"destination_port"` @@ -76,6 +82,7 @@ type CommandCreate struct { Id string `json:"id"` } +// Execute is the method that executes the Create command on a ProxyCommandCreate func (c ProxyCommandCreate) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -106,21 +113,25 @@ func (c ProxyCommandCreate) Execute(url netip.AddrPort) error { } } +// NewCommandCreate returns a new CommandCreate func NewCommandCreate(iport uint16, oport uint16, oip netip.Addr, id state.CustomUUID) ProxyCommandCreate { c := CommandCreate{iport, oport, oip, uuid.UUID.String(uuid.UUID(id))} return ProxyCommandCreate{c} } +// ProxyCommandModify is the command to modify a proxy type ProxyCommandModify struct { Command CommandModify `json:"modify"` } +// CommandModify is the struct for the "Modify" Command and contains all the info the proxy needs to modify a tunnel type CommandModify struct { DestinationPort uint16 `json:"destination_port"` DestinationIP netip.Addr `json:"destination_ip"` Id string `json:"id"` } +// Execute is the method that executes the Modify command on a ProxyCommandModify func (c ProxyCommandModify) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -151,19 +162,23 @@ func (c ProxyCommandModify) Execute(url netip.AddrPort) error { } } +// NewCommandModify returns a new CommandModify func NewCommandModify(oport uint16, oip netip.Addr, id state.CustomUUID) ProxyCommandModify { c := CommandModify{oport, oip, uuid.UUID.String(uuid.UUID(id))} return ProxyCommandModify{c} } +// ProxyCommandDelete is the command to delete a proxy type ProxyCommandDelete struct { Command CommandDelete `json:"delete"` } +// CommandDelete is the struct for the "Delete" Command and contains the id of the tunnel to delete type CommandDelete struct { Id string `json:"id"` } +// Execute is the method that executes the Delete command on a ProxyCommandDelete func (c ProxyCommandDelete) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -194,6 +209,7 @@ func (c ProxyCommandDelete) Execute(url netip.AddrPort) error { } } +// NewCommandDelete returns a new CommandDelete func NewCommandDelete(id state.CustomUUID) ProxyCommandDelete { c := CommandDelete{uuid.UUID.String(uuid.UUID(id))} return ProxyCommandDelete{c} From 0da207fd887635a05b0a85ebec5f2e97f5b9afe0 Mon Sep 17 00:00:00 2001 From: schulze Date: Wed, 26 Apr 2023 14:20:56 +0200 Subject: [PATCH 21/28] Test Proxy connection works --- mtdaws/mtd.go | 12 +++++++++++- pcsdk/commands.go | 20 +------------------- 2 files changed, 12 insertions(+), 20 deletions(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index 69e3d3b..b5b6b5e 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -29,6 +29,16 @@ func AWSMoveInstance(config state.Config) (state.Config) { fmt.Println("MTD move service:\t", uuid.UUID.String(uuid.UUID(serviceUUID))) + // Test Proxy Connection + t := time.Now() + s := pcsdk.NewCommandStatus() + err := s.Execute(netip.AddrPortFrom(instance.EntryIP, config.MTD.ManagementPort)) + if err != nil { + fmt.Printf("error executing test command: %s\n", err) + return config + } + fmt.Printf("Proxy Tested. (took %s)\n", time.Since(t).Round(100*time.Millisecond).String()) + return config region, instanceID := DecodeCloudID(instance.CloudID) awsConfig := NewConfig(region, config.AWS.CredentialsPath) svc := ec2.NewFromConfig(awsConfig) @@ -44,7 +54,7 @@ func AWSMoveInstance(config state.Config) (state.Config) { } //Create image - t := time.Now() + t = time.Now() imageName, err := createImage(svc, instanceID) if err != nil { fmt.Println("Error creating image:\t", err) diff --git a/pcsdk/commands.go b/pcsdk/commands.go index ad1d288..7aaa123 100644 --- a/pcsdk/commands.go +++ b/pcsdk/commands.go @@ -39,23 +39,18 @@ func (c ProxyCommandStatus) Execute(url netip.AddrPort) error { } requestURL := fmt.Sprintf("http://%s:%d/command", url.Addr().String(), url.Port()) - fmt.Println(requestURL) bodyReader := bytes.NewReader(data) res, err := http.DefaultClient.Post(requestURL, "application/json", bodyReader) if err != nil { return errors.New(fmt.Sprintf("error making http request: %s\n", err)) } - - fmt.Println(res) - body, err := ioutil.ReadAll(res.Body) - fmt.Println(string(body)) if err != nil { return errors.New(fmt.Sprintf("error reading response: %s\n", err)) } - if res.StatusCode != 202 { + if res.StatusCode != 200 { return errors.New(fmt.Sprintf("error processing command: (%d) %s\n", res.StatusCode, body)) } else { return nil @@ -90,18 +85,13 @@ func (c ProxyCommandCreate) Execute(url netip.AddrPort) error { } requestURL := fmt.Sprintf("http://%s:%d/command", url.Addr().String(), url.Port()) - fmt.Println(requestURL) bodyReader := bytes.NewReader(data) res, err := http.DefaultClient.Post(requestURL, "application/json", bodyReader) if err != nil { return errors.New(fmt.Sprintf("error making http request: %s\n", err)) } - - fmt.Println(res) - body, err := ioutil.ReadAll(res.Body) - fmt.Println(string(body)) if err != nil { return errors.New(fmt.Sprintf("error reading response: %s\n", err)) } @@ -146,11 +136,7 @@ func (c ProxyCommandModify) Execute(url netip.AddrPort) error { if err != nil { return errors.New(fmt.Sprintf("error making http request: %s\n", err)) } - - fmt.Println(res) - body, err := ioutil.ReadAll(res.Body) - fmt.Println(string(body)) if err != nil { return errors.New(fmt.Sprintf("error reading response: %s\n", err)) } @@ -193,11 +179,7 @@ func (c ProxyCommandDelete) Execute(url netip.AddrPort) error { if err != nil { return errors.New(fmt.Sprintf("error making http request: %s\n", err)) } - - fmt.Println(res) - body, err := ioutil.ReadAll(res.Body) - fmt.Println(string(body)) if err != nil { return errors.New(fmt.Sprintf("error reading response: %s\n", err)) } From 9c84a74a146a70002e9631f873692ed52ff80a4a Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 13:31:23 +0200 Subject: [PATCH 22/28] ignore binary --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 13da3e6..73f2b83 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,5 @@ config.yaml + +polemos From 126c0dbebb77b2558c9ad128a4051c74671112a9 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 13:32:39 +0200 Subject: [PATCH 23/28] . --- mtdaws/mtd.go | 1 - 1 file changed, 1 deletion(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index b5b6b5e..cd8abd9 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -38,7 +38,6 @@ func AWSMoveInstance(config state.Config) (state.Config) { return config } fmt.Printf("Proxy Tested. (took %s)\n", time.Since(t).Round(100*time.Millisecond).String()) - return config region, instanceID := DecodeCloudID(instance.CloudID) awsConfig := NewConfig(region, config.AWS.CredentialsPath) svc := ec2.NewFromConfig(awsConfig) From 8cb672a8ea45139fa72fdcc4255f90fdf855b0d1 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 13:33:33 +0200 Subject: [PATCH 24/28] Keep instance name when migrating --- mtdaws/utils.go | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/mtdaws/utils.go b/mtdaws/utils.go index 1726fca..a080125 100644 --- a/mtdaws/utils.go +++ b/mtdaws/utils.go @@ -162,11 +162,17 @@ func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string for i, sg := range oldInstance.SecurityGroups { securityGroupIds[i] = aws.ToString(sg.GroupId) } - // TODO: select random zone that is not the current one. availabilityZone, err := getRandomDifferentAvailabilityZone(svc, oldInstance, region) if err != nil { return "", err } + var nameTag string + for _, tag := range oldInstance.Tags { + if aws.ToString(tag.Key) == "Name" { + nameTag = aws.ToString(tag.Value) + break + } + } input := &ec2.RunInstancesInput{ ImageId: aws.String(imageID), @@ -178,6 +184,17 @@ func launchInstance(svc *ec2.Client, oldInstance *types.Instance, imageID string Placement: &types.Placement{ AvailabilityZone: aws.String(availabilityZone), }, + TagSpecifications: []types.TagSpecification{ + { + ResourceType: types.ResourceTypeInstance, + Tags: []types.Tag{ + { + Key: aws.String("Name"), + Value: aws.String(nameTag), + }, + }, + }, + }, } output, err := svc.RunInstances(context.TODO(), input) From e95f77d203233d305941034bba795ccc7b114eb6 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 13:59:33 +0200 Subject: [PATCH 25/28] create all tunnels on startup (no mtd right now) --- main.go | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/main.go b/main.go index 0387f45..d73946e 100644 --- a/main.go +++ b/main.go @@ -7,6 +7,7 @@ import ( "github.com/google/uuid" "github.com/thefeli73/polemos/mtdaws" + "github.com/thefeli73/polemos/pcsdk" "github.com/thefeli73/polemos/state" ) @@ -29,8 +30,11 @@ func main() { config = indexAllInstances(config) state.SaveConf(ConfigPath, config) + // CREATE TUNNELS + createTunnels(config) + // START DOING MTD - mtdLoop(config) + //mtdLoop(config) } func mtdLoop(config state.Config) { @@ -39,8 +43,8 @@ func mtdLoop(config state.Config) { config = movingTargetDefense(config) state.SaveConf(ConfigPath, config) - fmt.Println("Sleeping for 5 seconds") - time.Sleep(5*time.Second) + fmt.Println("Sleeping for 1 minute") + time.Sleep(1*time.Minute) //TODO: proxy commands } @@ -89,6 +93,24 @@ func indexAllInstances(config state.Config) state.Config { return config } +func createTunnels(config state.Config) { + for serviceUUID, service := range config.MTD.Services { + if service.AdminEnabled && service.Active { + s := pcsdk.NewCommandStatus() + err := s.Execute(netip.AddrPortFrom(service.EntryIP, config.MTD.ManagementPort)) + if err != nil { + continue + } + // Reconfigure Proxy to new instance + c := pcsdk.NewCommandCreate(service.ServicePort, service.ServicePort, service.ServiceIP, serviceUUID) + err = c.Execute(netip.AddrPortFrom(service.EntryIP, config.MTD.ManagementPort)) + if err != nil { + continue + } + } + } +} + func indexInstance(config state.Config, cloudID string, serviceIP netip.Addr) (state.Config, bool) { found := false var foundUUID state.CustomUUID From f5e01ba3c2f81e6ec34324066327af92182d811f Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 14:50:22 +0200 Subject: [PATCH 26/28] do moving target defense, fix wrong port, --- main.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main.go b/main.go index d73946e..7118300 100644 --- a/main.go +++ b/main.go @@ -34,7 +34,7 @@ func main() { createTunnels(config) // START DOING MTD - //mtdLoop(config) + mtdLoop(config) } func mtdLoop(config state.Config) { @@ -102,7 +102,7 @@ func createTunnels(config state.Config) { continue } // Reconfigure Proxy to new instance - c := pcsdk.NewCommandCreate(service.ServicePort, service.ServicePort, service.ServiceIP, serviceUUID) + c := pcsdk.NewCommandCreate(service.EntryPort, service.ServicePort, service.ServiceIP, serviceUUID) err = c.Execute(netip.AddrPortFrom(service.EntryIP, config.MTD.ManagementPort)) if err != nil { continue From 288b39c2e736232652d340f375de761f5b877bed Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 14:53:45 +0200 Subject: [PATCH 27/28] modify proxy tunnel with NEW IP etc, update local config to match --- mtdaws/mtd.go | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/mtdaws/mtd.go b/mtdaws/mtd.go index cd8abd9..016a3f0 100644 --- a/mtdaws/mtd.go +++ b/mtdaws/mtd.go @@ -87,23 +87,23 @@ func AWSMoveInstance(config state.Config) (state.Config) { return config } fmt.Printf("instance is ready:\t\t%s (took %s)\n", newInstanceID, time.Since(t).Round(100*time.Millisecond).String()) + + // update local config to match new instance + config = AWSUpdateService(config, region, serviceUUID, newInstanceID) // Reconfigure Proxy to new instance t = time.Now() - m := pcsdk.NewCommandModify(instance.ServicePort, instance.ServiceIP, serviceUUID) - err = m.Execute(netip.AddrPortFrom(instance.EntryIP, config.MTD.ManagementPort)) + m := pcsdk.NewCommandModify(config.MTD.Services[serviceUUID].ServicePort, config.MTD.Services[serviceUUID].ServiceIP, serviceUUID) + err = m.Execute(netip.AddrPortFrom(config.MTD.Services[serviceUUID].EntryIP, config.MTD.ManagementPort)) if err != nil { fmt.Printf("error executing modify command: %s\n", err) return config } fmt.Printf("Proxy modified. (took %s)\n", time.Since(t).Round(100*time.Millisecond).String()) - - - AWSUpdateService(config, region, serviceUUID, newInstanceID) + // take care of old instance, deregister image and delete snapshot cleanupAWS(svc, config, instanceID, imageName) - return config } @@ -129,7 +129,10 @@ func AWSUpdateService(config state.Config, region string, service state.CustomUU } cloudid := GetCloudID(formattedinstance) serviceip := netip.MustParseAddr(publicAddr) - config.MTD.Services[service] = state.Service{CloudID: cloudid, ServiceIP: serviceip} + s := config.MTD.Services[service] + s.CloudID = cloudid + s.ServiceIP = serviceip + config.MTD.Services[service] = s return config } From 777f3ae9ac0fd0c7f5a9ba8b5815770ee0209af4 Mon Sep 17 00:00:00 2001 From: schulze Date: Tue, 2 May 2023 16:05:08 +0200 Subject: [PATCH 28/28] revert commands.go comments and status func --- pcsdk/commands.go | 54 ----------------------------------------------- 1 file changed, 54 deletions(-) diff --git a/pcsdk/commands.go b/pcsdk/commands.go index 7aaa123..ef2a376 100644 --- a/pcsdk/commands.go +++ b/pcsdk/commands.go @@ -13,7 +13,6 @@ import ( "github.com/thefeli73/polemos/state" ) -// ExecuteCommand is the interface that wraps the Execute method. type ExecuteCommand interface { Execute(netip.AddrPort) error } @@ -22,54 +21,11 @@ type response struct { message string `json:"message"` } -// ProxyCommandStatus is the command to get the status of a proxy -type ProxyCommandStatus struct { - Command CommandStatus `json:"status"` - // signature Signature -} - -// CommandStatus is the status of a proxy -type CommandStatus struct {} - -// Execute is the method that executes the Status command -func (c ProxyCommandStatus) Execute(url netip.AddrPort) error { - data, err := json.Marshal(c) - if err != nil { - return errors.New(fmt.Sprintf("could not serialize: %s\n", err)) - } - - requestURL := fmt.Sprintf("http://%s:%d/command", url.Addr().String(), url.Port()) - bodyReader := bytes.NewReader(data) - - res, err := http.DefaultClient.Post(requestURL, "application/json", bodyReader) - if err != nil { - return errors.New(fmt.Sprintf("error making http request: %s\n", err)) - } - body, err := ioutil.ReadAll(res.Body) - if err != nil { - return errors.New(fmt.Sprintf("error reading response: %s\n", err)) - } - - if res.StatusCode != 200 { - return errors.New(fmt.Sprintf("error processing command: (%d) %s\n", res.StatusCode, body)) - } else { - return nil - } -} - -// NewCommandStatus returns a new CommandStatus -func NewCommandStatus() ProxyCommandStatus { - c := CommandStatus{} - return ProxyCommandStatus{c} -} - -// ProxyCommandCreate is the command to create a proxy type ProxyCommandCreate struct { Command CommandCreate `json:"create"` // signature Signature } -// CommandCreate is the struct for the "Create" Command and contains all the info the proxy needs to create a tunnel type CommandCreate struct { IncomingPort uint16 `json:"incoming_port"` DestinationPort uint16 `json:"destination_port"` @@ -77,7 +33,6 @@ type CommandCreate struct { Id string `json:"id"` } -// Execute is the method that executes the Create command on a ProxyCommandCreate func (c ProxyCommandCreate) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -103,25 +58,21 @@ func (c ProxyCommandCreate) Execute(url netip.AddrPort) error { } } -// NewCommandCreate returns a new CommandCreate func NewCommandCreate(iport uint16, oport uint16, oip netip.Addr, id state.CustomUUID) ProxyCommandCreate { c := CommandCreate{iport, oport, oip, uuid.UUID.String(uuid.UUID(id))} return ProxyCommandCreate{c} } -// ProxyCommandModify is the command to modify a proxy type ProxyCommandModify struct { Command CommandModify `json:"modify"` } -// CommandModify is the struct for the "Modify" Command and contains all the info the proxy needs to modify a tunnel type CommandModify struct { DestinationPort uint16 `json:"destination_port"` DestinationIP netip.Addr `json:"destination_ip"` Id string `json:"id"` } -// Execute is the method that executes the Modify command on a ProxyCommandModify func (c ProxyCommandModify) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -148,23 +99,19 @@ func (c ProxyCommandModify) Execute(url netip.AddrPort) error { } } -// NewCommandModify returns a new CommandModify func NewCommandModify(oport uint16, oip netip.Addr, id state.CustomUUID) ProxyCommandModify { c := CommandModify{oport, oip, uuid.UUID.String(uuid.UUID(id))} return ProxyCommandModify{c} } -// ProxyCommandDelete is the command to delete a proxy type ProxyCommandDelete struct { Command CommandDelete `json:"delete"` } -// CommandDelete is the struct for the "Delete" Command and contains the id of the tunnel to delete type CommandDelete struct { Id string `json:"id"` } -// Execute is the method that executes the Delete command on a ProxyCommandDelete func (c ProxyCommandDelete) Execute(url netip.AddrPort) error { data, err := json.Marshal(c) if err != nil { @@ -191,7 +138,6 @@ func (c ProxyCommandDelete) Execute(url netip.AddrPort) error { } } -// NewCommandDelete returns a new CommandDelete func NewCommandDelete(id state.CustomUUID) ProxyCommandDelete { c := CommandDelete{uuid.UUID.String(uuid.UUID(id))} return ProxyCommandDelete{c}