// Copyright 2024 The Update Framework Authors // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License // // SPDX-License-Identifier: Apache-2.0 // package config import ( "fmt" "net/http" "net/url" "os" "time" "github.com/cenkalti/backoff/v5" "github.com/theupdateframework/go-tuf/v2/metadata/fetcher" ) type UpdaterConfig struct { // TUF configuration MaxRootRotations int64 MaxDelegations int RootMaxLength int64 TimestampMaxLength int64 SnapshotMaxLength int64 TargetsMaxLength int64 // Updater configuration Fetcher fetcher.Fetcher LocalTrustedRoot []byte LocalMetadataDir string LocalTargetsDir string RemoteMetadataURL string RemoteTargetsURL string DisableLocalCache bool PrefixTargetsWithHash bool // UnsafeLocalMode only uses the metadata as written on disk // if the metadata is incomplete, calling updater.Refresh will fail UnsafeLocalMode bool } // New creates a new UpdaterConfig instance used by the Updater to // store configuration func New(remoteURL string, rootBytes []byte) (*UpdaterConfig, error) { // Default URL for target files - /targets targetsURL, err := url.JoinPath(remoteURL, "targets") if err != nil { return nil, err } return &UpdaterConfig{ // TUF configuration MaxRootRotations: 256, MaxDelegations: 32, RootMaxLength: 512000, // bytes TimestampMaxLength: 16384, // bytes SnapshotMaxLength: 2000000, // bytes TargetsMaxLength: 5000000, // bytes // Updater configuration Fetcher: fetcher.NewDefaultFetcher(), // use the default built-in download fetcher LocalTrustedRoot: rootBytes, // trusted root.json RemoteMetadataURL: remoteURL, // URL of where the TUF metadata is RemoteTargetsURL: targetsURL, // URL of where the target files should be downloaded from DisableLocalCache: false, // enable local caching of trusted metadata PrefixTargetsWithHash: true, // use hash-prefixed target files with consistent snapshots UnsafeLocalMode: false, }, nil } func (cfg *UpdaterConfig) EnsurePathsExist() error { if cfg.DisableLocalCache { return nil } for _, path := range []string{cfg.LocalMetadataDir, cfg.LocalTargetsDir} { // Use 0700 for cache directories: only the owner can read, write, and // access the directory. This prevents other users on shared systems from // reading or writing to the TUF cache, which could be a security risk. // If different permissions are needed, pre-create the directories with // the desired permissions before calling this function. if err := os.MkdirAll(path, 0700); err != nil { return err } } return nil } func (cfg *UpdaterConfig) SetDefaultFetcherHTTPClient(client *http.Client) error { // Check if the configured fetcher is the default fetcher // since we are only configuring a http.Client value for the default fetcher df, ok := cfg.Fetcher.(*fetcher.DefaultFetcher) if !ok { return fmt.Errorf("fetcher is not type fetcher.DefaultFetcher") } df.SetHTTPClient(client) cfg.Fetcher = df return nil } func (cfg *UpdaterConfig) SetDefaultFetcherTransport(rt http.RoundTripper) error { // Check if the configured fetcher is the default fetcher // since we are only configuring a Transport value for the default fetcher df, ok := cfg.Fetcher.(*fetcher.DefaultFetcher) if !ok { return fmt.Errorf("fetcher is not type fetcher.DefaultFetcher") } if err := df.SetTransport(rt); err != nil { return err } cfg.Fetcher = df return nil } // SetDefaultFetcherRetry sets the constant retry interval and count for the default fetcher func (cfg *UpdaterConfig) SetDefaultFetcherRetry(retryInterval time.Duration, retryCount uint) error { // Check if the configured fetcher is the default fetcher // since we are only configuring the retry interval and count for the default fetcher df, ok := cfg.Fetcher.(*fetcher.DefaultFetcher) if !ok { return fmt.Errorf("fetcher is not type fetcher.DefaultFetcher") } df.SetRetry(retryInterval, retryCount) cfg.Fetcher = df return nil } func (cfg *UpdaterConfig) SetRetryOptions(retryOptions ...backoff.RetryOption) error { // Check if the configured fetcher is the default fetcher // since we are only configuring retry options for the default fetcher df, ok := cfg.Fetcher.(*fetcher.DefaultFetcher) if !ok { return fmt.Errorf("fetcher is not type fetcher.DefaultFetcher") } df.SetRetryOptions(retryOptions...) cfg.Fetcher = df return nil }