ECDSA keys about acme HOT 12 CLOSED

diff --git a/acme.go b/acme.go
index 5f16a38..4836410 100644
--- a/acme.go
+++ b/acme.go
@@ -17,7 +17,7 @@ package acme

 import (
    "bytes"
-   "crypto/rsa"
+   "crypto"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
@@ -116,7 +116,8 @@ type AuthzID struct {
 // Client implements ACME spec.
 type Client struct {
    http.Client
-   Key *rsa.PrivateKey
+   // Key.Public() must be *rsa.PublicKey or *ecdsa.PublicKey
+   Key crypto.Signer
 }

 // CertSource creates new CertSource using client c.
@@ -268,6 +269,11 @@ func (c *Client) GetChallenge(url string) (*Challenge, error) {
 //
 // The server will then perform the validation asynchronously.
 func (c *Client) Accept(chal *Challenge) (*Challenge, error) {
+   auth, err := keyAuth(c.Key.Public(), chal.Token)
+   if err != nil {
+       return nil, err
+   }
+
    req := struct {
        Resource string `json:"resource"`
        Type     string `json:"type"`
@@ -275,7 +281,7 @@ func (c *Client) Accept(chal *Challenge) (*Challenge, error) {
    }{
        Resource: "challenge",
        Type:     chal.Type,
-       Auth:     keyAuth(&c.Key.PublicKey, chal.Token),
+       Auth:     auth,
    }
    res, err := c.PostJWS(chal.URI, req)
    if err != nil {
@@ -322,7 +328,11 @@ func (c *Client) HTTP01Handler(token string) http.Handler {
            return
        }
        w.Header().Set("content-type", "text/plain")
-       w.Write([]byte(keyAuth(&c.Key.PublicKey, token)))
+       auth, err := keyAuth(c.Key.Public(), token)
+       if err != nil {
+           panic(err)
+       }
+       w.Write([]byte(auth))
    })
 }

@@ -494,6 +504,10 @@ func retryAfter(v string) time.Duration {
 }

 // keyAuth generates a key authorization string for a given token.
-func keyAuth(pub *rsa.PublicKey, token string) string {
-   return fmt.Sprintf("%s.%s", token, JWKThumbprint(pub))
+func keyAuth(pub crypto.PublicKey, token string) (string, error) {
+   thumb, err := JWKThumbprint(pub)
+   if err != nil {
+       return "", err
+   }
+   return fmt.Sprintf("%s.%s", token, thumb), nil
 }
diff --git a/cmd/acme/cert.go b/cmd/acme/cert.go
index 15a6d7a..69507e3 100644
--- a/cmd/acme/cert.go
+++ b/cmd/acme/cert.go
@@ -166,7 +166,11 @@ func authz(client *acme.Client, zurl, domain string) error {

    if certManual {
        // manual challenge response
-       tok := fmt.Sprintf("%s.%s", chal.Token, acme.JWKThumbprint(&client.Key.PublicKey))
+       thumb, err := acme.JWKThumbprint(client.Key.Public())
+       if err != nil {
+           return err
+       }
+       tok := fmt.Sprintf("%s.%s", chal.Token, thumb)
        file, err := challengeFile(domain, tok)
        if err != nil {
            return err
diff --git a/errors.go b/errors.go
index 1087bd6..85fc229 100644
--- a/errors.go
+++ b/errors.go
@@ -16,6 +16,7 @@ import (
    "fmt"
    "io/ioutil"
    "net/http"
+   "reflect"
    "time"
 )

@@ -72,3 +73,11 @@ type RetryError time.Duration
 func (re RetryError) Error() string {
    return fmt.Sprintf("retry after %s", re)
 }
+
+type UnsupportedKeyError struct {
+   Type reflect.Type
+}
+
+func (e *UnsupportedKeyError) Error() string {
+   return fmt.Sprintf("acme: unsupported key type: %s", e.Type)
+}
diff --git a/jws.go b/jws.go
index 9aa869a..7540a27 100644
--- a/jws.go
+++ b/jws.go
@@ -13,6 +13,7 @@ package acme

 import (
    "crypto"
+   "crypto/ecdsa"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
@@ -20,13 +21,17 @@ import (
    "encoding/json"
    "fmt"
    "math/big"
+   "reflect"
 )

 // jwsEncodeJSON signs claimset using provided key and a nonce.
 // The result is serialized in JSON format.
 // See https://tools.ietf.org/html/rfc7515#section-7.
-func jwsEncodeJSON(claimset interface{}, key *rsa.PrivateKey, nonce string) ([]byte, error) {
-   jwk := jwkEncode(&key.PublicKey)
+func jwsEncodeJSON(claimset interface{}, key crypto.Signer, nonce string) ([]byte, error) {
+   jwk, err := jwkEncode(key.Public())
+   if err != nil {
+       return nil, err
+   }
    phead := fmt.Sprintf(`{"alg":"RS256","jwk":%s,"nonce":%q}`, jwk, nonce)
    phead = base64.RawURLEncoding.EncodeToString([]byte(phead))
    cs, err := json.Marshal(claimset)
@@ -36,7 +41,7 @@ func jwsEncodeJSON(claimset interface{}, key *rsa.PrivateKey, nonce string) ([]b
    payload := base64.RawURLEncoding.EncodeToString(cs)
    h := sha256.New()
    h.Write([]byte(phead + "." + payload))
-   sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, h.Sum(nil))
+   sig, err := key.Sign(rand.Reader, h.Sum(nil), crypto.SHA256)
    if err != nil {
        return nil, err
    }
@@ -52,24 +57,48 @@ func jwsEncodeJSON(claimset interface{}, key *rsa.PrivateKey, nonce string) ([]b
    return json.Marshal(&enc)
 }

-// jwkEncode encodes public part of an RSA key into a JWK.
+// jwkEncode encodes public part of an RSA or ECDSA key into a JWK.
 // The result is also suitable for creating a JWK thumbprint.
-func jwkEncode(pub *rsa.PublicKey) string {
-   n := pub.N
-   e := big.NewInt(int64(pub.E))
-   // fields order is important
-   // see https://tools.ietf.org/html/rfc7638#section-3.3 for details
-   return fmt.Sprintf(`{"e":"%s","kty":"RSA","n":"%s"}`,
-       base64.RawURLEncoding.EncodeToString(e.Bytes()),
-       base64.RawURLEncoding.EncodeToString(n.Bytes()),
-   )
+func jwkEncode(pub crypto.PublicKey) (string, error) {
+   switch pub := pub.(type) {
+   default:
+       return "", &UnsupportedKeyError{Type: reflect.TypeOf(pub)}
+   case *rsa.PublicKey:
+       n := pub.N
+       e := big.NewInt(int64(pub.E))
+       // fields order is important
+       // see https://tools.ietf.org/html/rfc7638#section-3.3 for details
+       return fmt.Sprintf(`{"e":"%s","kty":"RSA","n":"%s"}`,
+           base64.RawURLEncoding.EncodeToString(e.Bytes()),
+           base64.RawURLEncoding.EncodeToString(n.Bytes()),
+       ), nil
+   case *ecdsa.PublicKey:
+       p := pub.Curve.Params()
+       n := p.BitSize / 8
+       x := pub.X.Bytes()
+       if len(x) > n {
+           x = x[:n]
+       }
+       y := pub.Y.Bytes()
+       if len(y) > n {
+           y = y[:n]
+       }
+       return fmt.Sprintf(`{"crv":"%s","kty":"EC","x":"%s","y":"%s"}`,
+           p.Name,
+           base64.RawURLEncoding.EncodeToString(x),
+           base64.RawURLEncoding.EncodeToString(y),
+       ), nil
+   }
 }

 // JWKThumbprint creates a JWK thumbprint out of pub
 // as specified in https://tools.ietf.org/html/rfc7638.
-func JWKThumbprint(pub *rsa.PublicKey) string {
-   jwk := jwkEncode(pub)
+func JWKThumbprint(pub crypto.PublicKey) (string, error) {
+   jwk, err := jwkEncode(pub)
+   if err != nil {
+       return "", err
+   }
    h := sha256.New()
    h.Write([]byte(jwk))
-   return base64.RawURLEncoding.EncodeToString(h.Sum(nil))
+   return base64.RawURLEncoding.EncodeToString(h.Sum(nil)), nil
 }
diff --git a/jws_test.go b/jws_test.go
index 7aa6264..9d03837 100644
--- a/jws_test.go
+++ b/jws_test.go
@@ -139,7 +139,10 @@ func TestJWKThumbprint(t *testing.T) {
    e := new(big.Int).SetBytes(bytes)

    pub := &rsa.PublicKey{N: n, E: int(e.Uint64())}
-   th := JWKThumbprint(pub)
+   th, err := JWKThumbprint(pub)
+   if err != nil {
+       t.Error(err)
+   }
    if th != expected {
        t.Errorf("th = %q; want %q", th, expected)
    }