run_ca.go

// ThreatSpec package main
package main

import (
	"fmt"
	"github.com/jawher/mow.cli"
	"github.com/pki-io/controller"
	"strconv"
)

// ThreatSpec TMv0.1 for caCmd
// Does CA CLI handling for App:CLI
// Calls main.caNewCmd main.caListCmd main.caShowCmd main.caUpdateCmd main.caDeleteCmd

func caCmd(cmd *cli.Cmd) {
	cmd.Command("new", "Create a new CA", caNewCmd)
	cmd.Command("list", "List CAs", caListCmd)
	cmd.Command("show", "Show a CA", caShowCmd)
	cmd.Command("update", "Update an existing CA", caUpdateCmd)
	cmd.Command("delete", "Delete a CA", caDeleteCmd)
}

// ThreatSpec TMv0.1 for caNewCmd
// Does new CA CLI handling for App:CLI
// Calls main.controller.NewCA main.CAController.New

func caNewCmd(cmd *cli.Cmd) {
	cmd.Spec = "NAME [OPTIONS]"

	params := controller.NewCAParams()
	params.Name = cmd.StringArg("NAME", "", "name of CA")

	params.CertFile = cmd.StringOpt("cert", "", "certificate PEM file")
	params.KeyFile = cmd.StringOpt("key", "", "key PEM file")
	params.Tags = cmd.StringOpt("tags", "NAME", "comma separated list of tags")
	params.CaExpiry = cmd.IntOpt("ca-expiry", 365, "CA expiry period in days")
	params.CertExpiry = cmd.IntOpt("cert-expiry", 90, "Certificate expiry period in days")
	params.KeyType = cmd.StringOpt("key-type", "ec", "Key type (ec or rsa)")
	params.DnLocality = cmd.StringOpt("dn-l", "", "Locality for DN scope")
	params.DnState = cmd.StringOpt("dn-st", "", "State/province for DN scope")
	params.DnOrg = cmd.StringOpt("dn-o", "", "Organization for DN scope")
	params.DnOrgUnit = cmd.StringOpt("dn-ou", "", "Organizational unit for DN scope")
	params.DnCountry = cmd.StringOpt("dn-c", "", "Country for DN scope")
	params.DnStreet = cmd.StringOpt("dn-street", "", "Street for DN scope")
	params.DnPostal = cmd.StringOpt("dn-postal", "", "PostalCode for DN scope")

	cmd.Action = func() {
		app := NewAdminApp()
		logger.Info("creating new CA")

		cont, err := controller.NewCA(app.env)
		if err != nil {
			app.Fatal(err)
		}

		ca, err := cont.New(params)
		if err != nil {
			app.Fatal(err)
		}

		if ca != nil {
			table := app.NewTable()

			caData := [][]string{
				[]string{"Id", ca.Id()},
				[]string{"Name", ca.Name()},
			}

			table.AppendBulk(caData)

			app.RenderTable(table)
		}

	}
}

// ThreatSpec TMv0.1 for caListCmd

func caListCmd(cmd *cli.Cmd) {
	params := controller.NewCAParams()

	cmd.Action = func() {
		app := NewAdminApp()
		logger.Info("listing CAs")

		cont, err := controller.NewCA(app.env)
		if err != nil {
			app.Fatal(err)
		}

		cas, err := cont.List(params)
		if err != nil {
			app.Fatal(err)
		}

		table := app.NewTable()
		table.SetHeader([]string{"Name", "Id"})

		for _, ca := range cas {
			table.Append([]string{ca.Name(), ca.Id()})
		}

		app.RenderTable(table)
	}
}

// ThreatSpec TMv0.1 for caShowCmd

