sdk/go/keepclient/perms.go

   1 // Generate and verify permission signatures for Keep locators.
   2 //
   3 // See https://dev.arvados.org/projects/arvados/wiki/Keep_locator_format
   4
   5 package keepclient
   6
   7 import (
   8         "crypto/hmac"
   9         "crypto/sha1"
  10         "errors"
  11         "fmt"
  12         "regexp"
  13         "strconv"
  14         "strings"
  15         "time"
  16 )
  17
  18 var (
  19         // ErrSignatureExpired - a signature was rejected because the
  20         // expiry time has passed.
  21         ErrSignatureExpired = errors.New("Signature expired")
  22         // ErrSignatureInvalid - a signature was rejected because it
  23         // was badly formatted or did not match the given secret key.
  24         ErrSignatureInvalid = errors.New("Invalid signature")
  25         // ErrSignatureMissing - the given locator does not have a
  26         // signature hint.
  27         ErrSignatureMissing = errors.New("Missing signature")
  28 )
  29
  30 // makePermSignature generates a SHA-1 HMAC digest for the given blob,
  31 // token, expiry, and site secret.
  32 func makePermSignature(blobHash, apiToken, expiry, blobSignatureTTL string, permissionSecret []byte) string {
  33         hmac := hmac.New(sha1.New, permissionSecret)
  34         hmac.Write([]byte(blobHash))
  35         hmac.Write([]byte("@"))
  36         hmac.Write([]byte(apiToken))
  37         hmac.Write([]byte("@"))
  38         hmac.Write([]byte(expiry))
  39         hmac.Write([]byte("@"))
  40         hmac.Write([]byte(blobSignatureTTL))
  41         digest := hmac.Sum(nil)
  42         return fmt.Sprintf("%x", digest)
  43 }
  44
  45 // SignLocator returns blobLocator with a permission signature
  46 // added. If either permissionSecret or apiToken is empty, blobLocator
  47 // is returned untouched.
  48 //
  49 // This function is intended to be used by system components and admin
  50 // utilities: userland programs do not know the permissionSecret.
  51 func SignLocator(blobLocator, apiToken string, expiry time.Time, blobSignatureTTL time.Duration, permissionSecret []byte) string {
  52         if len(permissionSecret) == 0 || apiToken == "" {
  53                 return blobLocator
  54         }
  55         // Strip off all hints: only the hash is used to sign.
  56         blobHash := strings.Split(blobLocator, "+")[0]
  57         timestampHex := fmt.Sprintf("%08x", expiry.Unix())
  58         blobSignatureTTLHex := strconv.FormatInt(int64(blobSignatureTTL.Seconds()), 16)
  59         return blobLocator +
  60                 "+A" + makePermSignature(blobHash, apiToken, timestampHex, blobSignatureTTLHex, permissionSecret) +
  61                 "@" + timestampHex
  62 }
  63
  64 var signedLocatorRe = regexp.MustCompile(`^([[:xdigit:]]{32}).*\+A([[:xdigit:]]{40})@([[:xdigit:]]{8})`)
  65
  66 // VerifySignature returns nil if the signature on the signedLocator
  67 // can be verified using the given apiToken. Otherwise it returns
  68 // ErrSignatureExpired (if the signature's expiry time has passed,
  69 // which is something the client could have figured out
  70 // independently), ErrSignatureMissing (if there is no signature hint
  71 // at all), or ErrSignatureInvalid (if the signature is present but
  72 // badly formatted or incorrect).
  73 //
  74 // This function is intended to be used by system components and admin
  75 // utilities: userland programs do not know the permissionSecret.
  76 func VerifySignature(signedLocator, apiToken string, blobSignatureTTL time.Duration, permissionSecret []byte) error {
  77         matches := signedLocatorRe.FindStringSubmatch(signedLocator)
  78         if matches == nil {
  79                 return ErrSignatureMissing
  80         }
  81         blobHash := matches[1]
  82         signatureHex := matches[2]
  83         expiryHex := matches[3]
  84         if expiryTime, err := parseHexTimestamp(expiryHex); err != nil {
  85                 return ErrSignatureInvalid
  86         } else if expiryTime.Before(time.Now()) {
  87                 return ErrSignatureExpired
  88         }
  89         blobSignatureTTLHex := strconv.FormatInt(int64(blobSignatureTTL.Seconds()), 16)
  90         if signatureHex != makePermSignature(blobHash, apiToken, expiryHex, blobSignatureTTLHex, permissionSecret) {
  91                 return ErrSignatureInvalid
  92         }
  93         return nil
  94 }
  95
  96 func parseHexTimestamp(timestampHex string) (ts time.Time, err error) {
  97         if tsInt, e := strconv.ParseInt(timestampHex, 16, 0); e == nil {
  98                 ts = time.Unix(tsInt, 0)
  99         } else {
 100                 err = e
 101         }
 102         return ts, err
 103 }