package azurekms import ( "crypto" "crypto/ecdsa" "crypto/rsa" "encoding/base64" "io" "math/big" "github.com/Azure/azure-sdk-for-go/services/keyvault/v7.1/keyvault" "github.com/pkg/errors" "golang.org/x/crypto/cryptobyte" "golang.org/x/crypto/cryptobyte/asn1" ) // Signer implements a crypto.Signer using the AWS KMS. type Signer struct { client KeyVaultClient vaultBaseURL string name string version string publicKey crypto.PublicKey } // NewSigner creates a new signer using a key in the AWS KMS. func NewSigner(client KeyVaultClient, signingKey string) (crypto.Signer, error) { vault, name, version, _, err := parseKeyName(signingKey) if err != nil { return nil, err } // Make sure that the key exists. signer := &Signer{ client: client, vaultBaseURL: vaultBaseURL(vault), name: name, version: version, } if err := signer.preloadKey(); err != nil { return nil, err } return signer, nil } func (s *Signer) preloadKey() error { ctx, cancel := defaultContext() defer cancel() resp, err := s.client.GetKey(ctx, s.vaultBaseURL, s.name, s.version) if err != nil { return errors.Wrap(err, "keyVault GetKey failed") } s.publicKey, err = convertKey(resp.Key) return err } // Public returns the public key of this signer or an error. func (s *Signer) Public() crypto.PublicKey { return s.publicKey } // Sign signs digest with the private key stored in the AWS KMS. func (s *Signer) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) { alg, err := getSigningAlgorithm(s.Public(), opts) if err != nil { return nil, err } ctx, cancel := defaultContext() defer cancel() b64 := base64.RawURLEncoding.EncodeToString(digest) resp, err := s.client.Sign(ctx, s.vaultBaseURL, s.name, s.version, keyvault.KeySignParameters{ Algorithm: alg, Value: &b64, }) if err != nil { return nil, errors.Wrap(err, "keyVault Sign failed") } sig, err := base64.RawURLEncoding.DecodeString(*resp.Result) if err != nil { return nil, errors.Wrap(err, "error decoding keyVault Sign result") } var octetSize int switch alg { case keyvault.ES256: octetSize = 32 // 256-bit, concat(R,S) = 64 bytes case keyvault.ES384: octetSize = 48 // 384-bit, concat(R,S) = 96 bytes case keyvault.ES512: octetSize = 66 // 528-bit, concat(R,S) = 132 bytes default: return sig, nil } // Convert to ans1 if len(sig) != octetSize*2 { return nil, errors.Errorf("keyVault Sign failed: unexpected signature length") } var b cryptobyte.Builder b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) { b.AddASN1BigInt(new(big.Int).SetBytes(sig[:octetSize])) // R b.AddASN1BigInt(new(big.Int).SetBytes(sig[octetSize:])) // S }) return b.Bytes() } func getSigningAlgorithm(key crypto.PublicKey, opts crypto.SignerOpts) (keyvault.JSONWebKeySignatureAlgorithm, error) { switch key.(type) { case *rsa.PublicKey: hashFunc := opts.HashFunc() pss, isPSS := opts.(*rsa.PSSOptions) // Random salt lengths are not supported if isPSS && pss.SaltLength != rsa.PSSSaltLengthAuto && pss.SaltLength != rsa.PSSSaltLengthEqualsHash && pss.SaltLength != hashFunc.Size() { return "", errors.Errorf("unsupported RSA-PSS salt length %d", pss.SaltLength) } switch h := hashFunc; h { case crypto.SHA256: if isPSS { return keyvault.PS256, nil } return keyvault.RS256, nil case crypto.SHA384: if isPSS { return keyvault.PS384, nil } return keyvault.RS384, nil case crypto.SHA512: if isPSS { return keyvault.PS512, nil } return keyvault.RS512, nil default: return "", errors.Errorf("unsupported hash function %v", h) } case *ecdsa.PublicKey: switch h := opts.HashFunc(); h { case crypto.SHA256: return keyvault.ES256, nil case crypto.SHA384: return keyvault.ES384, nil case crypto.SHA512: return keyvault.ES512, nil default: return "", errors.Errorf("unsupported hash function %v", h) } default: return "", errors.Errorf("unsupported key type %T", key) } }