mirror of
https://github.com/kairos-io/kcrypt.git
synced 2025-07-31 15:10:31 +00:00
e64912f96f
Also use the pasword when refreshing the luks device in order to add discards as it may ask for the password Signed-off-by: Itxaka <itxaka@kairos.io>
123 lines
3.3 KiB
Go
123 lines
3.3 KiB
Go
// package config contains all the logic around kcrypt config
|
|
// This config includes everything below `kcrypt:` in the kairos config yaml
|
|
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/jaypipes/ghw/pkg/block"
|
|
"github.com/kairos-io/kairos-sdk/collector"
|
|
"github.com/pkg/errors"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// There are the directories under which we expect to find kairos configuration.
|
|
// When we are booted from an iso (during installation), configuration is expected
|
|
// under `/oem`. When we are booting an installed system (in initramfs phase),
|
|
// the path is `/sysroot/oem`.
|
|
var ConfigScanDirs = []string{"/oem", "/sysroot/oem"}
|
|
|
|
// This file is "hardcoded" to `/oem` because we only use this at install time
|
|
// in which case the config is in `/oem`.
|
|
var MappingsFile = "/oem/91-kcrypt-mappings.yaml"
|
|
|
|
type Config struct {
|
|
Kcrypt struct {
|
|
UUIDLabelMappings map[string]string `yaml:"uuid_label_mappings,omitempty"`
|
|
}
|
|
}
|
|
|
|
func PartitionToString(p *block.Partition) string {
|
|
return fmt.Sprintf("%s:%s:%s", p.FilesystemLabel, p.Name, p.UUID)
|
|
}
|
|
|
|
// Takes a partition info string (as returned by PartitionToString) and return
|
|
// the partition label and the UUID
|
|
func partitionDataFromString(partitionStr string) (string, string, error) {
|
|
parts := strings.Split(partitionStr, ":")
|
|
if len(parts) != 3 {
|
|
return "", "", errors.New("partition string not valid")
|
|
}
|
|
|
|
return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[2]), nil
|
|
}
|
|
|
|
func GetConfiguration(configDirs []string) (Config, error) {
|
|
var result Config
|
|
|
|
o := &collector.Options{MergeBootCMDLine: false}
|
|
|
|
if err := o.Apply(collector.Directories(configDirs...), collector.NoLogs); err != nil {
|
|
return result, err
|
|
}
|
|
|
|
c, err := collector.Scan(o, func(d []byte) ([]byte, error) {
|
|
return d, nil
|
|
})
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
configStr, err := c.String()
|
|
if err != nil {
|
|
return result, err
|
|
}
|
|
if err = yaml.Unmarshal([]byte(configStr), &result); err != nil {
|
|
return result, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// SetMapping updates the Config with partition information for
|
|
// one partition. This doesn't persist on the file. WriteMappings needs to
|
|
// be called after all mapping are in the Config (possibly with multiple calls
|
|
// to this function).
|
|
func (c *Config) SetMapping(partitionInfo string) error {
|
|
label, uuid, err := partitionDataFromString(partitionInfo)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Initialize map
|
|
if c.Kcrypt.UUIDLabelMappings == nil {
|
|
c.Kcrypt.UUIDLabelMappings = map[string]string{}
|
|
}
|
|
c.Kcrypt.UUIDLabelMappings[label] = uuid
|
|
|
|
return nil
|
|
}
|
|
|
|
// WriteMappings will create or replace the MappingsFile
|
|
// It's called by kairos agent, at installation time, after the partitions
|
|
// have been created (and we have the UUIDs available).
|
|
func (c *Config) WriteMappings(fileName string) error {
|
|
data, err := yaml.Marshal(&c)
|
|
if err != nil {
|
|
return errors.Wrap(err, "marshalling the kcrypt configuration to yaml")
|
|
}
|
|
|
|
data = append([]byte(collector.DefaultHeader+"\n"), data...)
|
|
|
|
err = os.WriteFile(fileName, data, 0744)
|
|
if err != nil {
|
|
return errors.Wrap(err, "writing the kcrypt configuration file")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c Config) LookupUUIDForLabel(l string) string {
|
|
return c.Kcrypt.UUIDLabelMappings[l]
|
|
}
|
|
|
|
func (c Config) LookupLabelForUUID(uuid string) string {
|
|
for k, v := range c.Kcrypt.UUIDLabelMappings {
|
|
if v == uuid {
|
|
return k
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|