golang-jwt/jwt key is of invalid type 錯誤的解決方法

起因:

無意中在github上看到dgrijalva/jwt-go已經(jīng)不在維護(hù)了,而是替換成了golang-jwt/jwt俘枫，所以考慮更新一下新的jwt包健盒，期間各種復(fù)雜，因為只是掃了一眼jwt的源碼褒傅，以為沒什么太大改動，所以以后還是得多看源碼包蛉谜，特此更新一篇筆記

傳送門：新版本go-jwt

直接上源代碼

package jwt

func GetToken(Id string) (string, error) {
    c := MyClaims{
        jwt.StandardClaims{
            Id : Id,
            ExpiresAt: time.Now().Add(TokenExpiration).Unix(),
        },
    }
        
  // 其實問題出在這里 這里會有很多選項 
  // 例如 ParseRSAPrivateKeyFromPEM rsa pkcs8的私鑰解析
  // ParseEdPrivateKeyFromPEM   ed25519 pkcs8的私鑰解析
  // 還有我用的 ParseECPrivateKeyFromPEM ecdsa pkcs8的私鑰解析
  // 這個方法的目的是還原private 對應(yīng)算法的[]byte 數(shù)據(jù)
    priKey, err := jwt.ParseECPrivateKeyFromPEM(privateKey)
    if err != nil {
        return "xxxx", err
    }

    token := jwt.NewWithClaims(jwt.SigningMethodES256, c)
    return token.SignedString(priKey)
}

我們來看一下 token.SignedString(priKey) 的源碼

// Get the complete, signed token 獲取一個已簽名的token
func (t *Token) SignedString(key interface{}) (string, error) {
    var sig, sstr string
    var err error
  // 生成簽名這里不用管
    if sstr, err = t.SigningString(); err != nil {
        return "", err
    }
  // 主要看這里t.Method.Sign 這里是一個接口
    if sig, err = t.Method.Sign(sstr, key); err != nil {
        return "", err
    }
    return strings.Join([]string{sstr, sig}, "."), nil
}

// t.Method.Sign --> 接口
type SigningMethod interface {
    Verify(signingString, signature string, key interface{}) error  // 驗簽
    Sign(signingString string, key interface{}) (string, error)     // 簽名
    Alg() string                                                        // 簽名的hash方式 例如HS256
}

// 那么 SignedString 的這段代碼就是加簽的流程
// 在最上面的代碼塊 GetToken 中  我使用的是 jwt.SigningMethodES256
// 這個是看一個網(wǎng)上的demo 寫的 所以這里也是跟 ParseECPrivateKeyFromPEM 保持一致的 
// 也就是說可以有很多加密方式的選擇 比如 以下相匹配的
// 也就是說jwt/xxx_utils.go ParseXXXPublicKeyFromPEM 
// 對應(yīng) jwt/xxx.go 下的 SigningMethodXXXX SigningMethodXXX
// 例如 rsa 方式加簽 就是 jwt/rsa_utils.go ParseRSAPrivateKeyFromPEMWithPassword / ParseRSAPublicKeyFromPEM 方法 
// 對應(yīng) jwt/rsa.go 下的集中加簽方式
//  SigningMethodRS256 *SigningMethodRSA
//  SigningMethodRS384 *SigningMethodRSA
//  SigningMethodRS512 *SigningMethodRSA
if sig, err = t.Method.Sign(sstr, key); err != nil {
        return "", err
}

以jwt.SigningMethodES256為例

// Implements the Sign method from SigningMethod
// For this signing method, key must be an ecdsa.PrivateKey struct
func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {
    // Get the key
    var ecdsaKey *ecdsa.PrivateKey // SigningMethodES256 需要的是 ecdsa 加簽算法的私鑰
                                                                // 所以 再遇到 key is of invalid type 這個問題 直接考慮加密方式是否不匹配
    switch k := key.(type) {
    case *ecdsa.PrivateKey:
        ecdsaKey = k
    default:
        return "", ErrInvalidKeyType
    }

    // Create the hasher
    if !m.Hash.Available() {
        return "", ErrHashUnavailable
    }

    hasher := m.Hash.New()
    hasher.Write([]byte(signingString))

    // Sign the string and return r, s
    if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {
        curveBits := ecdsaKey.Curve.Params().BitSize

        if m.CurveBits != curveBits {
            return "", ErrInvalidKey
        }

        keyBytes := curveBits / 8
        if curveBits%8 > 0 {
            keyBytes += 1
        }

        // We serialize the outputs (r and s) into big-endian byte arrays
        // padded with zeros on the left to make sure the sizes work out.
        // Output must be 2*keyBytes long.
        out := make([]byte, 2*keyBytes)
        r.FillBytes(out[0:keyBytes]) // r is assigned to the first half of output.
        s.FillBytes(out[keyBytes:])  // s is assigned to the second half of output.

        return EncodeSegment(out), nil
    } else {
        return "", err
    }
}

以下附上生成ecdsa的私鑰生成方法,其他算法同理自行處理吧

package main

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "encoding/base64"
    "fmt"
)

func generateEcdsaPrivateKey() (*ecdsa.PrivateKey, error) {
    return ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
}

func generatePkcs8PrivateKey(privateKey *ecdsa.PrivateKey) ([]byte, error) {
    return x509.MarshalPKCS8PrivateKey(privateKey)
}

func main() {

    key, err := generateEcdsaPrivateKey()
    if err != nil {
        panic(err)
    }

    pkcs8PrivateKey, err := generatePkcs8PrivateKey(key)
    if err != nil {
        panic(err)
    }

    privateKeyString := base64.StdEncoding.EncodeToString(pkcs8PrivateKey)
    base64PriKey := FormatPrivateKeyFromString(privateKeyString)
    fmt.Println(base64PriKey)
}

func  FormatPrivateKeyFromString(privateKey string) string{
    return fmt.Sprintf("-----BEGIN RSA PRIVATE KEY-----\n%s\n-----END RSA PRIVATE KEY-----", privateKey)
}