Merge remote-tracking branch 'mdigger/master'

doc.go

@@ -0,0 +1,8 @@
+// jwt поддерживает работу с токенами в формате JSON Web Token.
+//
+// В данной библиотеке я решил ограничиться только поддержкой основного метода подписи — HS256.
+// Во-первых, потому что он единственный является обязательным. Во-вторых, совершенно не хотелось
+// подключать дополнительные библиотеки без необходимости. В-третьих, с ним получается одна из
+// самых коротких подписей, что, как вы понимаете, в прямую касается длины получаемого токена.
+// В общем, мне показалось этого достаточно.
+package jwt

example_test.go

@@ -0,0 +1,35 @@
+package jwt_test
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/mdigger/jwt"
+)
+
+func Example() {
+	// создаем шаблон и описываем в нем те вещи, которые
+	// мы хотели бы включать во все токены
+	tmpl := &jwt.Template{
+		Issuer:  "me.mdigger.test",
+		Expire:  time.Hour,
+		Created: true,
+		Signer:  jwt.NewSignerHS256([]byte(`top secret`)),
+	}
+	// описываем дополнительные поля токена (можно структурой)
+	data := map[string]interface{}{
+		"user-id": "34529345",
+	}
+	// создаем и подписываем токен
+	token, err := tmpl.Token(data)
+	if err != nil {
+		fmt.Println("Error creating:", err)
+		return
+	}
+	// разбираем токен и получаем данные
+	// если токен не валиден, то вернется ошибка
+	if err := tmpl.Parse(token, &data); err != nil {
+		fmt.Println("Error parsing:", err)
+		return
+	}
+}

hmacSigner.go → signer.go

@@ -2,7 +2,6 @@ package jwt
 
 import (
 	"bytes"
-	"crypto"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -18,7 +17,7 @@ type Signer struct {
 	header string    // сформированный заголовок токена для данного алгоритма
 }
 
-// NewSignerHS256 возвращает инициализированный подписчик токена.
+// NewSignerHS256 возвращает инициализированный подписчик токена, основанный на алгоритме SHA256.
 func NewSignerHS256(key []byte) *Signer {
 	return &Signer{
 		hash:   hmac.New(sha256.New, key),
@@ -27,23 +26,23 @@ func NewSignerHS256(key []byte) *Signer {
 	}
 }
 
-// NewSignerHS384 возвращает инициализированный подписчик токена.
-func NewSignerHS384(key []byte) *Signer {
-	return &Signer{
-		hash:   hmac.New(crypto.SHA384.New, key),
-		name:   "HS384",
-		header: getHeader("HS384"),
-	}
-}
+// // NewSignerHS384 возвращает инициализированный подписчик токена.
+// func NewSignerHS384(key []byte) *Signer {
+// 	return &Signer{
+// 		hash:   hmac.New(sha512.New384, key),
+// 		name:   "HS384",
+// 		header: getHeader("HS384"),
+// 	}
+// }
 
-// NewSignerHS512 возвращает инициализированный подписчик токена.
-func NewSignerHS512(key []byte) *Signer {
-	return &Signer{
-		hash:   hmac.New(crypto.SHA512.New, key),
-		name:   "HS512",
-		header: getHeader("HS512"),
-	}
-}
+// // NewSignerHS512 возвращает инициализированный подписчик токена.
+// func NewSignerHS512(key []byte) *Signer {
+// 	return &Signer{
+// 		hash:   hmac.New(sha512.New, key),
+// 		name:   "HS512",
+// 		header: getHeader("HS512"),
+// 	}
+// }
 
 // Sign возвращает подписанный токен.
 func (s Signer) Sign(token []byte) []byte {

signer_test.go

@@ -0,0 +1,44 @@
+package jwt
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"testing"
+)
+
+func TestSigner(t *testing.T) {
+	signer := NewSignerHS256([]byte(`top secret`))
+	_, err := signer.Parse([]byte(`aaa.bbb`))
+	if err.Error() != "bad token parts" {
+		t.Error("bad token parts")
+	}
+	_, err = signer.Parse([]byte(`aaa.bbb.ccc`))
+	if err == nil {
+		t.Error("bad token encoder")
+	}
+	h, _ := json.Marshal(header{
+		Alg: "HS256",
+		Typ: "JJJ",
+	})
+	hh := base64.RawURLEncoding.EncodeToString(h)
+	_, err = signer.Parse([]byte(hh + `1.bbb.ccc`))
+	if err == nil {
+		t.Error("bad token header")
+	}
+	_, err = signer.Parse([]byte(hh + `.bbb.ccc`))
+	if err.Error() != "bad token type" {
+		t.Error("bad token type")
+	}
+	_, err = signer.Parse([]byte(getHeader("none") + `.bbb.ccc`))
+	if err.Error() != "bad token sign algorithm" {
+		t.Error("bad token sign algorithm")
+	}
+	_, err = signer.Parse([]byte(signer.header + `.bbb.ccc`))
+	if err.Error() != "bad token sign" {
+		t.Error("bad token sign")
+	}
+	_, err = signer.Parse([]byte(signer.header + `.bbb.+++`))
+	if err == nil {
+		t.Error("bad token sign data")
+	}
+}

template.go

@@ -19,7 +19,7 @@ type Template struct {
 	Created   bool          // добавлять дату и время создания
 	NotBefore bool          // добавлять время начала использования
 	UniqueID  func() string // функция для генерации уникального идентификатора
-	*Signer                 // генератор подписи
+	Signer    *Signer       // генератор подписи
 }
 
 // Token возвращает подписанный токен, сгенерированный на основании данных из шаблона и данных

template_test.go

@@ -1,33 +1,26 @@
 package jwt
 
 import (
-	"crypto/rand"
 	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 	"testing"
 	"time"
 )
 
+var key = []byte(`TOPSECRET`)
+
 func TestSign(t *testing.T) {
-	key := make([]byte, 1<<8)
-	if _, err := rand.Read(key); err != nil {
-		t.Error(err)
-	}
 	s := NewSignerHS256(key)
-	for i := 0; i < 10; i++ {
-		s.hash.Reset()
-		s.hash.Write([]byte("test"))
-		sum := s.hash.Sum(nil)
-		fmt.Println(hex.EncodeToString(sum), len(sum))
+	s.hash.Reset()
+	s.hash.Write([]byte("test"))
+	sum := s.hash.Sum(nil)
+	if hex.EncodeToString(sum) != `a3174174280008f8fcf2aa9aef674e26c8d66e2746ada2b8428279c090594fd9` {
+		t.Error("bad sign")
 	}
 }
 
 func TestMap(t *testing.T) {
-	key := make([]byte, 1<<8)
-	if _, err := rand.Read(key); err != nil {
-		t.Error(err)
-	}
 	fmt.Println("key:", base64.RawURLEncoding.EncodeToString(key))
 	var tmpl = &Template{
 		Issuer:   "i am",