cmd

Documentation

Index

• Variables
• func Execute() error

Variables

var Diff = cli.Command{
	Name:      "diff",
	Usage:     "Compare OSCAL resources semantically item by item",
	ArgsUsage: "FILE1 FILE2",
	Before: func(c *cli.Context) error {
		if c.NArg() != 2 {
			return cli.NewExitError("Please supply exactly file paths as command-line arguments", 1)
		}
		return nil
	},
	Action: func(c *cli.Context) error {
		fileA, fileB := c.Args()[0], c.Args()[1]
		osA, err := oscal_source.Open(fileA)
		if err != nil {
			return cli.NewExitError(fmt.Sprintf("Could not open oscal file %s: %v", fileA, err), 1)
		}
		defer osA.Close()

		osB, err := oscal_source.Open(fileB)
		if err != nil {
			return cli.NewExitError(fmt.Sprintf("Could not open oscal file %s: %v", fileB, err), 1)
		}
		defer osB.Close()

		text, err := oscal_diff.Diff(osA.OSCAL(), osB.OSCAL())
		fmt.Println(text)
		if err != nil {
			return err
		}
		if text != "" {
			return cli.NewExitError("", 2)
		}
		return nil
	},
}

var Info = cli.Command{
	Name:      "info",
	Usage:     "Provides information about particular OSCAL resource",
	ArgsUsage: "file [file...]",
	Before: func(c *cli.Context) error {
		if c.NArg() == 0 {
			return cli.NewExitError("No file provided", 1)
		}
		return nil
	},
	Action: func(c *cli.Context) error {
		for _, filePath := range c.Args() {
			os, err := oscal_source.Open(filePath)
			if err != nil {
				return cli.NewExitError(fmt.Sprintf("Could not open oscal file: %v", err), 1)
			}
			defer os.Close()

			err = printInfo(os.OSCAL())
			if err != nil {
				return err
			}
		}
		return nil
	},
}

var Sign = cli.Command{
	Name:      "sign",
	Usage:     "sign OSCAL JSON artifacts",
	ArgsUsage: "[files...]",
	Flags: []cli.Flag{
		cli.StringFlag{
			Name:        "key, k",
			Usage:       "private key file for signing. Must be in PEM or DER formats. Supports RSA/EC keys and X.509 certificats with embedded RSA/EC keys",
			Destination: &privKey,
		},
		cli.StringFlag{
			Name:        "alg, a",
			Usage:       "algorithm for signing. Supports RSASSA-PKCS#1v1.5, RSASSA-PSS, HMAC, ECDSA and Ed25519",
			Destination: &alg,
		},
	},
	Before: func(c *cli.Context) error {
		if privKey == "" {
			return cli.NewExitError("gocomply_oscalkit sign is missing the --key flag", 1)
		}

		if alg == "" {
			return cli.NewExitError("gocomply_oscalkit sign is missing the --alg flag", 1)
		}

		if c.NArg() < 1 {
			return cli.NewExitError("gocomply_oscalkit sign requires at least one argument", 1)
		}

		return nil
	},
	Action: func(c *cli.Context) error {
		for _, srcFile := range c.Args() {
			privKeyFile, err := ioutil.ReadFile(privKey)
			if err != nil {
				return cli.NewExitError(fmt.Sprintf("Error loading private key file %s: %s", privKey, err), 1)
			}

			srcFileData, err := ioutil.ReadFile(srcFile)
			if err != nil {
				return cli.NewExitError(fmt.Sprintf("Error reading source file %s: %s", srcFile, err), 1)
			}

			input := privKeyFile
			block, _ := pem.Decode(privKeyFile)
			if block != nil {
				input = block.Bytes
			}

			var priv interface{}
			var msg string
			priv, err0 := x509.ParsePKCS1PrivateKey(input)
			if err0 == nil {
				msg, err = sign(priv, srcFileData)
				if err != nil {
					return cli.NewExitError(fmt.Sprintf("Signing error: %s", err), 1)
				}
			}

			priv, err1 := x509.ParsePKCS8PrivateKey(input)
			if err1 == nil {
				msg, err = sign(priv, srcFileData)
				if err != nil {
					return cli.NewExitError(fmt.Sprintf("Signing error: %s", err), 1)
				}
			}

			priv, err2 := x509.ParseECPrivateKey(input)
			if err2 == nil {
				msg, err = sign(priv, srcFileData)
				if err != nil {
					return cli.NewExitError(fmt.Sprintf("Signing error: %s", err), 1)
				}
			}

			if msg != "" {
				splitPath := strings.Split(path.Base(srcFile), ".")
				filePath := fmt.Sprintf("%s-SIGNED.%s", splitPath[0], splitPath[1])
				if err := ioutil.WriteFile(filePath, []byte(msg), 0644); err != nil {
					return cli.NewExitError(fmt.Sprintf("Error writing signed file: %s", err), 1)
				}

				continue
			}

			return cli.NewExitError(fmt.Sprintf("Error parsing private key: %s, %s, %s", err0, err1, err2), 1)
		}

		return nil
	},
}

Sign ...

var Validate = cli.Command{
	Name:        "validate",
	Usage:       "validate files against OSCAL XML and JSON schemas",
	Description: `Validate OSCAL-formatted files against a specific OSCAL schema`,
	ArgsUsage:   "[files...]",
	Before: func(c *cli.Context) error {
		if c.NArg() < 1 {
			return cli.NewExitError("gocomply_oscalkit validate requires at least one argument", 1)
		}
		return nil
	},
	Action: func(c *cli.Context) error {
		for _, filePath := range c.Args() {
			os, err := oscal_source.Open(filePath)
			if err != nil {
				return cli.NewExitError(fmt.Sprintf("Could not open oscal file %s: %v", filePath, err), 1)
			}
			defer os.Close()

			err = os.Validate()
			if err != nil {
				return cli.NewExitError(err, 1)
			}
		}
		return nil
	},
}

Validate ...

Functions

func Execute

func Execute() error

Execute ...