github.com/jfrog/jfrog-cli-core/v2@v2.51.0/utils/config/configtoken.go (about)

     1  package config
     2  
     3  import (
     4  	"encoding/base64"
     5  	"encoding/json"
     6  
     7  	"github.com/jfrog/jfrog-client-go/utils/errorutils"
     8  )
     9  
    10  const tokenVersion = 2
    11  
    12  type configToken struct {
    13  	Version              int    `json:"version,omitempty"`
    14  	Url                  string `json:"url,omitempty"`
    15  	ArtifactoryUrl       string `json:"artifactoryUrl,omitempty"`
    16  	DistributionUrl      string `json:"distributionUrl,omitempty"`
    17  	XrayUrl              string `json:"xrayUrl,omitempty"`
    18  	MissionControlUrl    string `json:"missionControlUrl,omitempty"`
    19  	PipelinesUrl         string `json:"pipelinesUrl,omitempty"`
    20  	User                 string `json:"user,omitempty"`
    21  	Password             string `json:"password,omitempty"`
    22  	SshKeyPath           string `json:"sshKeyPath,omitempty"`
    23  	SshPassphrase        string `json:"sshPassphrase,omitempty"`
    24  	AccessToken          string `json:"accessToken,omitempty"`
    25  	RefreshToken         string `json:"refreshToken,omitempty"`
    26  	TokenRefreshInterval int    `json:"tokenRefreshInterval,omitempty"`
    27  	ClientCertPath       string `json:"clientCertPath,omitempty"`
    28  	ClientCertKeyPath    string `json:"clientCertKeyPath,omitempty"`
    29  	ServerId             string `json:"serverId,omitempty"`
    30  }
    31  
    32  func (token *configToken) convertToV2() {
    33  	if token.ArtifactoryUrl == "" {
    34  		token.ArtifactoryUrl = token.Url
    35  		token.Url = ""
    36  	}
    37  }
    38  
    39  func fromServerDetails(details *ServerDetails) *configToken {
    40  	return &configToken{
    41  		Version:              tokenVersion,
    42  		Url:                  details.Url,
    43  		ArtifactoryUrl:       details.ArtifactoryUrl,
    44  		DistributionUrl:      details.DistributionUrl,
    45  		XrayUrl:              details.XrayUrl,
    46  		MissionControlUrl:    details.MissionControlUrl,
    47  		PipelinesUrl:         details.PipelinesUrl,
    48  		User:                 details.User,
    49  		Password:             details.Password,
    50  		SshKeyPath:           details.SshKeyPath,
    51  		SshPassphrase:        details.SshPassphrase,
    52  		AccessToken:          details.AccessToken,
    53  		RefreshToken:         details.ArtifactoryRefreshToken,
    54  		TokenRefreshInterval: details.ArtifactoryTokenRefreshInterval,
    55  		ClientCertPath:       details.ClientCertPath,
    56  		ClientCertKeyPath:    details.ClientCertKeyPath,
    57  		ServerId:             details.ServerId,
    58  	}
    59  }
    60  
    61  func toServerDetails(detailsSerialization *configToken) *ServerDetails {
    62  	return &ServerDetails{
    63  		Url:                             detailsSerialization.Url,
    64  		ArtifactoryUrl:                  detailsSerialization.ArtifactoryUrl,
    65  		DistributionUrl:                 detailsSerialization.DistributionUrl,
    66  		MissionControlUrl:               detailsSerialization.MissionControlUrl,
    67  		PipelinesUrl:                    detailsSerialization.PipelinesUrl,
    68  		XrayUrl:                         detailsSerialization.XrayUrl,
    69  		User:                            detailsSerialization.User,
    70  		Password:                        detailsSerialization.Password,
    71  		SshKeyPath:                      detailsSerialization.SshKeyPath,
    72  		SshPassphrase:                   detailsSerialization.SshPassphrase,
    73  		AccessToken:                     detailsSerialization.AccessToken,
    74  		ArtifactoryRefreshToken:         detailsSerialization.RefreshToken,
    75  		ArtifactoryTokenRefreshInterval: detailsSerialization.TokenRefreshInterval,
    76  		ClientCertPath:                  detailsSerialization.ClientCertPath,
    77  		ClientCertKeyPath:               detailsSerialization.ClientCertKeyPath,
    78  		ServerId:                        detailsSerialization.ServerId,
    79  	}
    80  }
    81  
    82  func Export(details *ServerDetails) (string, error) {
    83  	conf, err := readConf()
    84  	if err != nil {
    85  		return "", err
    86  	}
    87  	// If config is encrypted, ask for master key.
    88  	if conf.Enc {
    89  		masterKeyFromFile, err := getEncryptionKey()
    90  		if err != nil {
    91  			return "", err
    92  		}
    93  		masterKeyFromConsole, err := readMasterKeyFromConsole()
    94  		if err != nil {
    95  			return "", err
    96  		}
    97  		if masterKeyFromConsole != masterKeyFromFile {
    98  			return "", errorutils.CheckErrorf("could not generate config token: config is encrypted, and wrong master key was provided")
    99  		}
   100  	}
   101  	buffer, err := json.Marshal(fromServerDetails(details))
   102  	if err != nil {
   103  		return "", err
   104  	}
   105  	return base64.StdEncoding.EncodeToString(buffer), nil
   106  }
   107  
   108  func Import(configTokenString string) (*ServerDetails, error) {
   109  	decoded, err := base64.StdEncoding.DecodeString(configTokenString)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  	token := &configToken{}
   114  	if err = json.Unmarshal(decoded, token); err != nil {
   115  		return nil, err
   116  	}
   117  	if token.Version < tokenVersion {
   118  		token.convertToV2()
   119  	}
   120  	return toServerDetails(token), nil
   121  }