func caShowCmd(cmd *cli.Cmd) {
	cmd.Spec = "NAME [OPTIONS]"

	params := controller.NewCAParams()
	params.Name = cmd.StringArg("NAME", "", "name of CA")

	params.Export = cmd.StringOpt("export", "", "tar.gz export to file")
	params.Private = cmd.BoolOpt("private", false, "show/export private data")

	cmd.Action = func() {
		app := NewAdminApp()
		logger.Info("showing CA")

		cont, err := controller.NewCA(app.env)
		if err != nil {
			app.Fatal(err)
		}

		ca, err := cont.Show(params)
		if err != nil {
			app.Fatal(err)
		}

		if *params.Export == "" {
			table := app.NewTable()

			caData := [][]string{
				[]string{"ID", ca.Id()},
				[]string{"Name", ca.Name()},
				[]string{"Key type", ca.Data.Body.KeyType},
				[]string{"CA expiry period (days)", strconv.Itoa(ca.Data.Body.CAExpiry)},
				[]string{"Cert expiry period (days)", strconv.Itoa(ca.Data.Body.CertExpiry)},
				[]string{"Country DN scope", ca.Data.Body.DNScope.Country},
				[]string{"Organization DN scope", ca.Data.Body.DNScope.Organization},
				[]string{"Organizational unit DN scope", ca.Data.Body.DNScope.OrganizationalUnit},
				[]string{"Locality DN scope", ca.Data.Body.DNScope.Locality},
				[]string{"Province DN scope", ca.Data.Body.DNScope.Province},
				[]string{"Street address DN scope", ca.Data.Body.DNScope.StreetAddress},
				[]string{"Postal code DN scope", ca.Data.Body.DNScope.PostalCode},
			}
			table.AppendBulk(caData)

			app.RenderTable(table)

			fmt.Println("")
			fmt.Printf("Certificate:\n%s\n", ca.Data.Body.Certificate)

			if *params.Private {
				fmt.Printf("Private key:\n%s\n", ca.Data.Body.PrivateKey)
			}
		} else {
			var files []ExportFile
			certFile := fmt.Sprintf("%s-cert.pem", ca.Data.Body.Name)
			keyFile := fmt.Sprintf("%s-key.pem", ca.Data.Body.Name)

			files = append(files, ExportFile{Name: certFile, Mode: 0644, Content: []byte(ca.Data.Body.Certificate)})

			if *params.Private {
				files = append(files, ExportFile{Name: keyFile, Mode: 0600, Content: []byte(ca.Data.Body.PrivateKey)})
			}

			Export(files, *params.Export)
		}
	}
}

// ThreatSpec TMv0.1 for caUpdateCmd

func caUpdateCmd(cmd *cli.Cmd) {
	cmd.Spec = "NAME [OPTIONS]"

	params := controller.NewCAParams()
	params.Name = cmd.StringArg("NAME", "", "name of CA")

	params.CertFile = cmd.StringOpt("cert", "", "certificate PEM file")
	params.KeyFile = cmd.StringOpt("key", "", "key PEM file")
	params.Tags = cmd.StringOpt("tags", "", "comma separated list of tags")
	params.CaExpiry = cmd.IntOpt("ca-expiry", 0, "CA expiry period in days")
	params.CertExpiry = cmd.IntOpt("cert-expiry", 0, "Certificate expiry period in days")
	params.DnLocality = cmd.StringOpt("dn-l", "", "Locality for DN scope")
	params.DnState = cmd.StringOpt("dn-st", "", "State/province for DN scope")
	params.DnOrg = cmd.StringOpt("dn-o", "", "Organization for DN scope")
	params.DnOrgUnit = cmd.StringOpt("dn-ou", "", "Organizational unit for DN scope")
	params.DnCountry = cmd.StringOpt("dn-c", "", "Country for DN scope")
	params.DnStreet = cmd.StringOpt("dn-street", "", "Street for DN scope")
	params.DnPostal = cmd.StringOpt("dn-postal", "", "PostalCode for DN scope")

	cmd.Action = func() {
		app := NewAdminApp()
		logger.Info("updating CA")

		cont, err := controller.NewCA(app.env)
		if err != nil {
			app.Fatal(err)
		}

		if err := cont.Update(params); err != nil {
			app.Fatal(err)
		}
	}
}

// ThreatSpec TMv0.1 for caDeleteCmd

func caDeleteCmd(cmd *cli.Cmd) {
	cmd.Spec = "NAME [OPTIONS]"

	params := controller.NewCAParams()
	params.Name = cmd.StringArg("NAME", "", "name of CA")

	params.ConfirmDelete = cmd.StringOpt("confirm-delete", "", "reason for deleting CA")

	cmd.Action = func() {
		app := NewAdminApp()
		logger.Info("deleting CA")

		cont, err := controller.NewCA(app.env)
		if err != nil {
			app.Fatal(err)
		}

		if err := cont.Delete(params); err != nil {
			app.Fatal(err)
		}
	}
}