Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
212 lines
7.6 KiB
Go
212 lines
7.6 KiB
Go
package store
|
|
|
|
import (
|
|
"crypto/aes"
|
|
"crypto/cipher"
|
|
"crypto/hmac"
|
|
"crypto/rand"
|
|
"crypto/sha1"
|
|
"crypto/sha256"
|
|
"encoding/base32"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
func (s *Store) encryptAuthSecret(plain []byte) (string, error) {
|
|
block, err := aes.NewCipher(s.authKey)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
gcm, err := cipher.NewGCM(block)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
nonce := make([]byte, gcm.NonceSize())
|
|
if _, err = rand.Read(nonce); err != nil {
|
|
return "", err
|
|
}
|
|
sealed := gcm.Seal(nonce, nonce, plain, nil)
|
|
return base64.RawStdEncoding.EncodeToString(sealed), nil
|
|
}
|
|
func (s *Store) decryptAuthSecret(encoded string) ([]byte, error) {
|
|
sealed, err := base64.RawStdEncoding.DecodeString(encoded)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
block, err := aes.NewCipher(s.authKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
gcm, err := cipher.NewGCM(block)
|
|
if err != nil || len(sealed) < gcm.NonceSize() {
|
|
return nil, errors.New("invalid encrypted secret")
|
|
}
|
|
return gcm.Open(nil, sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():], nil)
|
|
}
|
|
|
|
func (s *Store) BeginTOTPEnrollment(principalUUID string) (string, error) {
|
|
raw := make([]byte, 20)
|
|
if _, err := rand.Read(raw); err != nil {
|
|
return "", err
|
|
}
|
|
secret := base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(raw)
|
|
encrypted, err := s.encryptAuthSecret([]byte(secret))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
_, err = s.DB.Exec(`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,parameters_json,enabled,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'{}',0,?,?) ON CONFLICT(kind,identifier) DO UPDATE SET secret_hash=excluded.secret_hash,parameters_json='{}',enabled=0,updated_at_ms=excluded.updated_at_ms`, uuid.NewString(), principalUUID, "totp-pending", principalUUID, encrypted, now, now)
|
|
return secret, err
|
|
}
|
|
func totpCode(secret string, counter int64) (string, error) {
|
|
key, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(strings.ToUpper(secret))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
buf := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(buf, uint64(counter))
|
|
mac := hmac.New(sha1.New, key)
|
|
_, _ = mac.Write(buf)
|
|
sum := mac.Sum(nil)
|
|
offset := sum[len(sum)-1] & 15
|
|
value := (uint32(sum[offset])&0x7f)<<24 | uint32(sum[offset+1])<<16 | uint32(sum[offset+2])<<8 | uint32(sum[offset+3])
|
|
return fmt.Sprintf("%06d", value%1000000), nil
|
|
}
|
|
func verifyTOTPCode(secret, code string, last int64) (int64, bool) {
|
|
code = strings.TrimSpace(code)
|
|
now := time.Now().Unix() / 30
|
|
for delta := int64(-1); delta <= 1; delta++ {
|
|
counter := now + delta
|
|
if counter <= last {
|
|
continue
|
|
}
|
|
expected, err := totpCode(secret, counter)
|
|
if err == nil && hmac.Equal([]byte(expected), []byte(code)) {
|
|
return counter, true
|
|
}
|
|
}
|
|
return 0, false
|
|
}
|
|
func (s *Store) confirmTOTP(principalUUID, kind, code string) (int64, error) {
|
|
var encrypted, params string
|
|
err := s.DB.QueryRow(`SELECT secret_hash,parameters_json FROM auth_credentials WHERE principal_uuid=? AND kind=? AND identifier=?`, principalUUID, kind, principalUUID).Scan(&encrypted, ¶ms)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
plain, err := s.decryptAuthSecret(encrypted)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
var state struct {
|
|
LastCounter int64 `json:"last_counter"`
|
|
}
|
|
_ = json.Unmarshal([]byte(params), &state)
|
|
counter, ok := verifyTOTPCode(string(plain), code, state.LastCounter)
|
|
if !ok {
|
|
return 0, ErrAccessDenied
|
|
}
|
|
return counter, nil
|
|
}
|
|
func (s *Store) ConfirmTOTPEnrollment(principalUUID, code string) error {
|
|
counter, err := s.confirmTOTP(principalUUID, "totp-pending", code)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
_, _ = tx.Exec(`DELETE FROM auth_credentials WHERE principal_uuid=? AND kind='totp'`, principalUUID)
|
|
_, err = tx.Exec(`UPDATE auth_credentials SET kind='totp',enabled=1,parameters_json=?,updated_at_ms=? WHERE principal_uuid=? AND kind='totp-pending'`, string(params), time.Now().UnixMilli(), principalUUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
func (s *Store) HasTOTP(principalUUID string) bool {
|
|
var exists int
|
|
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM auth_credentials WHERE principal_uuid=? AND kind='totp' AND enabled=1)`, principalUUID).Scan(&exists)
|
|
return exists != 0
|
|
}
|
|
func (s *Store) PendingTOTPSecret(principalUUID string) string {
|
|
var encrypted string
|
|
if s.DB.QueryRow(`SELECT secret_hash FROM auth_credentials WHERE principal_uuid=? AND kind='totp-pending'`, principalUUID).Scan(&encrypted) != nil {
|
|
return ""
|
|
}
|
|
plain, err := s.decryptAuthSecret(encrypted)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return string(plain)
|
|
}
|
|
func (s *Store) VerifyTOTP(principalUUID, code string) error {
|
|
counter, err := s.confirmTOTP(principalUUID, "totp", code)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
params, _ := json.Marshal(map[string]int64{"last_counter": counter})
|
|
result, err := s.DB.Exec(`UPDATE auth_credentials SET parameters_json=?,updated_at_ms=? WHERE principal_uuid=? AND kind='totp' AND CAST(COALESCE(json_extract(parameters_json,'$.last_counter'),0) AS INTEGER)<?`, string(params), time.Now().UnixMilli(), principalUUID, counter)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
changed, _ := result.RowsAffected()
|
|
if changed != 1 {
|
|
return ErrAccessDenied
|
|
}
|
|
return nil
|
|
}
|
|
func (s *Store) DisableTOTP(principalUUID string) error {
|
|
_, err := s.DB.Exec(`DELETE FROM auth_credentials WHERE principal_uuid=? AND kind IN ('totp','totp-pending')`, principalUUID)
|
|
return err
|
|
}
|
|
|
|
func TOTPURI(secret, account, issuer string) string {
|
|
query := url.Values{"secret": {secret}, "issuer": {issuer}, "algorithm": {"SHA1"}, "digits": {"6"}, "period": {"30"}}
|
|
return "otpauth://totp/" + url.PathEscape(issuer+":"+account) + "?" + query.Encode()
|
|
}
|
|
|
|
func (s *Store) CreateTOTPLoginChallenge(domainUUID, principalUUID string) (string, error) {
|
|
token, hash, err := authToken()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
payload, _ := json.Marshal(map[string]string{"principal_uuid": principalUUID})
|
|
_, err = s.DB.Exec(`INSERT INTO auth_challenges(uuid,domain_uuid,principal_uuid,kind,token_hash,payload_json,expires_at_ms,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, uuid.NewString(), domainUUID, principalUUID, "totp-login", hash, string(payload), now+5*60*1000, now)
|
|
return token, err
|
|
}
|
|
func (s *Store) CompleteTOTPLoginChallenge(domainUUID, token, code string) (string, error) {
|
|
sum := sha256.Sum256([]byte(token))
|
|
hash := base64.RawURLEncoding.EncodeToString(sum[:])
|
|
var challengeUUID, principalUUID string
|
|
var expires int64
|
|
var attempts int
|
|
err := s.DB.QueryRow(`SELECT uuid,principal_uuid,expires_at_ms,attempt_count FROM auth_challenges WHERE domain_uuid=? AND kind='totp-login' AND token_hash=? AND consumed_at_ms=0`, domainUUID, hash).Scan(&challengeUUID, &principalUUID, &expires, &attempts)
|
|
if err != nil || expires < time.Now().UnixMilli() || attempts >= 5 {
|
|
return "", ErrAccessDenied
|
|
}
|
|
if err = s.VerifyTOTP(principalUUID, code); err != nil {
|
|
_, _ = s.DB.Exec(`UPDATE auth_challenges SET attempt_count=attempt_count+1,consumed_at_ms=CASE WHEN attempt_count+1>=5 THEN ? ELSE consumed_at_ms END WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), challengeUUID)
|
|
return "", err
|
|
}
|
|
result, err := s.DB.Exec(`UPDATE auth_challenges SET consumed_at_ms=? WHERE uuid=? AND consumed_at_ms=0`, time.Now().UnixMilli(), challengeUUID)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
changed, _ := result.RowsAffected()
|
|
if changed != 1 {
|
|
return "", ErrAccessDenied
|
|
}
|
|
return principalUUID, nil
|
|
}
|