mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
244 lines
5.6 KiB
Go
244 lines
5.6 KiB
Go
package retriable
|
|
|
|
import (
|
|
"crypto"
|
|
"crypto/ecdsa"
|
|
"crypto/elliptic"
|
|
"crypto/rsa"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"net/url"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/effective-security/porto/x/slices"
|
|
"github.com/effective-security/xlog"
|
|
"github.com/effective-security/xpki/jwt/dpop"
|
|
"github.com/mitchellh/go-homedir"
|
|
"github.com/pkg/errors"
|
|
"gopkg.in/square/go-jose.v2"
|
|
)
|
|
|
|
const (
|
|
authTokenFileName = ".auth_token"
|
|
)
|
|
|
|
// Storage provides Client storage
|
|
type Storage struct {
|
|
folder string
|
|
envAuthTokenName string
|
|
}
|
|
|
|
// OpenStorage returns Storage
|
|
func OpenStorage(baseFolder, host, envAuthTokenName string) *Storage {
|
|
folder := ExpandFolder(baseFolder)
|
|
if host != "" {
|
|
folder = path.Join(folder, HostFolderName(host))
|
|
}
|
|
return &Storage{folder: folder, envAuthTokenName: envAuthTokenName}
|
|
}
|
|
|
|
// Clean removes all stored files
|
|
func (c *Storage) Clean() {
|
|
os.RemoveAll(c.folder)
|
|
}
|
|
|
|
// SaveAuthToken persists auth token
|
|
// the token format can be as opaque string, or as form encoded
|
|
// access_token={token}&exp={unix_time}&dpop_jkt={jkt}&token_type={Bearer|DPoP}
|
|
func (c *Storage) SaveAuthToken(token string) error {
|
|
_ = os.MkdirAll(c.folder, 0755)
|
|
err := os.WriteFile(path.Join(c.folder, authTokenFileName), []byte(token), 0600)
|
|
if err != nil {
|
|
return errors.WithMessagef(err, "unable to store token")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// LoadKey returns *jose.JSONWebKey
|
|
func (c *Storage) LoadKey(label string) (*jose.JSONWebKey, string, error) {
|
|
path := path.Join(c.folder, label+".jwk")
|
|
return dpop.LoadKey(path)
|
|
}
|
|
|
|
// SaveKey saves the key to storage
|
|
func (c *Storage) SaveKey(k *jose.JSONWebKey) (string, error) {
|
|
return dpop.SaveKey(c.folder, k)
|
|
}
|
|
|
|
// LoadAuthToken returns LoadAuthToken
|
|
func (c *Storage) LoadAuthToken() (*AuthToken, error) {
|
|
if c.envAuthTokenName != "" {
|
|
val := os.Getenv(c.envAuthTokenName)
|
|
if val != "" {
|
|
return ParseAuthToken(val)
|
|
}
|
|
}
|
|
return LoadAuthToken(c.folder)
|
|
}
|
|
|
|
// LoadAuthToken loads .auth_token file
|
|
func LoadAuthToken(dir string) (*AuthToken, error) {
|
|
file := path.Join(dir, ".auth_token")
|
|
t, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, "credentials not found")
|
|
}
|
|
return ParseAuthToken(string(t))
|
|
}
|
|
|
|
// AuthToken provides auth token info
|
|
type AuthToken struct {
|
|
Raw string
|
|
AccessToken string
|
|
RefreshToken string
|
|
TokenType string
|
|
DpopJkt string
|
|
Expires *time.Time
|
|
}
|
|
|
|
// Expired returns true if expiry is present on the token,
|
|
// and is behind the current time
|
|
func (t *AuthToken) Expired() bool {
|
|
return t.Expires != nil && t.Expires.Before(time.Now())
|
|
}
|
|
|
|
// ParseAuthToken parses stored token and validates expiration
|
|
func ParseAuthToken(rawToken string) (*AuthToken, error) {
|
|
t := &AuthToken{
|
|
Raw: rawToken,
|
|
TokenType: "Bearer",
|
|
AccessToken: rawToken,
|
|
}
|
|
if strings.Contains(rawToken, "=") {
|
|
vals, err := url.ParseQuery(rawToken)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(err, "failed to parse token values")
|
|
}
|
|
t.AccessToken = slices.StringsCoalesce(getValue(vals, "access_token"),
|
|
getValue(vals, "id_token"),
|
|
getValue(vals, "token"))
|
|
t.RefreshToken = getValue(vals, "refresh_token")
|
|
t.DpopJkt = getValue(vals, "dpop_jkt")
|
|
|
|
exp := getValue(vals, "exp")
|
|
if exp != "" {
|
|
ux, err := strconv.ParseInt(exp, 10, 64)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(err, "invalid exp value")
|
|
}
|
|
expires := time.Unix(ux, 0)
|
|
t.Expires = &expires
|
|
}
|
|
}
|
|
|
|
return t, nil
|
|
}
|
|
|
|
// ExpandFolder returns expanded StorageFolder
|
|
func ExpandFolder(dir string) string {
|
|
if dir == "" {
|
|
dirname, _ := os.UserHomeDir()
|
|
// returns default
|
|
dir = path.Join(dirname, ".config", ".retriable")
|
|
}
|
|
dir, _ = homedir.Expand(dir)
|
|
return dir
|
|
}
|
|
|
|
// ListKeys returns list of DPoP keys in the storage
|
|
func (c *Storage) ListKeys() ([]*KeyInfo, error) {
|
|
list := []*KeyInfo{}
|
|
|
|
// load from the folder
|
|
err := filepath.Walk(c.folder, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
logger.KV(xlog.ERROR, "path", path, "err", err.Error())
|
|
return err
|
|
}
|
|
if info.IsDir() || !strings.HasSuffix(info.Name(), ".jwk") {
|
|
logger.KV(xlog.DEBUG, "skip", path)
|
|
return nil
|
|
}
|
|
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
logger.KV(xlog.DEBUG, "skip", path, "err", err.Error())
|
|
return nil
|
|
}
|
|
k := new(jose.JSONWebKey)
|
|
err = json.Unmarshal(b, k)
|
|
if err != nil {
|
|
logger.KV(xlog.DEBUG, "skip", path, "err", err.Error())
|
|
return nil
|
|
}
|
|
|
|
ki, err := NewKeyInfo(k)
|
|
if err != nil {
|
|
logger.KV(xlog.DEBUG, "skip", path, "err", err.Error())
|
|
return nil
|
|
}
|
|
list = append(list, ki)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
logger.KV(xlog.DEBUG, "folder", c.folder, "err", err.Error())
|
|
//return nil, err
|
|
}
|
|
|
|
return list, nil
|
|
}
|
|
|
|
// KeyInfo specifies key info
|
|
type KeyInfo struct {
|
|
KeySize int
|
|
Type string
|
|
Algo string
|
|
Thumbprint string
|
|
Key *jose.JSONWebKey
|
|
}
|
|
|
|
// NewKeyInfo returns *keyInfo
|
|
func NewKeyInfo(k *jose.JSONWebKey) (*KeyInfo, error) {
|
|
tp, err := k.Thumbprint(crypto.SHA256)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
si := &KeyInfo{
|
|
Key: k,
|
|
Thumbprint: base64.RawURLEncoding.EncodeToString(tp),
|
|
}
|
|
|
|
switch typ := k.Key.(type) {
|
|
case *rsa.PrivateKey:
|
|
si.KeySize = typ.N.BitLen()
|
|
si.Type = "RSA"
|
|
switch {
|
|
case si.KeySize >= 4096:
|
|
si.Algo = "RS512"
|
|
case si.KeySize >= 3072:
|
|
si.Algo = "RS384"
|
|
default:
|
|
si.Algo = "RS256"
|
|
}
|
|
case *ecdsa.PrivateKey:
|
|
si.Type = "ECDSA"
|
|
switch typ.Curve {
|
|
case elliptic.P521():
|
|
si.Algo = "ES512"
|
|
case elliptic.P384():
|
|
si.Algo = "ES384"
|
|
default:
|
|
si.Algo = "ES256"
|
|
}
|
|
si.KeySize = typ.Curve.Params().BitSize
|
|
default:
|
|
return nil, errors.Errorf("key not supported: %T", typ)
|
|
}
|
|
return si, nil
|
|
}
|