pax_global_header00006660000000000000000000000064137353752300014522gustar00rootroot0000000000000052 comment=b09cfaf05951815bc74aa8b14037c645b49b6668 jose2go-1.5/000077500000000000000000000000001373537523000127375ustar00rootroot00000000000000jose2go-1.5/.gitignore000066400000000000000000000004031373537523000147240ustar00rootroot00000000000000# Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe *.test jose2go-1.5/LICENSE000066400000000000000000000020531373537523000137440ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. jose2go-1.5/README.md000066400000000000000000000672561373537523000142360ustar00rootroot00000000000000# Golang (GO) Javascript Object Signing and Encryption (JOSE) and JSON Web Token (JWT) implementation [![GoDoc](https://godoc.org/github.com/dvsekhvalnov/jose2go?status.svg)](http://godoc.org/github.com/dvsekhvalnov/jose2go) Pure Golang (GO) library for generating, decoding and encrypting [JSON Web Tokens](https://tools.ietf.org/html/rfc7519). Zero dependency, relies only on standard library. Supports full suite of signing, encryption and compression algorithms defined by [JSON Web Algorithms](https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-31) as of July 4, 2014 version. Extensively unit tested and cross tested (100+ tests) for compatibility with [jose.4.j](https://bitbucket.org/b_c/jose4j/wiki/Home), [Nimbus-JOSE-JWT](https://bitbucket.org/nimbusds/nimbus-jose-jwt/wiki/Home), [json-jwt](https://github.com/nov/json-jwt) and [jose-jwt](https://github.com/dvsekhvalnov/jose-jwt) libraries. ## Status Used in production. GA ready. Current version is 1.5. ## Important v1.5 bug fix release v1.4 changes default behavior of inserting `typ=JWT` header if not overriden. As of 1.4 no extra headers added by library automatically. To mimic pre 1.4 behaviour use: ```Go token, err := jose.Sign(..., jose.Header("typ", "JWT")) //or token, err := jose.Encrypt(..., jose.Header("typ", "JWT")) ``` v1.3 fixed potential Invalid Curve Attack on NIST curves within ECDH key management. Upgrade strongly recommended. v1.2 breaks `jose.Decode` interface by returning 3 values instead of 2. v1.2 deprecates `jose.Compress` method in favor of using configuration options to `jose.Encrypt`, the method will be removed in next release. ### Migration to v1.2 Pre v1.2 decoding: ```Go payload,err := jose.Decode(token,sharedKey) ``` Should be updated to v1.2: ```Go payload, headers, err := jose.Decode(token,sharedKey) ``` Pre v1.2 compression: ```Go token,err := jose.Compress(payload,jose.DIR,jose.A128GCM,jose.DEF, key) ``` Should be update to v1.2: ```Go token, err := jose.Encrypt(payload, jose.DIR, jose.A128GCM, key, jose.Zip(jose.DEF)) ``` ## Supported JWA algorithms **Signing** - HMAC signatures with HS256, HS384 and HS512. - RSASSA-PKCS1-V1_5 signatures with RS256, RS384 and RS512. - RSASSA-PSS signatures (probabilistic signature scheme with appendix) with PS256, PS384 and PS512. - ECDSA signatures with ES256, ES384 and ES512. - NONE (unprotected) plain text algorithm without integrity protection **Encryption** - RSAES OAEP (using SHA-1 and MGF1 with SHA-1) encryption with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - RSAES OAEP 256 (using SHA-256 and MGF1 with SHA-256) encryption with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - RSAES-PKCS1-V1_5 encryption with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - A128KW, A192KW, A256KW encryption with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - A128GCMKW, A192GCMKW, A256GCMKW encryption with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - ECDH-ES with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - ECDH-ES+A128KW, ECDH-ES+A192KW, ECDH-ES+A256KW with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - PBES2-HS256+A128KW, PBES2-HS384+A192KW, PBES2-HS512+A256KW with A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM, A256GCM - Direct symmetric key encryption with pre-shared key A128CBC-HS256, A192CBC-HS384, A256CBC-HS512, A128GCM, A192GCM and A256GCM **Compression** - DEFLATE compression ## Installation ### Grab package from github `go get github.com/dvsekhvalnov/jose2go` or `go get -u github.com/dvsekhvalnov/jose2go` to update to latest version ### Import package ```Go import ( "github.com/dvsekhvalnov/jose2go" ) ``` ## Usage #### Creating Plaintext (unprotected) Tokens ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` token,err := jose.Sign(payload,jose.NONE, nil) if(err==nil) { //go use token fmt.Printf("\nPlaintext = %v\n",token) } } ``` ### Creating signed tokens #### HS-256, HS-384 and HS-512 Signing with HS256, HS384, HS512 expecting `[]byte` array key of corresponding length: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` key := []byte{97,48,97,50,97,98,100,56,45,54,49,54,50,45,52,49,99,51,45,56,51,100,54,45,49,99,102,53,53,57,98,52,54,97,102,99} token,err := jose.Sign(payload,jose.HS256,key) if(err==nil) { //go use token fmt.Printf("\nHS256 = %v\n",token) } } ``` #### RS-256, RS-384 and RS-512, PS-256, PS-384 and PS-512 Signing with RS256, RS384, RS512, PS256, PS384, PS512 expecting `*rsa.PrivateKey` private key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*rsa.PrivateKey` instance from PEM encoded PKCS1 or PKCS8 data: `Rsa.ReadPrivate([]byte)` under `jose2go/keys/rsa` package. ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` keyBytes,err := ioutil.ReadFile("private.key") if(err!=nil) { panic("invalid key file") } privateKey,e:=Rsa.ReadPrivate(keyBytes) if(e!=nil) { panic("invalid key format") } token,err := jose.Sign(payload,jose.RS256, privateKey) if(err==nil) { //go use token fmt.Printf("\nRS256 = %v\n",token) } } ``` #### ES-256, ES-384 and ES-512 ES256, ES384, ES512 ECDSA signatures expecting `*ecdsa.PrivateKey` private elliptic curve key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*ecdsa.PrivateKey` instance from PEM encoded PKCS1 or PKCS8 data: `ecc.ReadPrivate([]byte)` or directly from `X,Y,D` parameters: `ecc.NewPrivate(x,y,d []byte)` under `jose2go/keys/ecc` package. ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello":"world"}` privateKey:=ecc.NewPrivate([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}, []byte{ 42, 148, 231, 48, 225, 196, 166, 201, 23, 190, 229, 199, 20, 39, 226, 70, 209, 148, 29, 70, 125, 14, 174, 66, 9, 198, 80, 251, 95, 107, 98, 206 }) token,err := jose.Sign(payload, jose.ES256, privateKey) if(err==nil) { //go use token fmt.Printf("\ntoken = %v\n",token) } } ``` ### Creating encrypted tokens #### RSA-OAEP-256, RSA-OAEP and RSA1\_5 key management algorithm RSA-OAEP-256, RSA-OAEP and RSA1_5 key management expecting `*rsa.PublicKey` public key of corresponding length. ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` keyBytes,err := ioutil.ReadFile("public.key") if(err!=nil) { panic("invalid key file") } publicKey,e:=Rsa.ReadPublic(keyBytes) if(e!=nil) { panic("invalid key format") } //OR: //token,err := jose.Encrypt(payload, jose.RSA1_5, jose.A256GCM, publicKey) token,err := jose.Encrypt(payload, jose.RSA_OAEP, jose.A256GCM, publicKey) if(err==nil) { //go use token fmt.Printf("\ntoken = %v\n",token) } } ``` #### AES Key Wrap key management family of algorithms AES128KW, AES192KW and AES256KW key management requires `[]byte` array key of corresponding length ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` sharedKey :=[]byte{194,164,235,6,138,248,171,239,24,216,11,22,137,199,215,133} token,err := jose.Encrypt(payload,jose.A128KW,jose.A128GCM,sharedKey) if(err==nil) { //go use token fmt.Printf("\nA128KW A128GCM = %v\n",token) } } ``` #### AES GCM Key Wrap key management family of algorithms AES128GCMKW, AES192GCMKW and AES256GCMKW key management requires `[]byte` array key of corresponding length ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` sharedKey :=[]byte{194,164,235,6,138,248,171,239,24,216,11,22,137,199,215,133} token,err := jose.Encrypt(payload,jose.A128GCMKW,jose.A128GCM,sharedKey) if(err==nil) { //go use token fmt.Printf("\nA128GCMKW A128GCM = %v\n",token) } } ``` #### ECDH-ES and ECDH-ES with AES Key Wrap key management family of algorithms ECDH-ES and ECDH-ES+A128KW, ECDH-ES+A192KW, ECDH-ES+A256KW key management requires `*ecdsa.PublicKey` elliptic curve key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*ecdsa.PublicKey` instance from PEM encoded PKCS1 X509 certificate or PKIX data: `ecc.ReadPublic([]byte)` or directly from `X,Y` parameters: `ecc.NewPublic(x,y []byte)`under `jose2go/keys/ecc` package: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello":"world"}` publicKey:=ecc.NewPublic([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}) token,err := jose.Encrypt(payload, jose.ECDH_ES, jose.A128CBC_HS256, publicKey) if(err==nil) { //go use token fmt.Printf("\ntoken = %v\n",token) } } ``` #### PBES2 using HMAC SHA with AES Key Wrap key management family of algorithms PBES2-HS256+A128KW, PBES2-HS384+A192KW, PBES2-HS512+A256KW key management requires `string` passphrase from which actual key will be derived ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` passphrase := `top secret` token,err := jose.Encrypt(payload,jose.PBES2_HS256_A128KW,jose.A256GCM,passphrase) if(err==nil) { //go use token fmt.Printf("\nPBES2_HS256_A128KW A256GCM = %v\n",token) } } ``` #### DIR direct pre-shared symmetric key management Direct key management with pre-shared symmetric keys expecting `[]byte` array key of corresponding length: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` sharedKey :=[]byte{194,164,235,6,138,248,171,239,24,216,11,22,137,199,215,133} token,err := jose.Encrypt(payload,jose.DIR,jose.A128GCM,sharedKey) if(err==nil) { //go use token fmt.Printf("\nDIR A128GCM = %v\n",token) } } ``` ### Creating compressed & encrypted tokens #### DEFLATE compression **jose2go** supports optional DEFLATE compression of payload before encrypting, can be used with all supported encryption and key management algorithms: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := `{"hello": "world"}` sharedKey := []byte{194, 164, 235, 6, 138, 248, 171, 239, 24, 216, 11, 22, 137, 199, 215, 133} token, err := jose.Encrypt(payload, jose.DIR, jose.A128GCM, sharedKey, jose.Zip(jose.DEF)) if err == nil { //go use token fmt.Printf("\nDIR A128GCM DEFLATED= %v\n", token) } } ``` ### Verifying, Decoding and Decompressing tokens Decoding json web tokens is fully symmetric to creating signed or encrypted tokens (with respect to public/private cryptography), decompressing deflated payloads is handled automatically: As of v1.2 decode method defined as `jose.Decode() payload string, headers map[string]interface{}, err error` and returns both payload as unprocessed string and headers as map. **HS256, HS384, HS512** signatures, **A128KW, A192KW, A256KW**,**A128GCMKW, A192GCMKW, A256GCMKW** and **DIR** key management algorithm expecting `[]byte` array key: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { token := "eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E" sharedKey :=[]byte{97,48,97,50,97,98,100,56,45,54,49,54,50,45,52,49,99,51,45,56,51,100,54,45,49,99,102,53,53,57,98,52,54,97,102,99} payload, headers, err := jose.Decode(token,sharedKey) if(err==nil) { //go use token fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` **RS256, RS384, RS512**,**PS256, PS384, PS512** signatures expecting `*rsa.PublicKey` public key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*rsa.PublicKey` instance from PEM encoded PKCS1 X509 certificate or PKIX data: `Rsa.ReadPublic([]byte)` under `jose2go/keys/rsa` package: ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { token := "eyJhbGciOiJSUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.NL_dfVpZkhNn4bZpCyMq5TmnXbT4yiyecuB6Kax_lV8Yq2dG8wLfea-T4UKnrjLOwxlbwLwuKzffWcnWv3LVAWfeBxhGTa0c4_0TX_wzLnsgLuU6s9M2GBkAIuSMHY6UTFumJlEeRBeiqZNrlqvmAzQ9ppJHfWWkW4stcgLCLMAZbTqvRSppC1SMxnvPXnZSWn_Fk_q3oGKWw6Nf0-j-aOhK0S0Lcr0PV69ZE4xBYM9PUS1MpMe2zF5J3Tqlc1VBcJ94fjDj1F7y8twmMT3H1PI9RozO-21R0SiXZ_a93fxhE_l_dj5drgOek7jUN9uBDjkXUwJPAyp9YPehrjyLdw" keyBytes, err := ioutil.ReadFile("public.key") if(err!=nil) { panic("invalid key file") } publicKey, e:=Rsa.ReadPublic(keyBytes) if(e!=nil) { panic("invalid key format") } payload, headers, err := jose.Decode(token, publicKey) if(err==nil) { //go use token fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` **RSA-OAEP-256**, **RSA-OAEP** and **RSA1_5** key management algorithms expecting `*rsa.PrivateKey` private key of corresponding length: ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMjU2R0NNIn0.ixD3WVOkvaxeLKi0kyVqTzM6W2EW25SHHYCAr9473Xq528xSK0AVux6kUtv7QMkQKgkMvO8X4VdvonyGkDZTK2jgYUiI06dz7I1sjWJIbyNVrANbBsmBiwikwB-9DLEaKuM85Lwu6gnzbOF6B9R0428ckxmITCPDrzMaXwYZHh46FiSg9djChUTex0pHGhNDiEIgaINpsmqsOFX1L2Y7KM2ZR7wtpR3kidMV3JlxHdKheiPKnDx_eNcdoE-eogPbRGFdkhEE8Dyass1ZSxt4fP27NwsIer5pc0b922_3XWdi1r1TL_fLvGktHLvt6HK6IruXFHpU4x5Z2gTXWxEIog.zzTNmovBowdX2_hi.QSPSgXn0w25ugvzmu2TnhePn.0I3B9BE064HFNP2E0I7M9g" keyBytes, err := ioutil.ReadFile("private.key") if(err!=nil) { panic("invalid key file") } privateKey, e:=Rsa.ReadPrivate(keyBytes) if(e!=nil) { panic("invalid key format") } payload, headers, err := jose.Decode(token, privateKey) if(err==nil) { //go use payload fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` **PBES2-HS256+A128KW, PBES2-HS384+A192KW, PBES2-HS512+A256KW** key management algorithms expects `string` passpharase as a key ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go" ) func main() { token := `eyJhbGciOiJQQkVTMi1IUzI1NitBMTI4S1ciLCJlbmMiOiJBMjU2R0NNIiwicDJjIjo4MTkyLCJwMnMiOiJlZWpFZTF0YmJVbU5XV2s2In0.J2HTgltxH3p7A2zDgQWpZPgA2CHTSnDmMhlZWeSOMoZ0YvhphCeg-w.FzYG5AOptknu7jsG.L8jAxfxZhDNIqb0T96YWoznQ.yNeOfQWUbm8KuDGZ_5lL_g` passphrase := `top secret` payload, headers, err := jose.Decode(token,passphrase) if(err==nil) { //go use token fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` **ES256, ES284, ES512** signatures expecting `*ecdsa.PublicKey` public elliptic curve key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*ecdsa.PublicKey` instance from PEM encoded PKCS1 X509 certificate or PKIX data: `ecc.ReadPublic([]byte)` or directly from `X,Y` parameters: `ecc.NewPublic(x,y []byte)`under `jose2go/keys/ecc` package: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go" ) func main() { token := "eyJhbGciOiJFUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.EVnmDMlz-oi05AQzts-R3aqWvaBlwVZddWkmaaHyMx5Phb2NSLgyI0kccpgjjAyo1S5KCB3LIMPfmxCX_obMKA" publicKey:=ecc.NewPublic([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}) payload, headers, err := jose.Decode(token, publicKey) if(err==nil) { //go use token fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` **ECDH-ES** and **ECDH-ES+A128KW**, **ECDH-ES+A192KW**, **ECDH-ES+A256KW** key management expecting `*ecdsa.PrivateKey` private elliptic curve key of corresponding length. **jose2go** [provides convenient utils](#dealing-with-keys) to construct `*ecdsa.PrivateKey` instance from PEM encoded PKCS1 or PKCS8 data: `ecc.ReadPrivate([]byte)` or directly from `X,Y,D` parameters: `ecc.NewPrivate(x,y,d []byte)` under `jose2go/keys/ecc` package: ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go" ) func main() { token := "eyJhbGciOiJFQ0RILUVTIiwiZW5jIjoiQTEyOENCQy1IUzI1NiIsImVwayI6eyJrdHkiOiJFQyIsIngiOiItVk1LTG5NeW9IVHRGUlpGNnFXNndkRm5BN21KQkdiNzk4V3FVMFV3QVhZIiwieSI6ImhQQWNReTgzVS01Qjl1U21xbnNXcFZzbHVoZGJSZE1nbnZ0cGdmNVhXTjgiLCJjcnYiOiJQLTI1NiJ9fQ..UA3N2j-TbYKKD361AxlXUA.XxFur_nY1GauVp5W_KO2DEHfof5s7kUwvOgghiNNNmnB4Vxj5j8VRS8vMOb51nYy2wqmBb2gBf1IHDcKZdACkCOMqMIcpBvhyqbuKiZPLHiilwSgVV6ubIV88X0vK0C8ZPe5lEyRudbgFjdlTnf8TmsvuAsdtPn9dXwDjUR23bD2ocp8UGAV0lKqKzpAw528vTfD0gwMG8gt_op8yZAxqqLLljMuZdTnjofAfsW2Rq3Z6GyLUlxR51DAUlQKi6UpsKMJoXTrm1Jw8sXBHpsRqA.UHCYOtnqk4SfhAknCnymaQ" privateKey:=ecc.NewPrivate([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}, []byte{ 42, 148, 231, 48, 225, 196, 166, 201, 23, 190, 229, 199, 20, 39, 226, 70, 209, 148, 29, 70, 125, 14, 174, 66, 9, 198, 80, 251, 95, 107, 98, 206 }) payload, headers, err := jose.Decode(token, privateKey) if(err==nil) { //go use token fmt.Printf("\npayload = %v\n",payload) //and/or use headers fmt.Printf("\nheaders = %v\n",headers) } } ``` ### Adding extra headers It's possible to pass additional headers while encoding token. **jose2go** provides convenience configuration helpers: `Header(name string, value interface{})` and `Headers(headers map[string]interface{})` that can be passed to `Sign(..)` and `Encrypt(..)` calls. Note: **jose2go** do not allow to override `alg`, `enc` and `zip` headers. Example of signing with extra headers: ```Go token, err := jose.Sign(payload, jose.ES256, key, jose.Header("keyid", "111-222-333"), jose.Header("trans-id", "aaa-bbb")) ``` Encryption with extra headers: ```Go token, err := jose.Encrypt(payload, jose.DIR, jose.A128GCM, sharedKey, jose.Headers(map[string]interface{}{"keyid": "111-22-33", "cty": "text/plain"})) ``` ### Two phase validation In some cases validation (decoding) key can be unknown prior to examining token content. For instance one can use different keys per token issuer or rely on headers information to determine which key to use, do logging or other things. **jose2go** allows to pass `func(headers map[string]interface{}, payload string) key interface{}` callback instead of key to `jose.Decode(..)`. Callback will be executed prior to decoding and integrity validation and will recieve parsed headers and payload as is (for encrypted tokens it will be cipher text). Callback should return key to be used for actual decoding process or `error` if decoding should be stopped, given error object will be returned from `jose.Decode(..)` call. Example of decoding token with callback: ```Go package main import ( "crypto/rsa" "fmt" "github.com/dvsekhvalnov/jose2go" "github.com/dvsekhvalnov/jose2go/keys/rsa" "io/ioutil" "errors" ) func main() { token := "eyJhbGciOiJSUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.NL_dfVpZkhNn4bZpCyMq5TmnXbT4yiyecuB6Kax_lV8Yq2dG8wLfea-T4UKnrjLOwxlbwLwuKzffWcnWv3LVAWfeBxhGTa0c4_0TX_wzLnsgLuU6s9M2GBkAIuSMHY6UTFumJlEeRBeiqZNrlqvmAzQ9ppJHfWWkW4stcgLCLMAZbTqvRSppC1SMxnvPXnZSWn_Fk_q3oGKWw6Nf0-j-aOhK0S0Lcr0PV69ZE4xBYM9PUS1MpMe2zF5J3Tqlc1VBcJ94fjDj1F7y8twmMT3H1PI9RozO-21R0SiXZ_a93fxhE_l_dj5drgOek7jUN9uBDjkXUwJPAyp9YPehrjyLdw" payload, _, err := jose.Decode(token, func(headers map[string]interface{}, payload string) interface{} { //log something fmt.Printf("\nHeaders before decoding: %v\n", headers) fmt.Printf("\nPayload before decoding: %v\n", payload) //lookup key based on keyid header as en example //or lookup based on something from payload, e.g. 'iss' claim for instance key := FindKey(headers['keyid']) if(key==nil) { return errors.New("Key not found") } return key; }) if err == nil { //go use token fmt.Printf("\ndecoded payload = %v\n", payload) } } ``` ### Working with binary payload In addition to work with string payloads (typical use-case) `jose2go` supports encoding and decoding of raw binary data. `jose.DecodeBytes`, `jose.SignBytes` and `jose.EncryptBytes` functions provides similar interface but accepting `[]byte` payloads. Examples: ```Go package main import ( "github.com/dvsekhvalnov/jose2go" ) func main() { token := `eyJhbGciOiJQQkVTMi1IUzI1NitBMTI4S1ciLCJlbmMiOiJBMjU2R0NNIiwicDJjIjo4MTkyLCJwMnMiOiJlZWpFZTF0YmJVbU5XV2s2In0.J2HTgltxH3p7A2zDgQWpZPgA2CHTSnDmMhlZWeSOMoZ0YvhphCeg-w.FzYG5AOptknu7jsG.L8jAxfxZhDNIqb0T96YWoznQ.yNeOfQWUbm8KuDGZ_5lL_g` passphrase := `top secret` payload, headers, err := jose.DecodeBytes(token,passphrase) if(err==nil) { //go use token //payload = []byte{....} } } ``` ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := []byte {0x01, 0x02, 0x03, 0x04} keyBytes,err := ioutil.ReadFile("private.key") if(err!=nil) { panic("invalid key file") } privateKey,e:=Rsa.ReadPrivate(keyBytes) if(e!=nil) { panic("invalid key format") } token,err := jose.SignBytes(payload,jose.RS256, privateKey) if(err==nil) { //go use token fmt.Printf("\nRS256 = %v\n",token) } } ``` ```Go package main import ( "fmt" "io/ioutil" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "github.com/dvsekhvalnov/jose2go" ) func main() { payload := []byte {0x01, 0x02, 0x03, 0x04} keyBytes,err := ioutil.ReadFile("public.key") if(err!=nil) { panic("invalid key file") } publicKey,e:=Rsa.ReadPublic(keyBytes) if(e!=nil) { panic("invalid key format") } token,err := jose.EncryptBytes(payload, jose.RSA_OAEP, jose.A256GCM, publicKey) if(err==nil) { //go use token fmt.Printf("\ntoken = %v\n",token) } } ``` ### Dealing with keys **jose2go** provides several helper methods to simplify loading & importing of elliptic and rsa keys. Import `jose2go/keys/rsa` or `jose2go/keys/ecc` respectively: #### RSA keys 1. `Rsa.ReadPrivate(raw []byte) (key *rsa.PrivateKey,err error)` attempts to parse RSA private key from PKCS1 or PKCS8 format (`BEGIN RSA PRIVATE KEY` and `BEGIN PRIVATE KEY` headers) ```Go package main import ( "fmt" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "io/ioutil" ) func main() { keyBytes, _ := ioutil.ReadFile("private.key") privateKey, err:=Rsa.ReadPrivate(keyBytes) if(err!=nil) { panic("invalid key format") } fmt.Printf("privateKey = %v\n",privateKey) } ``` 2. `Rsa.ReadPublic(raw []byte) (key *rsa.PublicKey,err error)` attempts to parse RSA public key from PKIX key format or PKCS1 X509 certificate (`BEGIN PUBLIC KEY` and `BEGIN CERTIFICATE` headers) ```Go package main import ( "fmt" Rsa "github.com/dvsekhvalnov/jose2go/keys/rsa" "io/ioutil" ) func main() { keyBytes, _ := ioutil.ReadFile("public.cer") publicKey, err:=Rsa.ReadPublic(keyBytes) if(err!=nil) { panic("invalid key format") } fmt.Printf("publicKey = %v\n",publicKey) } ``` #### ECC keys 1. `ecc.ReadPrivate(raw []byte) (key *ecdsa.PrivateKey,err error)` attemps to parse elliptic curve private key from PKCS1 or PKCS8 format (`BEGIN EC PRIVATE KEY` and `BEGIN PRIVATE KEY` headers) ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "io/ioutil" ) func main() { keyBytes, _ := ioutil.ReadFile("ec-private.pem") ecPrivKey, err:=ecc.ReadPrivate(keyBytes) if(err!=nil) { panic("invalid key format") } fmt.Printf("ecPrivKey = %v\n",ecPrivKey) } ``` 2. `ecc.ReadPublic(raw []byte) (key *ecdsa.PublicKey,err error)` attemps to parse elliptic curve public key from PKCS1 X509 or PKIX format (`BEGIN PUBLIC KEY` and `BEGIN CERTIFICATE` headers) ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" "io/ioutil" ) func main() { keyBytes, _ := ioutil.ReadFile("ec-public.key") ecPubKey, err:=ecc.ReadPublic(keyBytes) if(err!=nil) { panic("invalid key format") } fmt.Printf("ecPubKey = %v\n",ecPubKey) } ``` 3. `ecc.NewPublic(x,y []byte) (*ecdsa.PublicKey)` constructs elliptic public key from (X,Y) represented as bytes. Supported are NIST curves P-256,P-384 and P-521. Curve detected automatically by input length. ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" ) func main() { ecPubKey:=ecc.NewPublic([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}) fmt.Printf("ecPubKey = %v\n",ecPubKey) } ``` 4. `ecc.NewPrivate(x,y,d []byte) (*ecdsa.PrivateKey)` constructs elliptic private key from (X,Y) and D represented as bytes. Supported are NIST curves P-256,P-384 and P-521. Curve detected automatically by input length. ```Go package main import ( "fmt" "github.com/dvsekhvalnov/jose2go/keys/ecc" ) func main() { ecPrivKey:=ecc.NewPrivate([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}, []byte{ 42, 148, 231, 48, 225, 196, 166, 201, 23, 190, 229, 199, 20, 39, 226, 70, 209, 148, 29, 70, 125, 14, 174, 66, 9, 198, 80, 251, 95, 107, 98, 206 }) fmt.Printf("ecPrivKey = %v\n",ecPrivKey) } ``` ### More examples Checkout `jose_test.go` for more examples. ## Changelog ### 1.2 - interface to access token headers after decoding - interface to provide extra headers for token encoding - two-phase validation support ### 1.1 - security and bug fixes ### 1.0 - initial stable version with full suite JOSE spec support jose2go-1.5/aes/000077500000000000000000000000001373537523000135075ustar00rootroot00000000000000jose2go-1.5/aes/ecb.go000066400000000000000000000025171373537523000145740ustar00rootroot00000000000000// Package aes contains provides AES Key Wrap and ECB mode implementations package aes import ( "crypto/cipher" ) type ecb struct { b cipher.Block } type ecbEncrypter ecb type ecbDecrypter ecb // NewECBEncrypter creates BlockMode for AES encryption in ECB mode func NewECBEncrypter(b cipher.Block) cipher.BlockMode { return &ecbEncrypter{b: b} } // NewECBDecrypter creates BlockMode for AES decryption in ECB mode func NewECBDecrypter(b cipher.Block) cipher.BlockMode { return &ecbDecrypter{b: b} } func (x *ecbEncrypter) BlockSize() int { return x.b.BlockSize() } func (x *ecbDecrypter) BlockSize() int { return x.b.BlockSize() } func (x *ecbDecrypter) CryptBlocks(dst, src []byte) { bs := x.BlockSize() if len(src)%bs != 0 { panic("ecbDecrypter.CryptBlocks(): input not full blocks") } if len(dst) < len(src) { panic("ecbDecrypter.CryptBlocks(): output smaller than input") } if len(src) == 0 { return } for len(src) > 0 { x.b.Decrypt(dst, src) src = src[bs:] } } func (x *ecbEncrypter) CryptBlocks(dst, src []byte) { bs := x.BlockSize() if len(src)%bs != 0 { panic("ecbEncrypter.CryptBlocks(): input not full blocks") } if len(dst) < len(src) { panic("ecbEncrypter.CryptBlocks(): output smaller than input") } if len(src) == 0 { return } for len(src) > 0 { x.b.Encrypt(dst, src) src = src[bs:] } } jose2go-1.5/aes/ecb_test.go000066400000000000000000000017401373537523000156300ustar00rootroot00000000000000package aes import ( // "fmt" "crypto/aes" // "crypto/cipher" . "gopkg.in/check.v1" ) func (s *TestSuite) TestNewECBEncryptor(c *C) { //given plaintext := []byte{0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255} kek := []byte{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15} block, _ := aes.NewCipher(kek) test := make([]byte,len(plaintext)) //when NewECBEncrypter(block).CryptBlocks(test,plaintext) //then c.Assert(test, DeepEquals, []byte{105,196,224,216,106,123,4,48,216,205,183,128,112,180,197,90}) } func (s *TestSuite) TestNewECBDecryptor(c *C) { //given ciphertext := []byte{105,196,224,216,106,123,4,48,216,205,183,128,112,180,197,90} kek := []byte{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15} block, _ := aes.NewCipher(kek) test := make([]byte,len(ciphertext)) //when NewECBDecrypter(block).CryptBlocks(test,ciphertext) //then c.Assert(test, DeepEquals, []byte{0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255}) }jose2go-1.5/aes/key_wrap.go000066400000000000000000000063141373537523000156630ustar00rootroot00000000000000package aes import ( "github.com/dvsekhvalnov/jose2go/arrays" "crypto/cipher" "crypto/aes" "crypto/hmac" "errors" ) var defaultIV=[]byte { 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6 } // KeyWrap encrypts provided key (CEK) with KEK key using AES Key Wrap (rfc 3394) algorithm func KeyWrap(cek,kek []byte) ([]byte,error) { // 1) Initialize variables a := defaultIV // Set A = IV, an initial value r := arrays.Slice(cek, 8) // For i = 1 to n // R[0][i] = P[i] n := uint64(len(r)) // 2) Calculate intermediate values. var j,i,t uint64 for j = 0; j < 6; j++ { // For j = 0 to 5 for i = 0; i < n; i++ { // For i=1 to n t = n * j + i + 1; b,e := aesEnc(kek, arrays.Concat(a, r[i])) // B=AES(K, A | R[i]) if e!=nil { return nil, e } a = b[:len(b)/2] // A=MSB(64,B) ^ t where t = (n*j)+i r[i] = b[len(b)/2:] // R[i] = LSB(64, B) a = arrays.Xor(a, arrays.UInt64ToBytes(t)) } } // 3) Output the results c := make([][]byte, n+1, n+1) c[0] = a; // Set C[0] = A for i = 1; i <= n; i++ { // For i = 1 to n c[i] = r[i - 1] // C[i] = R[i] } return arrays.Unwrap(c),nil } // KeyUnwrap decrypts previously encrypted key (CEK) with KEK key using AES Key Wrap (rfc 3394) algorithm func KeyUnwrap(encryptedCek, kek []byte) ([]byte,error) { // 1) Initialize variables c := arrays.Slice(encryptedCek, 8); a := c[0]; // Set A = C[0] r := make([][]byte,len(c) - 1); for i := 1; i < len(c); i++ { // For i = 1 to n r[i - 1] = c[i]; // R[i] = C[i] } n := uint64(len(r)) // 2) Calculate intermediate values var t,j uint64 for j = 6; j > 0; j-- { // For j = 5 to 0 for i := n; i > 0; i-- { // For i = n to 1 t = n * (j-1) + i; a = arrays.Xor(a, arrays.UInt64ToBytes(t)) b,e := aesDec(kek, arrays.Concat(a, r[i-1])) // B = AES-1(K, (A ^ t) | R[i]) where t = n*j+i if e!=nil { return nil,e } a = b[:len(b)/2] // A = MSB(64, B) r[i-1] = b[len(b)/2:] // R[i] = LSB(64, B) } } // 3) Output the results if (!hmac.Equal(defaultIV, a)) { // If A is an appropriate initial value return nil, errors.New("aes.KeyUnwrap(): integrity check failed.") } // For i = 1 to n return arrays.Unwrap(r),nil // P[i] = R[i] } func aesEnc(kek, plainText []byte) (cipherText []byte, err error) { var block cipher.Block if block, err = aes.NewCipher(kek);err!=nil { return nil,err } cipherText = make([]byte, len(plainText)) NewECBEncrypter(block).CryptBlocks(cipherText,plainText) return cipherText,nil } func aesDec(kek, cipherText []byte) (plainText []byte,err error) { var block cipher.Block if block, err = aes.NewCipher(kek);err!=nil { return nil,err } plainText = make([]byte, len(cipherText)) NewECBDecrypter(block).CryptBlocks(plainText,cipherText) return plainText,nil }jose2go-1.5/aes/key_wrap_test.go000066400000000000000000000215401373537523000167200ustar00rootroot00000000000000package aes import ( "testing" // "fmt" . "gopkg.in/check.v1" // "github.com/dvsekhvalnov/jose2go/arrays" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestWrap_128Key_128Kek(c *C) { //given (Section 4.1) //000102030405060708090A0B0C0D0E0F kek := []byte{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15} //00112233445566778899AABBCCDDEEFF key := []byte{0,17,34,51,68,85,102,119,136,153,170,187,204,221,238,255} //1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5 expected := []byte{ 31, 166, 139, 10, 129, 18, 180, 71, 174, 243, 75, 216, 251, 90, 123, 130, 157, 62, 134,35, 113, 210, 207, 229} //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap128Key_128Kek(c *C) { //given (Section 4.1) //000102030405060708090A0B0C0D0E0F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } //00112233445566778899AABBCCDDEEFF expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 } //1FA68B0A8112B447AEF34BD8FB5A7B829D3E862371D2CFE5 key := []byte{ 31, 166, 139, 10, 129, 18, 180, 71, 174, 243, 75, 216, 251, 90, 123, 130, 157, 62, 134, 35, 113, 210, 207, 229 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Wrap_128Key_192Kek(c *C) { //given (Section 4.2) //000102030405060708090A0B0C0D0E0F1011121314151617 kek := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23} //00112233445566778899AABBCCDDEEFF key := []byte{0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255} //96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D expected := []byte{150, 119, 139, 37, 174, 108, 164, 53, 249, 43, 91, 151, 192, 80, 174, 210, 70, 138, 184, 161, 122, 216, 78, 93} //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap128Key_192Kek(c *C) { //given (Section 4.2) //000102030405060708090A0B0C0D0E0F1011121314151617 kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 } //00112233445566778899AABBCCDDEEFF expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 } //96778B25AE6CA435F92B5B97C050AED2468AB8A17AD84E5D key := []byte{ 150, 119, 139, 37, 174, 108, 164, 53, 249, 43, 91, 151, 192, 80, 174, 210, 70, 138, 184, 161, 122, 216, 78, 93 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Wrap_128Key_256Kek(c *C) { //given (Section 4.3) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31} //00112233445566778899AABBCCDDEEFF key := []byte{0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255} //64E8C3F9CE0F5BA263E9777905818A2A93C8191E7D6E8AE7 expected := []byte{100, 232, 195, 249, 206, 15, 91, 162, 99, 233, 119, 121, 5, 129, 138, 42, 147, 200, 25, 30, 125, 110, 138, 231} //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap128Key_256Kek(c *C) { //given (Section 4.3) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 } //00112233445566778899AABBCCDDEEFF expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255 } //64E8C3F9CE0F5BA263E9777905818A2A93C8191E7D6E8AE7 key := []byte{ 100, 232, 195, 249, 206, 15, 91, 162, 99, 233, 119, 121, 5, 129, 138, 42, 147, 200, 25, 30, 125, 110, 138, 231 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Wrap_192Key_192Kek(c *C) { //given (Section 4.4) //000102030405060708090A0B0C0D0E0F1011121314151617 kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 } //00112233445566778899AABBCCDDEEFF0001020304050607 key := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7 } //031D33264E15D33268F24EC260743EDCE1C6C7DDEE725A936BA814915C6762D2 expected := []byte{ 3, 29, 51, 38, 78, 21, 211, 50, 104, 242, 78, 194, 96, 116, 62, 220, 225, 198, 199, 221, 238, 114, 90, 147, 107, 168, 20, 145, 92, 103, 98, 210 } //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap192Key_192Kek(c *C) { //given (Section 4.4) //000102030405060708090A0B0C0D0E0F1011121314151617 kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 } //00112233445566778899AABBCCDDEEFF0001020304050607 expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7 } //031D33264E15D33268F24EC260743EDCE1C6C7DDEE725A936BA814915C6762D2 key := []byte{ 3, 29, 51, 38, 78, 21, 211, 50, 104, 242, 78, 194, 96, 116, 62, 220, 225, 198, 199, 221, 238, 114, 90, 147, 107, 168, 20, 145, 92, 103, 98, 210 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Wrap_192Key_256Kek(c *C) { //given (Section 4.5) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 } //00112233445566778899AABBCCDDEEFF0001020304050607 key := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7 } //A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1 expected := []byte{ 168, 249, 188, 22, 18, 198, 139, 63, 246, 230, 244, 251, 227, 14, 113, 228, 118, 156, 139, 128, 163, 44, 184, 149, 140, 213, 209, 125, 107, 37, 77, 161 } //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap192Key_256Kek(c *C) { //given (Section 4.5) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 } //00112233445566778899AABBCCDDEEFF0001020304050607 expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7 } //A8F9BC1612C68B3FF6E6F4FBE30E71E4769C8B80A32CB8958CD5D17D6B254DA1 key := []byte{ 168, 249, 188, 22, 18, 198, 139, 63, 246, 230, 244, 251, 227, 14, 113, 228, 118, 156, 139, 128, 163, 44, 184, 149, 140, 213, 209, 125, 107, 37, 77, 161 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Wrap_256Key_256Kek(c *C) { //given (Section 4.6) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 } //00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F key := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } //28C9F404C4B810F4CBCCB35CFB87F8263F5786E2D80ED326CBC7F0E71A99F43BFB988B9B7A02DD21 expected := []byte{ 40, 201, 244, 4, 196, 184, 16, 244, 203, 204, 179, 92, 251, 135, 248, 38, 63, 87, 134, 226, 216, 14, 211, 38, 203, 199, 240, 231, 26, 153, 244, 59, 251, 152, 139, 155, 122, 2, 221, 33 } //when test,_ := KeyWrap(key, kek); //then c.Assert(test, DeepEquals, expected) } func (s *TestSuite) Test_Unwrap256Key_256Kek(c *C) { //given (Section 4.6) //000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F kek := []byte{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 } //00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F expected := []byte{ 0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } //28C9F404C4B810F4CBCCB35CFB87F8263F5786E2D80ED326CBC7F0E71A99F43BFB988B9B7A02DD21 key := []byte{ 40, 201, 244, 4, 196, 184, 16, 244, 203, 204, 179, 92, 251, 135, 248, 38, 63, 87, 134, 226, 216, 14, 211, 38, 203, 199, 240, 231, 26, 153, 244, 59, 251, 152, 139, 155, 122, 2, 221, 33 } //when test,_ := KeyUnwrap(key, kek) //then c.Assert(test, DeepEquals, expected) }jose2go-1.5/aes_cbc_hmac.go000066400000000000000000000054241373537523000156420ustar00rootroot00000000000000package jose import ( "crypto/aes" "crypto/cipher" "crypto/hmac" "errors" "fmt" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/padding" ) // AES CBC with HMAC authenticated encryption algorithm implementation type AesCbcHmac struct { keySizeBits int } func init() { RegisterJwe(&AesCbcHmac{keySizeBits: 256}) RegisterJwe(&AesCbcHmac{keySizeBits: 384}) RegisterJwe(&AesCbcHmac{keySizeBits: 512}) } func (alg *AesCbcHmac) Name() string { switch alg.keySizeBits { case 256: return A128CBC_HS256 case 384: return A192CBC_HS384 default: return A256CBC_HS512 } } func (alg *AesCbcHmac) KeySizeBits() int { return alg.keySizeBits } func (alg *AesCbcHmac) SetKeySizeBits(bits int) { alg.keySizeBits = bits } func (alg *AesCbcHmac) Encrypt(aad, plainText, cek []byte) (iv, cipherText, authTag []byte, err error) { cekSizeBits := len(cek) << 3 if cekSizeBits != alg.keySizeBits { return nil, nil, nil, errors.New(fmt.Sprintf("AesCbcHmac.Encrypt(): expected key of size %v bits, but was given %v bits.", alg.keySizeBits, cekSizeBits)) } hmacKey := cek[0 : len(cek)/2] aesKey := cek[len(cek)/2:] if iv, err = arrays.Random(16); err != nil { return nil, nil, nil, err } var block cipher.Block if block, err = aes.NewCipher(aesKey); err != nil { return nil, nil, nil, err } padded := padding.AddPkcs7(plainText, 16) cipherText = make([]byte, len(padded), cap(padded)) mode := cipher.NewCBCEncrypter(block, iv) mode.CryptBlocks(cipherText, padded) authTag = alg.computeAuthTag(aad, iv, cipherText, hmacKey) return iv, cipherText, authTag, nil } func (alg *AesCbcHmac) Decrypt(aad, cek, iv, cipherText, authTag []byte) (plainText []byte, err error) { cekSizeBits := len(cek) << 3 if cekSizeBits != alg.keySizeBits { return nil, errors.New(fmt.Sprintf("AesCbcHmac.Decrypt(): expected key of size %v bits, but was given %v bits.", alg.keySizeBits, cekSizeBits)) } hmacKey := cek[0 : len(cek)/2] aesKey := cek[len(cek)/2:] // Check MAC expectedAuthTag := alg.computeAuthTag(aad, iv, cipherText, hmacKey) if !hmac.Equal(expectedAuthTag, authTag) { return nil, errors.New("AesCbcHmac.Decrypt(): Authentication tag do not match.") } var block cipher.Block if block, err = aes.NewCipher(aesKey); err == nil { mode := cipher.NewCBCDecrypter(block, iv) var padded []byte = make([]byte, len(cipherText), cap(cipherText)) mode.CryptBlocks(padded, cipherText) return padding.RemovePkcs7(padded, 16), nil } return nil, err } func (alg *AesCbcHmac) computeAuthTag(aad []byte, iv []byte, cipherText []byte, hmacKey []byte) (signature []byte) { al := arrays.UInt64ToBytes(uint64(len(aad) << 3)) hmacInput := arrays.Concat(aad, iv, cipherText, al) hmac := calculateHmac(alg.keySizeBits, hmacInput, hmacKey) return hmac[0 : len(hmac)/2] } jose2go-1.5/aes_gcm.go000066400000000000000000000043641373537523000146730ustar00rootroot00000000000000package jose import ( "fmt" "errors" "crypto/aes" "crypto/cipher" "github.com/dvsekhvalnov/jose2go/arrays" ) // AES GCM authenticated encryption algorithm implementation type AesGcm struct{ keySizeBits int } func init() { RegisterJwe(&AesGcm{keySizeBits:128}) RegisterJwe(&AesGcm{keySizeBits:192}) RegisterJwe(&AesGcm{keySizeBits:256}) } func (alg *AesGcm) Name() string { switch alg.keySizeBits { case 128: return A128GCM case 192: return A192GCM default: return A256GCM } } func (alg *AesGcm) KeySizeBits() int { return alg.keySizeBits } func (alg *AesGcm) Encrypt(aad, plainText, cek []byte) (iv, cipherText, authTag []byte, err error) { cekSizeBits := len(cek)<<3 if cekSizeBits != alg.keySizeBits { return nil,nil,nil, errors.New(fmt.Sprintf("AesGcm.Encrypt(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits, cekSizeBits)) } if iv,err = arrays.Random(12);err!=nil { return nil,nil,nil,err } var block cipher.Block if block, err = aes.NewCipher(cek);err!=nil { return nil,nil,nil,err } var aesgcm cipher.AEAD if aesgcm,err = cipher.NewGCM(block);err!=nil { return nil,nil,nil,err } cipherWithTag := aesgcm.Seal(nil, iv, plainText, aad) cipherText=cipherWithTag[:len(cipherWithTag)-aesgcm.Overhead()] authTag=cipherWithTag[len(cipherWithTag)-aesgcm.Overhead():] return iv, cipherText, authTag, nil } func (alg *AesGcm) Decrypt(aad, cek, iv, cipherText, authTag []byte) (plainText []byte, err error) { cekSizeBits := len(cek)<<3 if cekSizeBits != alg.keySizeBits { return nil, errors.New(fmt.Sprintf("AesGcm.Decrypt(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits, cekSizeBits)) } var block cipher.Block if block, err = aes.NewCipher(cek);err!=nil { return nil,err } var aesgcm cipher.AEAD if aesgcm,err = cipher.NewGCM(block);err!=nil { return nil,err } cipherWithTag:=append(cipherText,authTag...) if nonceSize := len(iv); nonceSize != aesgcm.NonceSize() { return nil, errors.New(fmt.Sprintf("AesGcm.Decrypt(): expected nonce of size %v bits, but was given %v bits.", aesgcm.NonceSize()<<3, nonceSize<<3)) } if plainText,err = aesgcm.Open(nil, iv, cipherWithTag, aad);err!=nil { return nil,err } return plainText,nil } jose2go-1.5/aes_gcm_kw.go000066400000000000000000000061301373537523000153650ustar00rootroot00000000000000package jose import ( "errors" "fmt" "github.com/dvsekhvalnov/jose2go/base64url" "github.com/dvsekhvalnov/jose2go/arrays" "crypto/aes" "crypto/cipher" ) func init() { RegisterJwa(&AesGcmKW{ keySizeBits: 128}) RegisterJwa(&AesGcmKW{ keySizeBits: 192}) RegisterJwa(&AesGcmKW{ keySizeBits: 256}) } // AES GCM Key Wrap key management algorithm implementation type AesGcmKW struct { keySizeBits int } func (alg *AesGcmKW) Name() string { switch alg.keySizeBits { case 128: return A128GCMKW case 192: return A192GCMKW default: return A256GCMKW } } func (alg *AesGcmKW) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if kek,ok:=key.([]byte); ok { kekSizeBits := len(kek) << 3 if kekSizeBits != alg.keySizeBits { return nil,nil, errors.New(fmt.Sprintf("AesGcmKW.WrapNewKey(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits, kekSizeBits)) } if cek,err = arrays.Random(cekSizeBits>>3);err!=nil { return nil,nil,err } var iv []byte if iv,err = arrays.Random(12);err!=nil { return nil,nil,err } var block cipher.Block if block, err = aes.NewCipher(kek);err!=nil { return nil,nil,err } var aesgcm cipher.AEAD if aesgcm,err = cipher.NewGCM(block);err!=nil { return nil,nil,err } cipherWithTag := aesgcm.Seal(nil, iv, cek, nil) cipherText := cipherWithTag[:len(cipherWithTag)-aesgcm.Overhead()] authTag := cipherWithTag[len(cipherWithTag)-aesgcm.Overhead():] header["iv"]=base64url.Encode(iv) header["tag"]=base64url.Encode(authTag) return cek,cipherText,nil } return nil,nil,errors.New("AesGcmKW.WrapNewKey(): expected key to be '[]byte' array") } func (alg *AesGcmKW) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if kek,ok:=key.([]byte); ok { kekSizeBits := len(kek) << 3 if kekSizeBits != alg.keySizeBits { return nil,errors.New(fmt.Sprintf("AesGcmKW.Unwrap(): expected key of size %v bits, but was given %v bits.", alg.keySizeBits, kekSizeBits)) } var iv,tag string if iv,ok = header["iv"].(string);!ok { return nil,errors.New("AesGcmKW.Unwrap(): expected 'iv' param in JWT header, but was not found.") } if tag,ok = header["tag"].(string);!ok { return nil,errors.New("AesGcmKW.Unwrap(): expected 'tag' param in JWT header, but was not found.") } var ivBytes,tagBytes []byte if ivBytes,err = base64url.Decode(iv);err!=nil { return nil,err } if tagBytes,err = base64url.Decode(tag);err!=nil { return nil,err } var block cipher.Block if block, err = aes.NewCipher(kek);err!=nil { return nil,err } var aesgcm cipher.AEAD if aesgcm,err = cipher.NewGCM(block);err!=nil { return nil,err } cipherAndTag:=append(encryptedCek,tagBytes...) if cek,err = aesgcm.Open(nil, ivBytes,cipherAndTag , nil);err!=nil { fmt.Printf("err = %v\n",err) return nil,err } return cek,nil } return nil,errors.New("AesGcmKW.Unwrap(): expected key to be '[]byte' array") } jose2go-1.5/aeskw.go000066400000000000000000000031731373537523000144040ustar00rootroot00000000000000package jose import ( "errors" "fmt" "github.com/dvsekhvalnov/jose2go/aes" "github.com/dvsekhvalnov/jose2go/arrays" ) func init() { RegisterJwa(&AesKW{ keySizeBits: 128}) RegisterJwa(&AesKW{ keySizeBits: 192}) RegisterJwa(&AesKW{ keySizeBits: 256}) } // AES Key Wrap key management algorithm implementation type AesKW struct { keySizeBits int } func (alg *AesKW) Name() string { switch alg.keySizeBits { case 128: return A128KW case 192: return A192KW default: return A256KW } } func (alg *AesKW) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if kek,ok:=key.([]byte); ok { kekSizeBits := len(kek) << 3 if kekSizeBits != alg.keySizeBits { return nil,nil, errors.New(fmt.Sprintf("AesKW.WrapNewKey(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits, kekSizeBits)) } if cek,err = arrays.Random(cekSizeBits>>3);err==nil { encryptedCek,err=aes.KeyWrap(cek,kek) return } return nil,nil,err } return nil,nil,errors.New("AesKW.WrapNewKey(): expected key to be '[]byte' array") } func (alg *AesKW) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if kek,ok:=key.([]byte); ok { kekSizeBits := len(kek) << 3 if kekSizeBits != alg.keySizeBits { return nil,errors.New(fmt.Sprintf("AesKW.Unwrap(): expected key of size %v bits, but was given %v bits.", alg.keySizeBits, kekSizeBits)) } return aes.KeyUnwrap(encryptedCek, kek) } return nil,errors.New("AesKW.Unwrap(): expected key to be '[]byte' array") } jose2go-1.5/arrays/000077500000000000000000000000001373537523000142405ustar00rootroot00000000000000jose2go-1.5/arrays/arrays.go000066400000000000000000000047121373537523000160740ustar00rootroot00000000000000// Package arrays provides various byte array utilities package arrays import ( "bytes" "crypto/rand" "encoding/binary" "fmt" "github.com/dvsekhvalnov/jose2go/base64url" ) // Xor is doing byte by byte exclusive or of 2 byte arrays func Xor(left, right []byte) []byte { result := make([]byte, len(left)) for i := 0; i < len(left); i++ { result[i] = left[i] ^ right[i] } return result } // Slice is splitting input byte array into slice of subarrays. Each of count length. func Slice(arr []byte, count int) [][]byte { sliceCount := len(arr) / count result := make([][]byte, sliceCount) for i := 0; i < sliceCount; i++ { start := i * count end := i*count + count result[i] = arr[start:end] } return result } // Random generates byte array with random data of byteCount length func Random(byteCount int) ([]byte, error) { data := make([]byte, byteCount) if _, err := rand.Read(data); err != nil { return nil, err } return data, nil } // Concat combine several arrays into single one, resulting slice = A1 | A2 | A3 | ... | An func Concat(arrays ...[]byte) []byte { var result []byte = arrays[0] for _, arr := range arrays[1:] { result = append(result, arr...) } return result } // Unwrap same thing as Contact, just different interface, combines several array into single one func Unwrap(arrays [][]byte) []byte { var result []byte = arrays[0] for _, arr := range arrays[1:] { result = append(result, arr...) } return result } // UInt64ToBytes unwrap uint64 value to byte array of length 8 using big endian func UInt64ToBytes(value uint64) []byte { result := make([]byte, 8) binary.BigEndian.PutUint64(result, value) return result } // UInt32ToBytes unwrap uint32 value to byte array of length 4 using big endian func UInt32ToBytes(value uint32) []byte { result := make([]byte, 4) binary.BigEndian.PutUint32(result, value) return result } // Dump produces printable debug representation of byte array as string func Dump(arr []byte) string { var buf bytes.Buffer buf.WriteString("(") buf.WriteString(fmt.Sprintf("%v", len(arr))) buf.WriteString(" bytes)[") for idx, b := range arr { buf.WriteString(fmt.Sprintf("%v", b)) if idx != len(arr)-1 { buf.WriteString(", ") } } buf.WriteString("], Hex: [") for idx, b := range arr { buf.WriteString(fmt.Sprintf("%X", b)) if idx != len(arr)-1 { buf.WriteString(" ") } } buf.WriteString("], Base64Url:") buf.WriteString(base64url.Encode(arr)) return buf.String() } jose2go-1.5/arrays/arrays_test.go000066400000000000000000000036311373537523000171320ustar00rootroot00000000000000package arrays import ( . "gopkg.in/check.v1" "testing" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestXor(c *C) { //given data := []byte{0xFF, 0x00, 0xF0, 0x0F, 0x55, 0xAA, 0xBB, 0xCC} //when test_1 := Xor(data, []byte{0x00, 0xFF, 0x0F, 0xF0, 0xAA, 0x55, 0x44, 0x33}) test_2 := Xor(data, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}) //then c.Assert(test_1, DeepEquals, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}) c.Assert(test_2, DeepEquals, []byte{0x00, 0xFF, 0x0F, 0xF0, 0xAA, 0x55, 0x44, 0x33}) } func (s *TestSuite) TestSlice(c *C) { //given data := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8} //when test := Slice(data, 3) //then c.Assert(len(test), Equals, 3) c.Assert(test[0], DeepEquals, []byte{0, 1, 2}) c.Assert(test[1], DeepEquals, []byte{3, 4, 5}) c.Assert(test[2], DeepEquals, []byte{6, 7, 8}) } func (s *TestSuite) TestConcat(c *C) { //given a := []byte{1, 2, 3} b := []byte{4, 5} d := []byte{6} e := []byte{} f := []byte{7, 8, 9, 10} //when test := Concat(a, b, d, e, f) //then c.Assert(test, DeepEquals, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) } func (s *TestSuite) TestUnwrap(c *C) { //given a := []byte{1, 2, 3} b := []byte{4, 5} d := []byte{6} e := []byte{} f := []byte{7, 8, 9, 10} //when test := Unwrap([][]byte{a, b, d, e, f}) //then c.Assert(test, DeepEquals, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) } func (s *TestSuite) TestUInt32ToBytes(c *C) { //then c.Assert(UInt32ToBytes(0xFF), DeepEquals, []byte{0x00, 0x00, 0x00, 0xFF}) c.Assert(UInt32ToBytes(0xFFFFFFFE), DeepEquals, []byte{0xff, 0xff, 0xff, 0xfe}) } func (s *TestSuite) TestUInt64ToBytes(c *C) { //then c.Assert(UInt64ToBytes(0xFF), DeepEquals, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}) c.Assert(UInt64ToBytes(0xFFFFFFFFFFFFFFFE), DeepEquals, []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}) } jose2go-1.5/base64url/000077500000000000000000000000001373537523000145465ustar00rootroot00000000000000jose2go-1.5/base64url/base64url.go000066400000000000000000000016731373537523000167130ustar00rootroot00000000000000// package base64url provides base64url encoding/decoding support package base64url import ( "strings" "encoding/base64" ) // Decode decodes base64url string to byte array func Decode(data string) ([]byte,error) { data = strings.Replace(data, "-", "+", -1) // 62nd char of encoding data = strings.Replace(data, "_", "/", -1) // 63rd char of encoding switch(len(data) % 4) { // Pad with trailing '='s case 0: // no padding case 2: data+="==" // 2 pad chars case 3: data+="=" // 1 pad char } return base64.StdEncoding.DecodeString(data) } // Encode encodes given byte array to base64url string func Encode(data []byte) string { result := base64.StdEncoding.EncodeToString(data) result = strings.Replace(result, "+", "-", -1) // 62nd char of encoding result = strings.Replace(result, "/", "_", -1) // 63rd char of encoding result = strings.Replace(result, "=", "", -1) // Remove any trailing '='s return result }jose2go-1.5/base64url/base64url_test.go000066400000000000000000000015551373537523000177510ustar00rootroot00000000000000package base64url import ( "testing" "fmt" . "gopkg.in/check.v1" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestEncode(c *C) { //given in:=[]byte{72,101,108,108,111,32,66,97,115,101,54,52,85,114,108,32,101,110,99,111,100,105,110,103,33} //when test:=Encode(in) //then c.Assert(test, Equals, "SGVsbG8gQmFzZTY0VXJsIGVuY29kaW5nIQ") } func (s *TestSuite) TestDecode(c *C) { //when test,err := Decode("SGVsbG8gQmFzZTY0VXJsIGVuY29kaW5nIQ") //then c.Assert(err, IsNil) c.Assert(test, DeepEquals, []byte{72,101,108,108,111,32,66,97,115,101,54,52,85,114,108,32,101,110,99,111,100,105,110,103,33}) } func (s *TestSuite) TestDecodeIllegalBase64String(c *C) { //when _,err := Decode("SGVsbG8gQmFzZTY0VXJsIGVuY29kaW5nQ") //then c.Assert(err,NotNil) fmt.Printf("err = %v\n",err) }jose2go-1.5/compact/000077500000000000000000000000001373537523000143655ustar00rootroot00000000000000jose2go-1.5/compact/compact.go000066400000000000000000000014551373537523000163470ustar00rootroot00000000000000// package compact provides function to work with json compact serialization format package compact import ( "github.com/dvsekhvalnov/jose2go/base64url" "strings" ) // Parse splitting & decoding compact serialized json web token, returns slice of byte arrays, each representing part of token func Parse(token string) (result [][]byte, e error) { parts := strings.Split(token, ".") result = make([][]byte, len(parts)) for i, part := range parts { if result[i], e = base64url.Decode(part); e != nil { return nil, e } } return result, nil } // Serialize converts given parts into compact serialization format func Serialize(parts ...[]byte) string { result := make([]string, len(parts)) for i, part := range parts { result[i] = base64url.Encode(part) } return strings.Join(result, ".") } jose2go-1.5/compact/compact_test.go000066400000000000000000000203471373537523000174070ustar00rootroot00000000000000package compact import ( "fmt" . "gopkg.in/check.v1" "testing" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestParseThreeParts(c *C) { //when test, err := Parse("eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E") //then c.Assert(err, IsNil) c.Assert(test, HasLen, 3) c.Assert(test[0], DeepEquals, []byte{123, 34, 97, 108, 103, 34, 58, 34, 72, 83, 50, 53, 54, 34, 44, 34, 99, 116, 121, 34, 58, 34, 116, 101, 120, 116, 92, 47, 112, 108, 97, 105, 110, 34, 125}) c.Assert(test[1], DeepEquals, []byte{123, 34, 104, 101, 108, 108, 111, 34, 58, 32, 34, 119, 111, 114, 108, 100, 34, 125}) c.Assert(test[2], DeepEquals, []byte{114, 18, 40, 97, 106, 208, 48, 15, 23, 47, 153, 197, 207, 170, 11, 12, 156, 175, 128, 121, 54, 40, 14, 1, 172, 81, 171, 43, 41, 163, 11, 193}) } func (s *TestSuite) TestParseEmptyTrailingPart(c *C) { //when test, err := Parse("eyJhbGciOiJub25lIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.") //then c.Assert(err, IsNil) c.Assert(test, HasLen, 3) c.Assert(test[0], DeepEquals, []byte{123, 34, 97, 108, 103, 34, 58, 34, 110, 111, 110, 101, 34, 125}) c.Assert(test[1], DeepEquals, []byte{123, 34, 104, 101, 108, 108, 111, 34, 58, 32, 34, 119, 111, 114, 108, 100, 34, 125}) c.Assert(test[2], DeepEquals, []byte{}) } func (s *TestSuite) TestParseFiveParts(c *C) { //when test, err := Parse("eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4R0NNIn0.FojyyzygtFOyNBjzqTRfr9HVHPrvtqbVUt9sXSuU59ZhLlzk7FrirryFnFGtj8YC9lx-IX156Ro9rBaJTCU_dfERd05DhPMffT40rdcDiLxfCLOY0E2PfsMyGQPhI6YtNBtf_sQjXWEBC59zH_VoswFAUstkvXY9eVVecoM-W9HFlIxwUXMVpEPtS96xZX5LMksDgJ9sYDTNa6EQOA0hfzw07fD_FFJShcueqJuoJjILYbad-AHbpnLTV4oTbFTYjskRxpEYQr9plFZsT4_xKiCU89slT9EFhmuaiUI_-NGdX-kNDyQZj2Vtid4LSOVv5kGxyygThuQb6wjr1AGe1g.O92pf8iqwlBIQmXA.YdGjkN7lzeKYIv743XlPRYTd3x4VA0xwa5WVoGf1hiHlhQuXGEg4Jv3elk4JoFJzgVuMMQMex8fpFFL3t5I4H9bH18pbrEo7wLXvGOsP971cuOOaXPxhX6qClkwx5qkWhcTbO_2AuJxzIaU9qBwtwWaxJm9axofAPYgYbdaMZkU4F5sFdaFY8IOe94wUA1Ocn_gxC_DYp9IEAyZut0j5RImmthPgiRO_0pK9OvusE_Xg3iGfdxu70x0KpoItuNwlEf0LUA.uP5jOGMxtDUiT6E3ubucBw") //then c.Assert(err, IsNil) c.Assert(test, HasLen, 5) c.Assert(test[0], DeepEquals, []byte{123, 34, 97, 108, 103, 34, 58, 34, 82, 83, 65, 49, 95, 53, 34, 44, 34, 101, 110, 99, 34, 58, 34, 65, 49, 50, 56, 71, 67, 77, 34, 125}) c.Assert(test[1], DeepEquals, []byte{22, 136, 242, 203, 60, 160, 180, 83, 178, 52, 24, 243, 169, 52, 95, 175, 209, 213, 28, 250, 239, 182, 166, 213, 82, 223, 108, 93, 43, 148, 231, 214, 97, 46, 92, 228, 236, 90, 226, 174, 188, 133, 156, 81, 173, 143, 198, 2, 246, 92, 126, 33, 125, 121, 233, 26, 61, 172, 22, 137, 76, 37, 63, 117, 241, 17, 119, 78, 67, 132, 243, 31, 125, 62, 52, 173, 215, 3, 136, 188, 95, 8, 179, 152, 208, 77, 143, 126, 195, 50, 25, 3, 225, 35, 166, 45, 52, 27, 95, 254, 196, 35, 93, 97, 1, 11, 159, 115, 31, 245, 104, 179, 1, 64, 82, 203, 100, 189, 118, 61, 121, 85, 94, 114, 131, 62, 91, 209, 197, 148, 140, 112, 81, 115, 21, 164, 67, 237, 75, 222, 177, 101, 126, 75, 50, 75, 3, 128, 159, 108, 96, 52, 205, 107, 161, 16, 56, 13, 33, 127, 60, 52, 237, 240, 255, 20, 82, 82, 133, 203, 158, 168, 155, 168, 38, 50, 11, 97, 182, 157, 248, 1, 219, 166, 114, 211, 87, 138, 19, 108, 84, 216, 142, 201, 17, 198, 145, 24, 66, 191, 105, 148, 86, 108, 79, 143, 241, 42, 32, 148, 243, 219, 37, 79, 209, 5, 134, 107, 154, 137, 66, 63, 248, 209, 157, 95, 233, 13, 15, 36, 25, 143, 101, 109, 137, 222, 11, 72, 229, 111, 230, 65, 177, 203, 40, 19, 134, 228, 27, 235, 8, 235, 212, 1, 158, 214}) c.Assert(test[2], DeepEquals, []byte{59, 221, 169, 127, 200, 170, 194, 80, 72, 66, 101, 192}) c.Assert(test[3], DeepEquals, []byte{97, 209, 163, 144, 222, 229, 205, 226, 152, 34, 254, 248, 221, 121, 79, 69, 132, 221, 223, 30, 21, 3, 76, 112, 107, 149, 149, 160, 103, 245, 134, 33, 229, 133, 11, 151, 24, 72, 56, 38, 253, 222, 150, 78, 9, 160, 82, 115, 129, 91, 140, 49, 3, 30, 199, 199, 233, 20, 82, 247, 183, 146, 56, 31, 214, 199, 215, 202, 91, 172, 74, 59, 192, 181, 239, 24, 235, 15, 247, 189, 92, 184, 227, 154, 92, 252, 97, 95, 170, 130, 150, 76, 49, 230, 169, 22, 133, 196, 219, 59, 253, 128, 184, 156, 115, 33, 165, 61, 168, 28, 45, 193, 102, 177, 38, 111, 90, 198, 135, 192, 61, 136, 24, 109, 214, 140, 102, 69, 56, 23, 155, 5, 117, 161, 88, 240, 131, 158, 247, 140, 20, 3, 83, 156, 159, 248, 49, 11, 240, 216, 167, 210, 4, 3, 38, 110, 183, 72, 249, 68, 137, 166, 182, 19, 224, 137, 19, 191, 210, 146, 189, 58, 251, 172, 19, 245, 224, 222, 33, 159, 119, 27, 187, 211, 29, 10, 166, 130, 45, 184, 220, 37, 17, 253, 11, 80}) c.Assert(test[4], DeepEquals, []byte{184, 254, 99, 56, 99, 49, 180, 53, 34, 79, 161, 55, 185, 187, 156, 7}) } func (s *TestSuite) TestParseInvalidBase64Encoded(c *C) { //when test, err := Parse("eyJhbGciOiJub25lIn0.eyJo@#xsbyI6ICJ3b3JsZCJ9.") //then c.Assert(err, NotNil) fmt.Printf("\nerr=%v\n", err) c.Assert(test, IsNil) } func (s *TestSuite) TestParseEmptyMiddlePart(c *C) { //when test, err := Parse("eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4R0NNIn0..yVi-LdQQngN0C5WS.1McwSmhZzAtmmLp9y-OdnJwaJFo1nj_4ashmzl2LhubGf0Jl1OTEVJzsHZb7bkup7cGTkuxh6Vfv10ljHsjWf_URXoxP3stQqQeViVcuPV0y2Q_WHYzTNGZpmHGe-hM6gjDhyZyvu3yeXGFSvfPQmp9pWVOgDjI4RC0MQ83rzzn-rRdnZkznWjbmOPxwPrR72Qng0BISsEwbkPn4oO8-vlHkVmPpuDTaYzCT2ZR5K9JnIU8d8QdxEAGb7-s8GEJ1yqtd_w._umbK59DAKA3O89h15VoKQ") //then c.Assert(err, IsNil) c.Assert(test, HasLen, 5) c.Assert(test[0], DeepEquals, []byte{123, 34, 97, 108, 103, 34, 58, 34, 100, 105, 114, 34, 44, 34, 101, 110, 99, 34, 58, 34, 65, 49, 50, 56, 71, 67, 77, 34, 125}) c.Assert(test[1], DeepEquals, []byte{}) c.Assert(test[2], DeepEquals, []byte{201, 88, 190, 45, 212, 16, 158, 3, 116, 11, 149, 146}) c.Assert(test[3], DeepEquals, []byte{212, 199, 48, 74, 104, 89, 204, 11, 102, 152, 186, 125, 203, 227, 157, 156, 156, 26, 36, 90, 53, 158, 63, 248, 106, 200, 102, 206, 93, 139, 134, 230, 198, 127, 66, 101, 212, 228, 196, 84, 156, 236, 29, 150, 251, 110, 75, 169, 237, 193, 147, 146, 236, 97, 233, 87, 239, 215, 73, 99, 30, 200, 214, 127, 245, 17, 94, 140, 79, 222, 203, 80, 169, 7, 149, 137, 87, 46, 61, 93, 50, 217, 15, 214, 29, 140, 211, 52, 102, 105, 152, 113, 158, 250, 19, 58, 130, 48, 225, 201, 156, 175, 187, 124, 158, 92, 97, 82, 189, 243, 208, 154, 159, 105, 89, 83, 160, 14, 50, 56, 68, 45, 12, 67, 205, 235, 207, 57, 254, 173, 23, 103, 102, 76, 231, 90, 54, 230, 56, 252, 112, 62, 180, 123, 217, 9, 224, 208, 18, 18, 176, 76, 27, 144, 249, 248, 160, 239, 62, 190, 81, 228, 86, 99, 233, 184, 52, 218, 99, 48, 147, 217, 148, 121, 43, 210, 103, 33, 79, 29, 241, 7, 113, 16, 1, 155, 239, 235, 60, 24, 66, 117, 202, 171, 93, 255}) c.Assert(test[4], DeepEquals, []byte{254, 233, 155, 43, 159, 67, 0, 160, 55, 59, 207, 97, 215, 149, 104, 41}) } func (s *TestSuite) TestSerialize(c *C) { //when test := Serialize([]byte{123, 34, 97, 108, 103, 34, 58, 34, 72, 83, 50, 53, 54, 34, 44, 34, 99, 116, 121, 34, 58, 34, 116, 101, 120, 116, 92, 47, 112, 108, 97, 105, 110, 34, 125}, []byte{123, 34, 104, 101, 108, 108, 111, 34, 58, 32, 34, 119, 111, 114, 108, 100, 34, 125}, []byte{114, 18, 40, 97, 106, 208, 48, 15, 23, 47, 153, 197, 207, 170, 11, 12, 156, 175, 128, 121, 54, 40, 14, 1, 172, 81, 171, 43, 41, 163, 11, 193}) //then c.Assert(test, Equals, "eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E") } func (s *TestSuite) TestSerializeEmptyTrailingPart(c *C) { //when test := Serialize([]byte{123, 34, 97, 108, 103, 34, 58, 34, 72, 83, 50, 53, 54, 34, 44, 34, 99, 116, 121, 34, 58, 34, 116, 101, 120, 116, 92, 47, 112, 108, 97, 105, 110, 34, 125}, []byte{123, 34, 104, 101, 108, 108, 111, 34, 58, 32, 34, 119, 111, 114, 108, 100, 34, 125}, []byte{}) //then c.Assert(test, Equals, "eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.") } func (s *TestSuite) TestSerializeEmptyMiddlePart(c *C) { //when test := Serialize([]byte{123, 34, 97, 108, 103, 34, 58, 34, 72, 83, 50, 53, 54, 34, 44, 34, 99, 116, 121, 34, 58, 34, 116, 101, 120, 116, 92, 47, 112, 108, 97, 105, 110, 34, 125}, []byte{}, []byte{114, 18, 40, 97, 106, 208, 48, 15, 23, 47, 153, 197, 207, 170, 11, 12, 156, 175, 128, 121, 54, 40, 14, 1, 172, 81, 171, 43, 41, 163, 11, 193}) //then c.Assert(test, Equals, "eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0..chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E") } jose2go-1.5/deflate.go000066400000000000000000000011531373537523000146720ustar00rootroot00000000000000package jose import ( "bytes" "compress/flate" "io/ioutil" ) func init() { RegisterJwc(new(Deflate)) } // Deflate compression algorithm implementation type Deflate struct {} func (alg *Deflate) Name() string { return DEF } func (alg *Deflate) Compress(plainText []byte) []byte { var buf bytes.Buffer deflate,_ := flate.NewWriter(&buf, 8) //level=DEFLATED deflate.Write(plainText) deflate.Close() return buf.Bytes() } func (alg *Deflate) Decompress(compressedText []byte) []byte { enflated,_ := ioutil.ReadAll( flate.NewReader( bytes.NewReader(compressedText))) return enflated } jose2go-1.5/direct.go000066400000000000000000000015711373537523000145440ustar00rootroot00000000000000package jose import ( "errors" ) func init() { RegisterJwa(new(Direct)) } // Direct (pre-shared) key management algorithm implementation type Direct struct{ } func (alg *Direct) Name() string { return DIR } func (alg *Direct) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if cek,ok:=key.([]byte); ok { return cek,[]byte{},nil } return nil,nil,errors.New("Direct.WrapNewKey(): expected key to be '[]byte' array") } func (alg *Direct) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if(len(encryptedCek)!=0) { return nil, errors.New("Direct.Unwrap(): expected empty encrypted CEK") } if cek,ok:=key.([]byte); ok { return cek,nil } return nil,errors.New("Direct.Unwrap(): expected key to be '[]byte' array") } jose2go-1.5/ecdh.go000066400000000000000000000106751373537523000142020ustar00rootroot00000000000000package jose import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/sha256" "errors" "fmt" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/base64url" "github.com/dvsekhvalnov/jose2go/kdf" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go/padding" "math/big" ) func init() { RegisterJwa(&Ecdh{directAgreement: true}) } // Elliptic curve Diffie–Hellman key management (key agreement) algorithm implementation type Ecdh struct { directAgreement bool } func (alg *Ecdh) Name() string { return ECDH_ES } func (alg *Ecdh) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if pubKey, ok := key.(*ecdsa.PublicKey); ok { if _, ok := header[alg.idHeader()].(string); !ok { return nil, nil, errors.New(fmt.Sprintf("Ecdh.WrapNewKey(): expected '%v' param in JWT header, but was not found.", alg.idHeader())) } var d []byte var x, y *big.Int if d, x, y, err = elliptic.GenerateKey(pubKey.Curve, rand.Reader); err != nil { return nil, nil, err } ephemeral := ecc.NewPrivate(x.Bytes(), y.Bytes(), d) xBytes := padding.Align(x.Bytes(), pubKey.Curve.Params().BitSize) yBytes := padding.Align(y.Bytes(), pubKey.Curve.Params().BitSize) epk := map[string]string{ "kty": "EC", "x": base64url.Encode(xBytes), "y": base64url.Encode(yBytes), "crv": name(pubKey.Curve), } header["epk"] = epk return alg.deriveKey(pubKey, ephemeral, cekSizeBits, header), nil, nil } return nil, nil, errors.New("Ecdh.WrapNewKey(): expected key to be '*ecdsa.PublicKey'") } func (alg *Ecdh) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if privKey, ok := key.(*ecdsa.PrivateKey); ok { var epk map[string]interface{} if epk, ok = header["epk"].(map[string]interface{}); !ok { return nil, errors.New("Ecdh.Unwrap(): expected 'epk' param in JWT header, but was not found.") } if _, ok := header[alg.idHeader()].(string); !ok { return nil, errors.New(fmt.Sprintf("Ecdh.Unwrap(): expected '%v' param in JWT header, but was not found.", alg.idHeader())) } var x, y, crv string var xBytes, yBytes []byte if x, ok = epk["x"].(string); !ok { return nil, errors.New("Ecdh.Unwrap(): expects 'epk' key to contain 'x','y' and 'crv' fields, but 'x' was not found.") } if y, ok = epk["y"].(string); !ok { return nil, errors.New("Ecdh.Unwrap(): expects 'epk' key to contain 'x','y' and 'crv' fields, but 'y' was not found.") } if crv, ok = epk["crv"].(string); !ok { return nil, errors.New("Ecdh.Unwrap(): expects 'epk' key to contain 'x','y' and 'crv' fields, but 'crv' was not found.") } if crv != "P-256" && crv != "P-384" && crv != "P-521" { return nil, errors.New(fmt.Sprintf("Ecdh.Unwrap(): unknown or unsupported curve %v", crv)) } if xBytes, err = base64url.Decode(x); err != nil { return nil, err } if yBytes, err = base64url.Decode(y); err != nil { return nil, err } pubKey := ecc.NewPublic(xBytes, yBytes) if !privKey.Curve.IsOnCurve(pubKey.X, pubKey.Y) { return nil, errors.New(fmt.Sprintf("Ephemeral public key received in header is invalid for reciever's private key.")) } return alg.deriveKey(pubKey, privKey, cekSizeBits, header), nil } return nil, errors.New("Ecdh.Unwrap(): expected key to be '*ecdsa.PrivateKey'") } func (alg *Ecdh) deriveKey(pubKey *ecdsa.PublicKey, privKey *ecdsa.PrivateKey, keySizeBits int, header map[string]interface{}) []byte { var enc, apv, apu []byte var err error enc = []byte(header[alg.idHeader()].(string)) if a, ok := header["apv"].(string); !ok { if apv, err = base64url.Decode(a); err != nil { apv = nil } } if a, ok := header["apu"].(string); !ok { if apu, err = base64url.Decode(a); err != nil { apu = nil } } z, _ := pubKey.Curve.ScalarMult(pubKey.X, pubKey.Y, privKey.D.Bytes()) zBytes := padding.Align(z.Bytes(), privKey.Curve.Params().BitSize) return kdf.DeriveConcatKDF(keySizeBits, zBytes, prependDatalen(enc), prependDatalen(apu), prependDatalen(apv), arrays.UInt32ToBytes(uint32(keySizeBits)), nil, sha256.New()) } func (alg *Ecdh) idHeader() string { if alg.directAgreement { return "enc" } return "alg" } func name(curve elliptic.Curve) string { return fmt.Sprintf("P-%v", curve.Params().BitSize) } func prependDatalen(bytes []byte) []byte { return arrays.Concat(arrays.UInt32ToBytes(uint32(len(bytes))), bytes) } jose2go-1.5/ecdh_aeskw.go000066400000000000000000000025161373537523000153670ustar00rootroot00000000000000package jose func init() { RegisterJwa(&EcdhAesKW{ keySizeBits: 128, aesKW: &AesKW{ keySizeBits: 128}, ecdh: &Ecdh{directAgreement:false}}) RegisterJwa(&EcdhAesKW{ keySizeBits: 192, aesKW: &AesKW{ keySizeBits: 192}, ecdh: &Ecdh{directAgreement:false}}) RegisterJwa(&EcdhAesKW{ keySizeBits: 256, aesKW: &AesKW{ keySizeBits: 256}, ecdh: &Ecdh{directAgreement:false}}) } // Elliptic curve Diffie–Hellman with AES Key Wrap key management algorithm implementation type EcdhAesKW struct{ keySizeBits int aesKW JwaAlgorithm ecdh JwaAlgorithm } func (alg *EcdhAesKW) Name() string { switch alg.keySizeBits { case 128: return ECDH_ES_A128KW case 192: return ECDH_ES_A192KW default: return ECDH_ES_A256KW } } func (alg *EcdhAesKW) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { var kek []byte if kek,_,err=alg.ecdh.WrapNewKey(alg.keySizeBits, key, header);err!=nil { return nil,nil,err } return alg.aesKW.WrapNewKey(cekSizeBits,kek,header) } func (alg *EcdhAesKW) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { var kek []byte if kek,err=alg.ecdh.Unwrap(nil, key, alg.keySizeBits, header);err!=nil { return nil,err } return alg.aesKW.Unwrap(encryptedCek,kek,cekSizeBits,header) }jose2go-1.5/ecdsa_using_sha.go000066400000000000000000000041531373537523000164100ustar00rootroot00000000000000package jose import ( "crypto/rand" "math/big" "crypto/ecdsa" "errors" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/padding" "fmt" ) func init() { RegisterJws(&EcdsaUsingSha{keySizeBits: 256, hashSizeBits: 256}) RegisterJws(&EcdsaUsingSha{keySizeBits: 384, hashSizeBits: 384}) RegisterJws(&EcdsaUsingSha{keySizeBits: 521, hashSizeBits: 512}) } // ECDSA signing algorithm implementation type EcdsaUsingSha struct{ keySizeBits int hashSizeBits int } func (alg *EcdsaUsingSha) Name() string { switch alg.keySizeBits { case 256: return ES256 case 384: return ES384 default: return ES512 } } func (alg *EcdsaUsingSha) Verify(securedInput, signature []byte, key interface{}) error { if pubKey,ok:=key.(*ecdsa.PublicKey);ok { if sizeBits:=pubKey.Curve.Params().BitSize;sizeBits!=alg.keySizeBits { return errors.New(fmt.Sprintf("EcdsaUsingSha.Verify(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits,sizeBits)) } r:=new(big.Int).SetBytes(signature[:len(signature)/2]) s:=new(big.Int).SetBytes(signature[len(signature)/2:]) if ok:=ecdsa.Verify(pubKey, sha(alg.hashSizeBits, securedInput), r,s); ok { return nil } return errors.New("EcdsaUsingSha.Verify(): Signature is not valid.") } return errors.New("EcdsaUsingSha.Verify(): expects key to be '*ecdsa.PublicKey'") } func (alg *EcdsaUsingSha) Sign(securedInput []byte, key interface{}) (signature []byte, err error) { if privKey,ok := key.(*ecdsa.PrivateKey);ok { if sizeBits:=privKey.Curve.Params().BitSize;sizeBits!=alg.keySizeBits { return nil,errors.New(fmt.Sprintf("EcdsaUsingSha.Sign(): expected key of size %v bits, but was given %v bits.",alg.keySizeBits,sizeBits)) } var r,s *big.Int if r,s,err = ecdsa.Sign(rand.Reader, privKey, sha(alg.hashSizeBits, securedInput));err==nil { rBytes:=padding.Align(r.Bytes(), alg.keySizeBits) sBytes:=padding.Align(s.Bytes(), alg.keySizeBits) return arrays.Concat(rBytes,sBytes),nil } return nil, err } return nil,errors.New("EcdsaUsingSha.Sign(): expects key to be '*ecdsa.PrivateKey'") }jose2go-1.5/go.mod000066400000000000000000000002761373537523000140520ustar00rootroot00000000000000module github.com/dvsekhvalnov/jose2go go 1.15 require ( github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b ) jose2go-1.5/go.sum000066400000000000000000000012371373537523000140750ustar00rootroot00000000000000github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U= gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= jose2go-1.5/hmac.go000066400000000000000000000004031373537523000141730ustar00rootroot00000000000000package jose import ( "crypto/hmac" "hash" ) func calculateHmac(keySizeBits int, securedInput []byte, key []byte) []byte { hasher := hmac.New(func() hash.Hash { return hashAlg(keySizeBits)}, key) hasher.Write(securedInput) return hasher.Sum(nil) }jose2go-1.5/hmac_using_sha.go000066400000000000000000000020161373537523000162350ustar00rootroot00000000000000package jose import ( "crypto/hmac" "errors" ) func init() { RegisterJws(&HmacUsingSha{keySizeBits: 256}) RegisterJws(&HmacUsingSha{keySizeBits: 384}) RegisterJws(&HmacUsingSha{keySizeBits: 512}) } // HMAC with SHA signing algorithm implementation type HmacUsingSha struct{ keySizeBits int } func (alg *HmacUsingSha) Name() string { switch alg.keySizeBits { case 256: return HS256 case 384: return HS384 default: return HS512 } } func (alg *HmacUsingSha) Verify(securedInput, signature []byte, key interface{}) error { actualSig,_ := alg.Sign(securedInput, key) if !hmac.Equal(signature, actualSig) { return errors.New("HmacUsingSha.Verify(): Signature is invalid") } return nil } func (alg *HmacUsingSha) Sign(securedInput []byte, key interface{}) (signature []byte, err error) { //TODO: assert min key size if pubKey,ok:=key.([]byte); ok { return calculateHmac(alg.keySizeBits, securedInput, pubKey),nil } return nil,errors.New("HmacUsingSha.Sign(): expects key to be '[]byte' array") }jose2go-1.5/jose.go000066400000000000000000000370161373537523000142350ustar00rootroot00000000000000//Package jose provides high level functions for producing (signing, encrypting and // compressing) or consuming (decoding) Json Web Tokens using Java Object Signing and Encryption spec package jose import ( "encoding/json" "errors" "fmt" "github.com/dvsekhvalnov/jose2go/compact" ) const ( NONE = "none" //plaintext (unprotected) without signature / encryption HS256 = "HS256" //HMAC using SHA-256 hash HS384 = "HS384" //HMAC using SHA-384 hash HS512 = "HS512" //HMAC using SHA-512 hash RS256 = "RS256" //RSASSA-PKCS-v1_5 using SHA-256 hash RS384 = "RS384" //RSASSA-PKCS-v1_5 using SHA-384 hash RS512 = "RS512" //RSASSA-PKCS-v1_5 using SHA-512 hash PS256 = "PS256" //RSASSA-PSS using SHA-256 hash PS384 = "PS384" //RSASSA-PSS using SHA-384 hash PS512 = "PS512" //RSASSA-PSS using SHA-512 hash ES256 = "ES256" //ECDSA using P-256 curve and SHA-256 hash ES384 = "ES384" //ECDSA using P-384 curve and SHA-384 hash ES512 = "ES512" //ECDSA using P-521 curve and SHA-512 hash A128CBC_HS256 = "A128CBC-HS256" //AES in CBC mode with PKCS #5 (NIST.800-38A) padding with HMAC using 256 bit key A192CBC_HS384 = "A192CBC-HS384" //AES in CBC mode with PKCS #5 (NIST.800-38A) padding with HMAC using 384 bit key A256CBC_HS512 = "A256CBC-HS512" //AES in CBC mode with PKCS #5 (NIST.800-38A) padding with HMAC using 512 bit key A128GCM = "A128GCM" //AES in GCM mode with 128 bit key A192GCM = "A192GCM" //AES in GCM mode with 192 bit key A256GCM = "A256GCM" //AES in GCM mode with 256 bit key DIR = "dir" //Direct use of pre-shared symmetric key RSA1_5 = "RSA1_5" //RSAES with PKCS #1 v1.5 padding, RFC 3447 RSA_OAEP = "RSA-OAEP" //RSAES using Optimal Assymetric Encryption Padding, RFC 3447 RSA_OAEP_256 = "RSA-OAEP-256" //RSAES using Optimal Assymetric Encryption Padding with SHA-256, RFC 3447 A128KW = "A128KW" //AES Key Wrap Algorithm using 128 bit keys, RFC 3394 A192KW = "A192KW" //AES Key Wrap Algorithm using 192 bit keys, RFC 3394 A256KW = "A256KW" //AES Key Wrap Algorithm using 256 bit keys, RFC 3394 A128GCMKW = "A128GCMKW" //AES GCM Key Wrap Algorithm using 128 bit keys A192GCMKW = "A192GCMKW" //AES GCM Key Wrap Algorithm using 192 bit keys A256GCMKW = "A256GCMKW" //AES GCM Key Wrap Algorithm using 256 bit keys PBES2_HS256_A128KW = "PBES2-HS256+A128KW" //Password Based Encryption using PBES2 schemes with HMAC-SHA and AES Key Wrap using 128 bit key PBES2_HS384_A192KW = "PBES2-HS384+A192KW" //Password Based Encryption using PBES2 schemes with HMAC-SHA and AES Key Wrap using 192 bit key PBES2_HS512_A256KW = "PBES2-HS512+A256KW" //Password Based Encryption using PBES2 schemes with HMAC-SHA and AES Key Wrap using 256 bit key ECDH_ES = "ECDH-ES" //Elliptic Curve Diffie Hellman key agreement ECDH_ES_A128KW = "ECDH-ES+A128KW" //Elliptic Curve Diffie Hellman key agreement with AES Key Wrap using 128 bit key ECDH_ES_A192KW = "ECDH-ES+A192KW" //Elliptic Curve Diffie Hellman key agreement with AES Key Wrap using 192 bit key ECDH_ES_A256KW = "ECDH-ES+A256KW" //Elliptic Curve Diffie Hellman key agreement with AES Key Wrap using 256 bit key DEF = "DEF" //DEFLATE compression, RFC 1951 ) var jwsHashers = map[string]JwsAlgorithm{} var jweEncryptors = map[string]JweEncryption{} var jwaAlgorithms = map[string]JwaAlgorithm{} var jwcCompressors = map[string]JwcAlgorithm{} // RegisterJwe register new encryption algorithm func RegisterJwe(alg JweEncryption) { jweEncryptors[alg.Name()] = alg } // RegisterJwa register new key management algorithm func RegisterJwa(alg JwaAlgorithm) { jwaAlgorithms[alg.Name()] = alg } // RegisterJws register new signing algorithm func RegisterJws(alg JwsAlgorithm) { jwsHashers[alg.Name()] = alg } // RegisterJwc register new compression algorithm func RegisterJwc(alg JwcAlgorithm) { jwcCompressors[alg.Name()] = alg } // JweEncryption is a contract for implementing encryption algorithm type JweEncryption interface { Encrypt(aad, plainText, cek []byte) (iv, cipherText, authTag []byte, err error) Decrypt(aad, cek, iv, cipherText, authTag []byte) (plainText []byte, err error) KeySizeBits() int Name() string } // JwaAlgorithm is a contract for implementing key management algorithm type JwaAlgorithm interface { WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) Name() string } // JwsAlgorithm is a contract for implementing signing algorithm type JwsAlgorithm interface { Verify(securedInput, signature []byte, key interface{}) error Sign(securedInput []byte, key interface{}) (signature []byte, err error) Name() string } // JwcAlgorithm is a contract for implementing compression algorithm type JwcAlgorithm interface { Compress(plainText []byte) []byte Decompress(compressedText []byte) []byte Name() string } func Zip(alg string) func(cfg *JoseConfig) { return func(cfg *JoseConfig) { cfg.CompressionAlg = alg } } func Header(name string, value interface{}) func(cfg *JoseConfig) { return func(cfg *JoseConfig) { cfg.Headers[name] = value } } func Headers(headers map[string]interface{}) func(cfg *JoseConfig) { return func(cfg *JoseConfig) { for k, v := range headers { cfg.Headers[k] = v } } } type JoseConfig struct { CompressionAlg string Headers map[string]interface{} } // Sign produces signed JWT token given arbitrary string payload, signature algorithm to use (see constants for list of supported algs), signing key and extra options (see option functions) // Signing key is of different type for different signing alg, see specific // signing alg implementation documentation. // // It returns 3 parts signed JWT token as string and not nil error if something went wrong. func Sign(payload string, signingAlg string, key interface{}, options ...func(*JoseConfig)) (token string, err error) { return SignBytes([]byte(payload), signingAlg, key, options...) } // Sign produces signed JWT token given arbitrary binary payload, signature algorithm to use (see constants for list of supported algs), signing key and extra options (see option functions) // Signing key is of different type for different signing alg, see specific // signing alg implementation documentation. // // It returns 3 parts signed JWT token as string and not nil error if something went wrong. func SignBytes(payload []byte, signingAlg string, key interface{}, options ...func(*JoseConfig)) (token string, err error) { if signer, ok := jwsHashers[signingAlg]; ok { cfg := &JoseConfig{CompressionAlg: "", Headers: make(map[string]interface{})} //apply extra options for _, option := range options { option(cfg) } //make sure defaults and requires are managed by us cfg.Headers["alg"] = signingAlg paloadBytes := payload var header []byte var signature []byte if header, err = json.Marshal(cfg.Headers); err == nil { securedInput := []byte(compact.Serialize(header, paloadBytes)) if signature, err = signer.Sign(securedInput, key); err == nil { return compact.Serialize(header, paloadBytes, signature), nil } } return "", err } return "", errors.New(fmt.Sprintf("jwt.Sign(): unknown algorithm: '%v'", signingAlg)) } // Encrypt produces encrypted JWT token given arbitrary string payload, key management and encryption algorithms to use (see constants for list of supported algs) and management key. // Management key is of different type for different key management alg, see specific // key management alg implementation documentation. // // It returns 5 parts encrypted JWT token as string and not nil error if something went wrong. func Encrypt(payload string, alg string, enc string, key interface{}, options ...func(*JoseConfig)) (token string, err error) { return EncryptBytes([]byte(payload), alg, enc, key, options...) } // Encrypt produces encrypted JWT token given arbitrary binary payload, key management and encryption algorithms to use (see constants for list of supported algs) and management key. // Management key is of different type for different key management alg, see specific // key management alg implementation documentation. // // It returns 5 parts encrypted JWT token as string and not nil error if something went wrong. func EncryptBytes(payload []byte, alg string, enc string, key interface{}, options ...func(*JoseConfig)) (token string, err error) { cfg := &JoseConfig{CompressionAlg: "", Headers: make(map[string]interface{})} //apply extra options for _, option := range options { option(cfg) } //make sure required headers are managed by us cfg.Headers["alg"] = alg cfg.Headers["enc"] = enc byteContent := payload if cfg.CompressionAlg != "" { if zipAlg, ok := jwcCompressors[cfg.CompressionAlg]; ok { byteContent = zipAlg.Compress([]byte(payload)) cfg.Headers["zip"] = cfg.CompressionAlg } else { return "", errors.New(fmt.Sprintf("jwt.Compress(): Unknown compression method '%v'", cfg.CompressionAlg)) } } else { delete(cfg.Headers, "zip") //we not allow to manage 'zip' header manually for encryption } return encrypt(byteContent, cfg.Headers, key) } // This method is DEPRICATED and subject to be removed in next version. // Use Encrypt(..) with Zip option instead. // // Compress produces encrypted & comressed JWT token given arbitrary payload, key management , encryption and compression algorithms to use (see constants for list of supported algs) and management key. // Management key is of different type for different key management alg, see specific // key management alg implementation documentation. // // It returns 5 parts encrypted & compressed JWT token as string and not nil error if something went wrong. func Compress(payload string, alg string, enc string, zip string, key interface{}) (token string, err error) { if zipAlg, ok := jwcCompressors[zip]; ok { compressed := zipAlg.Compress([]byte(payload)) jwtHeader := map[string]interface{}{ "enc": enc, "alg": alg, "zip": zip, } return encrypt(compressed, jwtHeader, key) } return "", errors.New(fmt.Sprintf("jwt.Compress(): Unknown compression method '%v'", zip)) } // Decode verifies, decrypts and decompresses given JWT token using management key. // Management key is of different type for different key management or signing algorithms, see specific alg implementation documentation. // // Returns decoded payload as a string, headers and not nil error if something went wrong. func Decode(token string, key interface{}) (string, map[string]interface{}, error) { payload, headers, err := DecodeBytes(token, key) if err != nil { return "", nil, err } return string(payload), headers, nil } // Decode verifies, decrypts and decompresses given JWT token using management key. // Management key is of different type for different key management or signing algorithms, see specific alg implementation documentation. // // Returns decoded payload as a raw bytes, headers and not nil error if something went wrong. func DecodeBytes(token string, key interface{}) ([]byte, map[string]interface{}, error) { parts, err := compact.Parse(token) if err != nil { return nil, nil, err } if len(parts) == 3 { return verify(parts, key) } if len(parts) == 5 { return decrypt(parts, key) } return nil, nil, errors.New(fmt.Sprintf("jwt.DecodeBytes() expects token of 3 or 5 parts, but was given: %v parts", len(parts))) } func encrypt(payload []byte, jwtHeader map[string]interface{}, key interface{}) (token string, err error) { var ok bool var keyMgmtAlg JwaAlgorithm var encAlg JweEncryption alg := jwtHeader["alg"].(string) enc := jwtHeader["enc"].(string) if keyMgmtAlg, ok = jwaAlgorithms[alg]; !ok { return "", errors.New(fmt.Sprintf("jwt.encrypt(): Unknown key management algorithm '%v'", alg)) } if encAlg, ok = jweEncryptors[enc]; !ok { return "", errors.New(fmt.Sprintf("jwt.encrypt(): Unknown encryption algorithm '%v'", enc)) } var cek, encryptedCek, header, iv, cipherText, authTag []byte if cek, encryptedCek, err = keyMgmtAlg.WrapNewKey(encAlg.KeySizeBits(), key, jwtHeader); err != nil { return "", err } if header, err = json.Marshal(jwtHeader); err != nil { return "", err } if iv, cipherText, authTag, err = encAlg.Encrypt([]byte(compact.Serialize(header)), payload, cek); err != nil { return "", err } return compact.Serialize(header, encryptedCek, iv, cipherText, authTag), nil } func verify(parts [][]byte, key interface{}) (plainText []byte, headers map[string]interface{}, err error) { header, payload, signature := parts[0], parts[1], parts[2] secured := []byte(compact.Serialize(header, payload)) var jwtHeader map[string]interface{} if err = json.Unmarshal(header, &jwtHeader); err != nil { return nil, nil, err } if alg, ok := jwtHeader["alg"].(string); ok { if verifier, ok := jwsHashers[alg]; ok { if key, err = retrieveActualKey(jwtHeader, string(payload), key); err != nil { return nil, nil, err } if err = verifier.Verify(secured, signature, key); err == nil { return payload, jwtHeader, nil } return nil, nil, err } return nil, nil, errors.New(fmt.Sprintf("jwt.Decode(): Unknown algorithm: '%v'", alg)) } return nil, nil, errors.New(fmt.Sprint("jwt.Decode(): required 'alg' header is missing or of invalid type")) } func decrypt(parts [][]byte, key interface{}) (plainText []byte, headers map[string]interface{}, err error) { header, encryptedCek, iv, cipherText, authTag := parts[0], parts[1], parts[2], parts[3], parts[4] var jwtHeader map[string]interface{} if e := json.Unmarshal(header, &jwtHeader); e != nil { return nil, nil, e } var keyMgmtAlg JwaAlgorithm var encAlg JweEncryption var zipAlg JwcAlgorithm var cek, plainBytes []byte var ok bool var alg, enc string if alg, ok = jwtHeader["alg"].(string); !ok { return nil, nil, errors.New(fmt.Sprint("jwt.Decode(): required 'alg' header is missing or of invalid type")) } if enc, ok = jwtHeader["enc"].(string); !ok { return nil, nil, errors.New(fmt.Sprint("jwt.Decode(): required 'enc' header is missing or of invalid type")) } aad := []byte(compact.Serialize(header)) if keyMgmtAlg, ok = jwaAlgorithms[alg]; ok { if encAlg, ok = jweEncryptors[enc]; ok { if key, err = retrieveActualKey(jwtHeader, string(cipherText), key); err != nil { return nil, nil, err } if cek, err = keyMgmtAlg.Unwrap(encryptedCek, key, encAlg.KeySizeBits(), jwtHeader); err == nil { if plainBytes, err = encAlg.Decrypt(aad, cek, iv, cipherText, authTag); err == nil { if zip, compressed := jwtHeader["zip"].(string); compressed { if zipAlg, ok = jwcCompressors[zip]; !ok { return nil, nil, errors.New(fmt.Sprintf("jwt.decrypt(): Unknown compression algorithm '%v'", zip)) } plainBytes = zipAlg.Decompress(plainBytes) } return plainBytes, jwtHeader, nil } return nil, nil, err } return nil, nil, err } return nil, nil, errors.New(fmt.Sprintf("jwt.decrypt(): Unknown encryption algorithm '%v'", enc)) } return nil, nil, errors.New(fmt.Sprintf("jwt.decrypt(): Unknown key management algorithm '%v'", alg)) } func retrieveActualKey(headers map[string]interface{}, payload string, key interface{}) (interface{}, error) { if keyCallback, ok := key.(func(headers map[string]interface{}, payload string) interface{}); ok { result := keyCallback(headers, payload) if err, ok := result.(error); ok { return nil, err } return result, nil } return key, nil } jose2go-1.5/jose_test.go000066400000000000000000003136461373537523000153020ustar00rootroot00000000000000package jose import ( "crypto/ecdsa" "crypto/rsa" "errors" "fmt" "strings" "testing" "github.com/dvsekhvalnov/jose2go/keys/ecc" "github.com/dvsekhvalnov/jose2go/keys/rsa" . "gopkg.in/check.v1" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) var shaKey = []byte{97, 48, 97, 50, 97, 98, 100, 56, 45, 54, 49, 54, 50, 45, 52, 49, 99, 51, 45, 56, 51, 100, 54, 45, 49, 99, 102, 53, 53, 57, 98, 52, 54, 97, 102, 99} var aes128Key = []byte{194, 164, 235, 6, 138, 248, 171, 239, 24, 216, 11, 22, 137, 199, 215, 133} var aes192Key = []byte{139, 156, 136, 148, 17, 147, 27, 233, 145, 80, 115, 197, 223, 11, 100, 221, 5, 50, 155, 226, 136, 222, 216, 14} var aes256Key = []byte{164, 60, 194, 0, 161, 189, 41, 38, 130, 89, 141, 164, 45, 170, 159, 209, 69, 137, 243, 216, 191, 131, 47, 250, 32, 107, 231, 117, 37, 158, 225, 234} var aes384Key = []byte{185, 30, 233, 199, 32, 98, 209, 3, 114, 250, 30, 124, 207, 173, 227, 152, 243, 202, 238, 165, 227, 199, 202, 230, 218, 185, 216, 113, 13, 53, 40, 100, 100, 20, 59, 67, 88, 97, 191, 3, 161, 37, 147, 223, 149, 237, 190, 156} var aes512Key = []byte{238, 71, 183, 66, 57, 207, 194, 93, 82, 80, 80, 152, 92, 242, 84, 206, 194, 46, 67, 43, 231, 118, 208, 168, 156, 212, 33, 105, 27, 45, 60, 160, 232, 63, 61, 235, 68, 171, 206, 35, 152, 11, 142, 121, 174, 165, 140, 11, 172, 212, 13, 101, 13, 190, 82, 244, 109, 113, 70, 150, 251, 82, 215, 226} var pubKey = `-----BEGIN CERTIFICATE----- MIICnTCCAYUCBEReYeAwDQYJKoZIhvcNAQEFBQAwEzERMA8GA1UEAxMIand0LTIw NDgwHhcNMTQwMTI0MTMwOTE2WhcNMzQwMjIzMjAwMDAwWjATMREwDwYDVQQDEwhq d3QtMjA0ODCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKhWb9KXmv45 +TKOKhFJkrboZbpbKPJ9Yp12xKLXf8060KfStEStIX+7dCuAYylYWoqiGpuLVVUL 5JmHgXmK9TJpzv9Dfe3TAc/+35r8r9IYB2gXUOZkebty05R6PLY0RO/hs2ZhrOoz HMo+x216Gwz0CWaajcuiY5Yg1V8VvJ1iQ3rcRgZapk49RNX69kQrGS63gzj0gyHn Rtbqc/Ua2kobCA83nnznCom3AGinnlSN65AFPP5jmri0l79+4ZZNIerErSW96mUF 8jlJFZI1yJIbzbv73tL+y4i0+BvzsWBs6TkHAp4pinaI8zT+hrVQ2jD4fkJEiRN9 lAqLPUd8CNkCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAnqBw3UHOSSHtU7yMi1+H E+9119tMh7X/fCpcpOnjYmhW8uy9SiPBZBl1z6vQYkMPcURnDMGHdA31kPKICZ6G LWGkBLY3BfIQi064e8vWHW7zX6+2Wi1zFWdJlmgQzBhbr8pYh9xjZe6FjPwbSEuS 0uE8dWSWHJLdWsA4xNX9k3pr601R2vPVFCDKs3K1a8P/Xi59kYmKMjaX6vYT879y gWt43yhtGTF48y85+eqLdFRFANTbBFSzdRlPQUYa5d9PZGxeBTcg7UBkK/G+d6D5 sd78T2ymwlLYrNi+cSDYD6S4hwZaLeEK6h7p/OoG02RBNuT4VqFRu5DJ6Po+C6Jh qQ== -----END CERTIFICATE-----` var privKey = `-----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAqFZv0pea/jn5Mo4qEUmStuhlulso8n1inXbEotd/zTrQp9K0 RK0hf7t0K4BjKVhaiqIam4tVVQvkmYeBeYr1MmnO/0N97dMBz/7fmvyv0hgHaBdQ 5mR5u3LTlHo8tjRE7+GzZmGs6jMcyj7HbXobDPQJZpqNy6JjliDVXxW8nWJDetxG BlqmTj1E1fr2RCsZLreDOPSDIedG1upz9RraShsIDzeefOcKibcAaKeeVI3rkAU8 /mOauLSXv37hlk0h6sStJb3qZQXyOUkVkjXIkhvNu/ve0v7LiLT4G/OxYGzpOQcC nimKdojzNP6GtVDaMPh+QkSJE32UCos9R3wI2QIDAQABAoIBAQCUmHBvSkqUHaK/ IMU7q2FqOi0KWswDefEiJKQhRu9Wv5NOgW2FrfqDIXrDp7pg1dBezgeExHLX9v6d FAOTwbj9/m6t3+r6k6fm7gp+ao3dfD6VgPd12L2oXQ0t5NVQ1UUBJ4/QUWps9h90 3AP4vK/COG1P+CAw4DDeZi9TlwF/Pr7e492GXcLBAUJODA6538ED2nYw8xQcbzbA wr+w07UjRNimObtOfA0HCIpsx/6LkIqe6iGChisQNgt4yDd/fZ4GWOUIU1hqgK1P 6avVl7Q5Mk0PTi9t8ui1X4EEq6Uils45J5WkobuAnFkea/uKfs8Tn9bNrEoVWgdb fBHq/8bNAoGBANKmjpE9e+L0RtxP+u4FN5YDoKE+i96VR7ru8H6yBKMcnD2uf5mV RueEoL0FKHxlGBBo0dJWr1AIwpcPbTs3Dgx1/EQMZLg57QBZ7QcYETPiMwMvEM3k Zf3G4YFYwUwIQXMYPt1ckr+RncRcq0GiKPDsvzzyNS+BBSmR5onAXd7bAoGBAMyT 6ggyqmiR/UwBn87em+GjbfX6YqxHHaQBdWwnnRX0JlGTNCxt6zLTgCIYxF4AA7eR gfGTStwUJfAScjJirOe6Cpm1XDgxEQrT6oxAl17MR/ms/Z88WrT73G+4phVvDpVr JcK+CCESnRI8xGLOLMkCc+5NpLajqWCOf1H2J8NbAoGAKTWmTGmf092AA1euOmRQ 5IsfIIxQ5qGDn+FgsRh4acSOGE8L7WrTrTU4EOJyciuA0qz+50xIDbs4/j5pWx1B JVTrnhBin9vNLrVo9mtR6jmFS0ko226kOUpwEVLgtdQjobWLjtiuaMW+/Iw4gKWN ptxZ6T1lBD8UWHaPiEFW2+MCgYAmfSWoyS96YQ0QwbV5TDRzrTXA84yg8PhIpOWc pY9OVBLpghJs0XlQpK4UvCglr0cDwGJ8OsP4x+mjUzUc+aeiKURZSt/Ayqp0KQ6V uIlCEpjwBnXpAYfnSQNeGZVVrwFFZ1VBYFNTNZdLmRcxp6yRXN7G1ODKY9w4CFc3 6mHsxQKBgQCxEA+KAmmXxL++x/XOElOscz3vFHC4HbpHpOb4nywpE9vunnHE2WY4 EEW9aZbF22jx0ESU2XJ1JlqffvfIEvHNb5tmBWn4HZEpPUHdaFNhb9WjkMuFaLzh cydwnEftq+3G0X3KSxp4p7R7afcnpNNqfneYODgoXxTQ4Q7ZyKo72A== -----END RSA PRIVATE KEY-----` func (s *TestSuite) TestDecodePlaintext(c *C) { //given token := "eyJhbGciOiJub25lIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9." //when test, _, err := Decode(token, nil) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodePlaintextWithSignature(c *C) { //given token := "eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.KmLWPfxC3JGopWImDgYg9IUpgAi8gwimviUfr6eJyFI" //when test, _, err := Decode(token, nil) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecodePlaintextWithKey(c *C) { //given token := "eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9." //when test, _, err := Decode(token, shaKey) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecodeHS256(c *C) { //given token := "eyJhbGciOiJIUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E" //when test, _, err := Decode(token, shaKey) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeHS384(c *C) { //given token := "eyJhbGciOiJIUzM4NCIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.McDgk0h4mRdhPM0yDUtFG_omRUwwqVS2_679Yeivj-a7l6bHs_ahWiKl1KoX_hU_" //when test, _, err := Decode(token, shaKey) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeHS512(c *C) { //given token := "eyJhbGciOiJIUzUxMiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.9KirTNe8IRwFCBLjO8BZuXf3U2ZVagdsg7F9ZsvMwG3FuqY9W0vqwjzPOjLqPN-GkjPm6C3qWPnINhpr5bEDJQ" //when test, _, err := Decode(token, shaKey) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestEncodePlaintext(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, NONE, nil) fmt.Printf("\nnone = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJub25lIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.") //make sure we consistent with ourselfs t, _, _ := Decode(test, nil) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeHS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, HS256, shaKey) fmt.Printf("\nHS256 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJIUzI1NiJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.UAuHfK1tObqUzQj2tdMoKjKq1SWoI17hAg17VJ2l8j0") //make sure we consistent with ourselfs t, _, _ := Decode(test, shaKey) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeHS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, HS384, shaKey) fmt.Printf("\nHS384 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJIUzM4NCJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.c92ouMmuQ1EmFN6IQmCEKAv5JZoVIeo_ehQl79OskFw3_y5GE_OLiUEfcRikturb") //make sure we consistent with ourselfs t, _, _ := Decode(test, shaKey) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeHS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, HS512, shaKey) fmt.Printf("\nHS512 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJIUzUxMiJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.tfZJJbT-Nht5_JkM0vylscOSwiuf9-X7mcBdxTIB_fdHBC-LylKQGPWLqjzDWFnx29f7U_s9c4EjA3WUahib7w") //make sure we consistent with ourselfs t, _, _ := Decode(test, shaKey) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecodeRS256(c *C) { //given token := "eyJhbGciOiJSUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.NL_dfVpZkhNn4bZpCyMq5TmnXbT4yiyecuB6Kax_lV8Yq2dG8wLfea-T4UKnrjLOwxlbwLwuKzffWcnWv3LVAWfeBxhGTa0c4_0TX_wzLnsgLuU6s9M2GBkAIuSMHY6UTFumJlEeRBeiqZNrlqvmAzQ9ppJHfWWkW4stcgLCLMAZbTqvRSppC1SMxnvPXnZSWn_Fk_q3oGKWw6Nf0-j-aOhK0S0Lcr0PV69ZE4xBYM9PUS1MpMe2zF5J3Tqlc1VBcJ94fjDj1F7y8twmMT3H1PI9RozO-21R0SiXZ_a93fxhE_l_dj5drgOek7jUN9uBDjkXUwJPAyp9YPehrjyLdw" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeRS384(c *C) { //given token := "eyJhbGciOiJSUzM4NCIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.cOPca7YEOxnXVdIi7cJqfgRMmDFPCrZG1M7WCJ23U57rAWvCTaQgEFdLjs7aeRAPY5Su_MVWV7YixcawKKYOGVG9eMmjdGiKHVoRcfjwVywGIb-nuD1IBzGesrQe7mFQrcWKtYD9FurjCY1WuI2FzGPp5YhW5Zf4TwmBvOKz6j2D1vOFfGsogzAyH4lqaMpkHpUAXddQxzu8rmFhZ54Rg4T-jMGVlsdrlAAlGA-fdRZ-V3F2PJjHQYUcyS6n1ULcy6ljEOgT5fY-_8DDLLpI8jAIdIhcHUAynuwvvnDr9bJ4xIy4olFRqcUQIHbcb5-WDeWul_cSGzTJdxDZsnDuvg" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeRS512(c *C) { //given token := "eyJhbGciOiJSUzUxMiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.KP_mwCVRIxcF6ErdrzNcXZQDFGcL-Hlyocc4tIl3tJfzSfc7rz7qOLPjHpZ6UFH1ncd5TlpRc1B_pgvY-l0BNtx_s7n_QA55X4c1oeD8csrIoXQ6A6mtvdVGoSlGu2JnP6N2aqlDmlcefKqjl_Z-8nwDMGTMkDNhHKfHlIb2_Dliwxeq8LmNMREEdvNH2XVp_ffxBjiaKv2Eqbwc6I17241GCEmjDCvnagSgjX_5uu-da2H7TK2gtPJYUo8r9nzC7uzZJ5SB8suZH0COSofsP-9wvH0FESO40evCyEBylqg3bh9M9dIzeq8_bdTiC5kG93Fal44OEY8_Zm88wB_VjQ" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestEncodeRS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, RS256, PrivKey()) fmt.Printf("\nRS256 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJSUzI1NiJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.fLVmWBDvVKZZPKNAaGrSitQpRGLoku1JPDafaTJhQUjfvrgvu8_RgTO4WmwQVngbAdT0i57EXt28WZHpAdBEJK4wi6sVzRADxO3aSiAxZn_aY_QwH7B4CGeeCvdvjUBX-wNj-4S3F9xCygq2VGtl8PknzAJLtcPmG9V-2hEfyLeL8lcOgK6SGaWWoGC5PjvVW46ilYSbySCr2c3B86TPITcx29_g4juuAM_AtHUdGimOVX1eKyHKSB8_U2IXWc2ujMMgphc0eZNY0W2nl_MwEwq-SvcdyLGfWVuEhgmfqlRHXu5eztHZsw1ejki0J-9r9reG1FbV6GzTMsU9HARW_Q") //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeRS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, RS384, PrivKey()) fmt.Printf("\nRS384 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJSUzM4NCJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.BqDcZoC0pWa1k_gFRRSOJnDrU_0c78SdRphUikML36JrZs6fVwcP2NtdVUpDl40CwRdeHFjJF9skXI0KmMbj2bRTFyxL-At8WOVAMVRY0N9jFOjK67nwdafSDCKBqPAjw-Vv1f9yKwNvDoObI2isvhKqTF_EK_wEj-AwQIsmJNqUNF3yD3IgB6PCLS8mW5zXEp6xwf8hMguco6aHV7WBU-ZhdMFjJRydyrwBinUFig68QCdcAUI7KFVbsjani4W87jHgJhinv2GyVyKw5QpIDdvcMQKeoTZWLKQg9BBW4Ar9-YhQIuuO-7chTn2KCMpFCq3hrdrZTqVtX1nEDvBYpA") //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeRS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, RS512, PrivKey()) fmt.Printf("\nRS512 = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJSUzUxMiJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.AqwiRtgwP0th1K8mvmL1oW8bbf8EuqDiUGLIfSQLY7Z9eXzct3Zcd3diri_-v6WczQWKtQ-NipCSEl8CWJQSZY8cRqDhFjiDnLEImY5SzC-xqYxDVb5zu_iQZNd18nlmSw504W3IvxIwk1_avZ6Q12OvRNbG3gLGZtcWi3VLdTa-SGEemEicnlRfLpTAaCk3kkJq6St5NLbiVdQMpfhDBeGCOTFMptLZ6Tw1rWaHy6y5b7_PRwWG1Cb8QEl8du-dxmhDgbenreq5EiybOL05qZRFxJ-1861j5xduG-AY6xum6HtWKPGTSsIZNxepK3DTYfovN5HidcubV747w_6PXw") //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecodePS256(c *C) { //given token := "eyJhbGciOiJQUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.S9xuR-IGfXEj5qsHcMtK-jcj1lezvVstw1AISp8dEQVRNgwOMZhUQnSCx9i1CA-pMucxR-lv4e7zd6h3cYCfMnyv7iuxraxNiNAgREhOT-bkBCZMNgb5t15xEtDSJ3MuBlK3YBtXyVcDDIdKH_Bwj-u363y6LuvZ8FEOGmIK5WSFi18Xjg-ihhvH1C6UzH1G82wrRbX6DyJKqrUnHAg8yzUJVP1AdgjWRt5BKpuYbXSib-MKZZkaE4q_hCb-j25xCzn8Ez8a7PO7p0fDGvZuOk_yzSfvXSavg7iE0GLuUTNv3nQ_xW-rfbrpYeyXNtstoK3JPFpdtORTyH1iIh7VVA" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodePS384(c *C) { //given token := "eyJhbGciOiJQUzM4NCIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.EKqVLw6nLGNt1h7KNFZbzkKhf788VBYCfnigYc0dBZBa64MrfbIFHtJuFgIGkCVSDYH-qs-i4w9ke6mD8mxTZFniMgzFXXaCFIrv6QZeMbKh6VYtSEPp7l0B1zMZiQw6egZbZ6a8VBkCRipuZggSlUTg5tHMMTj_jNVxxlY4uUwXlz7vakpbqgXe19pCDJrzEoXE0cNKV13eRCNA1tXOHx0dFL7Jm9NUq7blvhJ8iTw1jMFzK8bV6g6L7GclHBMoJ3MIvRp71m6idir-QeW1KCUfVtBs3HRn3a822LW02vGqopSkaGdRzQZOI28136AMeW4679UXE852srA2v3mWHQ" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodePS512(c *C) { //given token := "eyJhbGciOiJQUzUxMiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.IvbnmxhKvM70C0n0grkF807wOQLyPOBwJOee-p7JHCQcSstNeml3Owdyw9C3HGHzOdK9db51yAkjJ2TCojxqHW4OR5Apna8tvafYgD2femn1V3GdkGj6ZvYdV3q4ldnmahVeO36vHYy5P0zFcEGU1_j3S3DwGmhw2ktZ4p5fLZ2up2qwhzlOjbtsQpWywHj7cLdeA32MLId9MTAPVGUHIZHw_W0xwjJRS6TgxD9vPQQnP70MY-q_2pVAhfRCM_pauPYO1XH5ldizrTvVr27q_-Uqtw-wV-UDUnyWYQUDDiMTpLBoX1EEXmsbvUGx0OH3yWEaNINoCsepgZvTKbiEQQ" //when test, _, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestEncodePS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, PS256, PrivKey()) fmt.Printf("\nPS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJQUzI1NiJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[1]), Equals, 24) //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodePS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, PS384, PrivKey()) fmt.Printf("\nPS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJQUzM4NCJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[1]), Equals, 24) //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodePS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, PS512, PrivKey()) fmt.Printf("\nPS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJQUzUxMiJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[1]), Equals, 24) //make sure we consistent with ourselfs t, _, _ := Decode(test, PubKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecodeES256(c *C) { //given token := "eyJhbGciOiJFUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.EVnmDMlz-oi05AQzts-R3aqWvaBlwVZddWkmaaHyMx5Phb2NSLgyI0kccpgjjAyo1S5KCB3LIMPfmxCX_obMKA" //when test, _, err := Decode(token, Ecc256Public()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeES384(c *C) { //given token := "eyJhbGciOiJFUzM4NCIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.jVTHd9T0fIQDJLNvAq3LPpgj_npXtWb64FfEK8Sm65Nr9q2goUWASrM9jv3h-71UrP4cBpM3on3yN--o6B-Tl6bscVUfpm1swPp94f7XD9VYLEjGMjQOaozr13iBZJCY" //when test, _, err := Decode(token, Ecc384Public()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecodeES512(c *C) { //given token := "eyJhbGciOiJFUzUxMiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.AHxJYFeTVpZmrfZsltpQKkkplmbkycQKFOFucD7hE4Sm3rCswUDi8hlSCfeYByugySYLFzogTQGk79PHP6vdl39sAUc9k2bhnv-NxRmJsN8ZxEx09qYKbc14qiNWZztLweQg0U-pU0DQ66rwJ0HikzSqgmyD1bJ6RxitJwceYLAovv0v" //when test, _, err := Decode(token, Ecc512Public()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestEncodeES256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, ES256, Ecc256Private()) fmt.Printf("\nES256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJFUzI1NiJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[2]), Equals, 86) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Public()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeES384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, ES384, Ecc384Private()) fmt.Printf("\nES384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJFUzM4NCJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[2]), Equals, 128) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc384Public()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncodeES512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, ES512, Ecc512Private()) fmt.Printf("\nES512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJFUzUxMiJ9") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[2]), Equals, 176) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc512Public()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_DIR_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..3lClLoerWhxIc811QXDLbg.iFd5MNk2eWDlW3hbq7vTFLPJlC0Od_MSyWGakEn5kfYbbPk7BM_SxUMptwcvDnZ5uBKwwPAYOsHIm5IjZ79LKZul9ZnOtJONRvxWLeS9WZiX4CghOLZL7dLypKn-mB22xsmSUbtizMuNSdgJwUCxEmms7vYOpL0Che-0_YrOu3NmBCLBiZzdWVtSSvYw6Ltzbch4OAaX2ye_IIemJoU1VnrdW0y-AjPgnAUA-GY7CAKJ70leS1LyjTW8H_ecB4sDCkLpxNOUsWZs3DN0vxxSQw.bxrZkcOeBgFAo3t0585ZdQ" //when test, _, err := Decode(token, aes256Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_DIR_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0..fX42Nn8ABHClA0UfbpkX_g.ClZzxQIzg40GpTETaLejGNhCN0mqSM1BNCIU5NldeF-hGS7_u_5uFsJoWK8BLCoWRtQ3cWIeaHgOa5njCftEK1AoHvechgNCQgme-fuF3f2v5DOphU-tveYzN-uvrUthS0LIrAYrwQW0c0DKcJZ-9vQmC__EzesZgUHiDB8SnoEROPTvJcsBKI4zhFT7wOgqnFS7P7_BQZj_UnbJkzTAiE5MURBBpCYR-OS3zn--QftbdGVJ2CWmwH3HuDO9-IE2IQ5cKYHnzSwu1vyME_SpZA.qd8ZGKzmOzzPhFV-Po8KgJ5jZb5xUQtU" //when test, _, err := Decode(token, aes384Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553372,"sub":"alice","nbf":1392552772,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"f81648e9-e9b3-4e37-a655-fcfacace0ef0","iat":1392552772}`) } func (s *TestSuite) TestDecrypt_DIR_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0..ZD93XtD7TOa2WMbqSuaY9g.1J5BAuxNRMWaw43s7hR82gqLiaZOHBmfD3_B9k4I2VIDKzS9oEF_NS2o7UIBa6t_fWHU7vDm9lNAN4rqq7OvtCBHJpFk31dcruQHxwYKn5xNefG7YP-o6QtpyNioNWJpaSD5VRcRO5ufRrw2bu4_nOth00yJU5jjN3O3n9f-0ewrN2UXDJIbZM-NiSuEDEgOVHImQXoOtOQd0BuaDx6xTJydw_rW5-_wtiOH2k-3YGlibfOWNu51kApGarRsAhhqKIPetYf5Mgmpv1bkUo6HJw.nVpOmg3Sxri0rh6nQXaIx5X0fBtCt7Kscg6c66NugHY" //when test, _, err := Decode(token, aes512Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553617,"sub":"alice","nbf":1392553017,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"029ea059-b8aa-44eb-a5ad-59458de678f8","iat":1392553017}`) } func (s *TestSuite) TestEncrypt_DIR_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A128CBC_HS256, aes256Key) fmt.Printf("\nDIR A128CBC-HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes256Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_DIR_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A192CBC_HS384, aes384Key) fmt.Printf("\nDIR A192CBC-HS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes384Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_DIR_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A256CBC_HS512, aes512Key) fmt.Printf("\nDIR A256CBC-HS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes512Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_DIR_A128GCM(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4R0NNIn0..yVi-LdQQngN0C5WS.1McwSmhZzAtmmLp9y-OdnJwaJFo1nj_4ashmzl2LhubGf0Jl1OTEVJzsHZb7bkup7cGTkuxh6Vfv10ljHsjWf_URXoxP3stQqQeViVcuPV0y2Q_WHYzTNGZpmHGe-hM6gjDhyZyvu3yeXGFSvfPQmp9pWVOgDjI4RC0MQ83rzzn-rRdnZkznWjbmOPxwPrR72Qng0BISsEwbkPn4oO8-vlHkVmPpuDTaYzCT2ZR5K9JnIU8d8QdxEAGb7-s8GEJ1yqtd_w._umbK59DAKA3O89h15VoKQ" //when test, _, err := Decode(token, aes128Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392548520,"sub":"alice","nbf":1392547920,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"0e659a67-1cd3-438b-8888-217e72951ec9","iat":1392547920}`) } func (s *TestSuite) TestDecrypt_DIR_A128GCM_WRONG_NONCE_SIZE(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4R0NNIn0..yVi-LQQngN0C5WS.1McwSmhZzAtmmLp9y-OdnJwaJFo1nj_4ashmzl2LhubGf0Jl1OTEVJzsHZb7bkup7cGTkuxh6Vfv10ljHsjWf_URXoxP3stQqQeViVcuPV0y2Q_WHYzTNGZpmHGe-hM6gjDhyZyvu3yeXGFSvfPQmp9pWVOgDjI4RC0MQ83rzzn-rRdnZkznWjbmOPxwPrR72Qng0BISsEwbkPn4oO8-vlHkVmPpuDTaYzCT2ZR5K9JnIU8d8QdxEAGb7-s8GEJ1yqtd_w._umbK59DAKA3O89h15VoKQ" //when _, _, err := Decode(token, aes128Key) //then c.Assert(err, NotNil) } func (s *TestSuite) TestDecrypt_DIR_A192GCM(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTkyR0NNIn0..YW2WB0afVronbgSz.tfk1VADGjBnViYD7He5mbhxpbogoT1cmhKiDKzzoBV2AxfsgJ2Eq-vtEqPi9eY9H52FLLtht26rc5fPz9ZKOUH2hYeFdaRyKYXlpEnUR2cCT9_3TYcaFhpYBH4HCa59NruKlJHMBqM2ssWZLSEblFX9srUHFtu2OQz2ydMy1fr8ABDTdVYgaqyBoYRGykTkEsgayEyfAMz9u095N2J0JTCB5Q0IiXNdBzBSxZXG-i9f5HFEb6IliaTwFTNFnhDL66O4rsg._dh02z25W7HA6b1XiFVpUw" //when test, _, err := Decode(token, aes192Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392552631,"sub":"alice","nbf":1392552031,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"a3fea096-2e96-4d8b-b7cd-070e08b533fb","iat":1392552031}`) } func (s *TestSuite) TestDecrypt_DIR_A256GCM(c *C) { //given token := "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0..Fmz3PLVfv-ySl4IJ.LMZpXMDoBIll5yuEs81Bws2-iUUaBSpucJPL-GtDKXkPhFpJmES2T136Vd8xzvp-3JW-fvpRZtlhluqGHjywPctol71Zuz9uFQjuejIU4axA_XiAy-BadbRUm1-25FRT30WtrrxKltSkulmIS5N-Nsi_zmCz5xicB1ZnzneRXGaXY4B444_IHxGBIS_wdurPAN0OEGw4xIi2DAD1Ikc99a90L7rUZfbHNg_iTBr-OshZqDbR6C5KhmMgk5KqDJEN8Ik-Yw.Jbk8ZmO901fqECYVPKOAzg" //when test, _, err := Decode(token, aes256Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392552841,"sub":"alice","nbf":1392552241,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"efdfc02f-945e-4e1f-85a6-9f240f6cf153","iat":1392552241}`) } func (s *TestSuite) TestEncrypt_DIR_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A128GCM, aes128Key) fmt.Printf("\nDIR A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4R0NNIn0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes128Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_DIR_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A192GCM, aes192Key) fmt.Printf("\nDIR A192GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTkyR0NNIn0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes192Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_DIR_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, DIR, A256GCM, aes256Key) fmt.Printf("\nDIR A256GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJkaXIiLCJlbmMiOiJBMjU2R0NNIn0") c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes256Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_RSA1_5_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.Pi1BtHrCnYfqXB0jr9lDuUoZf5yVZQKm940dNrhyEtcTg5R5Nw8NIPepVYM0Lt_BKdUs-g9iwZ4FwO0NHnaLOysqmLiOkey1gO2dBnDySISG4-SDEhkbBxVmAK-schPxXcC9hR0SpoI202h5o4jMrEvoxfiT-D5wq8iTJAiipVMA2QFO46ODuDLQOxuDTf57_z0W_5Qg-LYce7C8_nyhpGnhqkONEAwFBVwX0gPX08bui7fxs2LctvB3YZLJ5o4QDb0dRJ9HjDJ6YMiuPt9lgH4a4TScD3wZFmeksZYnNiMHPsfL-xDexbabQb2WB0CEleRXCBAcoGYQdXy-cCr4Vg.S8T50xGdXg_PzORit9s3Hg.vtHSEqDBKRiLpmO3CVzANMNu0dKcm0r1VJ-3YkZD8LEEGx4K29Scq7hMKC1XgBUYkcY0F1e7itItEvpWvwXkNAzP8YPEj8-p_wHgrqSn0Z4x_8626vKxLjlOK30uleq_pJTc4lwjG5VTRW9ax1Jy8rVu6x464e9vwfjzdFdEcDMtfM2MYrhM9XFHqaJNRmUAqd0GKepvoPVQSOw3tVxeqblCEgpZt8CEHpKpNPQkzOiaF3Ec7a8Garm7FE0zI69qVh94-ViBp7_1uxxHw-AnSg.JVC_j28xJiA0iQOhL86v7w" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408349987,\"sub\":\"alice\",\"nbf\":1408349387,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"e82d6f67-e3ed-4a1b-9f29-114575c37e6d\",\"iat\":1408349387}") } func (s *TestSuite) TestDecrypt_RSA1_5_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0.ApUpt1SGilnXuqvFSHdTV0K9QKSf0P6wEEOTrAqWMwyEOLlyb6VR8o6fdd4wXMTkkL5Bp9BH1x0oibTrVwVa50rxbPDlRJQe0yvBm0w02nkzl3Tt4fE3sGjEXGgI8w8ZxSVAN0EkaXLqzsG1rQ631ptzqyNzg9BWfy53cHhuzh9w00ZOXZtNc7GFBQ1LRvhK1EyLS2_my8KD091KwsjvXC-_J0eOp2W8NkycP_jCIrUzAOSwz--NZyRXt9V2o609HGItKajHplbE1PJVShaXO84MdJl3X6ef8ZXz7mCP3dRlsYfK-tlnFVeEKwC1Oy_zdFsdiY4j41Mj3usvG2j7xQ.GY4Em2zkSGMZsDLNr9pnDw.GZYJSpeQHmOtx34dk4WxEPCnt7l8R5oLKd3IyoMYbjZrWRtomyTufOKfiOVT-nY9ad0Vs5w5Imr2ysy6DnkAFoOnINV_Bzq1hQU4oFfUd_9bFfHZvGuW9H-NTUVBLDhok6NHosSBaY8xLdwHL_GiztRsX_rU4I88bmWBIFiu8T_IRskrX_kSKQ_iGpIJiDy5psIxY4il9dPihLJhcI_JqysW0pIMHB9ij_JSrCnVPs4ngXBHrQoxeDv3HiHFTGXziZ8k79LZ9LywanzC0-ZC5Q.1cmUwl7MnFl__CS9Y__a8t5aVyI9IKOY" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1391196668,\"sub\":\"alice\",\"nbf\":1391196068,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"c9d44ff8-ff1e-4490-8454-941e45766152\",\"iat\":1391196068}") } func (s *TestSuite) TestDecrypt_RSA1_5_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.NPxfy2Oscg5bA_7pPpc8NCa_CpAu0DWCo8JHrr5acLQ4Fcn1veO0MucNLdHHXlTcolSudxLpjulfmTxafUIw0O1_rz9omsB577f3B0DA_ovnABLwIf1YUJTE-pPCn1qVU2noaWhq0OEnmzB3aJaDp1pp1Lb3UHt-X9dbXDD2zluiSyt4wAjLp7JJLPfNdypps0UwOjGPRG009C7Kbb3Gnx1YOSd_xVuRDf_CqwwF5-VoAQxbLxDU-38aCZL7VjMgiDDXs56SX2bqnpvW1Q_58wTA-7LIpiP4vk8th2jpg59W9k0vixAqszWeiw1nqVOJ5qZgusss-MXYlPHZGmWFpg.uo4pnWhJEa8Cd496i1aS8Q.buM4urwbq330U7HUM2uNExvhBHxneqy4MnU1_g3ar5aTiH0dOsKD2J8jJJPt3k2BTPOOm8YZh36M7sm5TUTdp2Suc9UyMeV-HgL5-DPGGPFaG-Kk1ZjZPBpGwf-RmpSq9yUhINx5TO3XoX1rXyJcNi8_3l1B3R5Fv3Kjl-cihbTejHz_q2IPQwDZJTaTIlmtkrflTN07aZ9Y_KFLc2qjG6KdP2CM-I1-Oq-gc-H0EdoBLj1zGvAwoPpPdviO8C8n4VBb80RV8ED-wt8J2JVc3A.6bGm8EKBxcyMvFcWXr5G1ziCD0e1Pv1TP0YOze11vZc" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408349987,\"sub\":\"alice\",\"nbf\":1408349387,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"f6d4b905-3382-4207-be7a-611461e06c3d\",\"iat\":1408349387}") } func (s *TestSuite) TestDecrypt_RSA1_5_A128GCM(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4R0NNIn0.SLM4JN2t0JHYBXQr2uJ-K3QHW4SRCWPTPL-Czo-9IJQWgBbIlBXjrXOpQ-HtLg3OeKlXGz4AIihdHpFRSpPAq-e4ht8O5DSK-O6qyl8_-PSJfinZCMeLLE9Q1L6qHY86Rv9NMFeVUZZVmBPIXUTer-jU4tAgi3Upwek0M_gMwzeH94FEhHQqCzdYsBfsqwHpuRcrjatdjxBoSBXIEvNg8fi31UYG5L6jEUt2evOVFYq1C0-R17wydC71-2ubb35xXKbsNt5pShiil0sDalLTkuVKMtDuuMWZeMWHPp81wGJSHj9Ctl_ISHHjPC99MbGq9ZXSOBX2DNbfVmUMVRfHcQ.bbsRwjtVRyEeovfu.jGoxrc-CRwigy9IXs6NwKUR2zMZL2gcj_qhEmZAL1uqhkusA4zcCvVNrt2hFL3ZprN7pjpJ0Nm56MngNgTWQZkxwt_oz-Dk7IHmemEkC3m2Xboyy9ZvfesHvJlZEs6xMmxM-7TEQrb7_FP0lR_wZVoIuMQUHl6rwxofjtPNdABzxDQyaW-PU7aOSGNO-Eg8lBGFJZFWTcpwOwsYZhSdHhtc4PnUmzfkwDMWdOAXwey4bRXih6D0LuQZZbVlsYOSZq3dpTg.Igb39yvfNHPGPVryD5a3WA" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408349988,\"sub\":\"alice\",\"nbf\":1408349388,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"e7c97c7a-418c-440d-b3de-6f9ddc5d8f71\",\"iat\":1408349388}") } func (s *TestSuite) TestDecrypt_RSA1_5_A192GCM(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTkyR0NNIn0.pqD1m66UeNppuOnP_H0WBQB3PCgYN0Zzf1DZraXM8XUJapw4LrwhvUXlYwcgrFdZ4v-asmzvABPc2sbGxzIJsPebGoEIlFDV3OvRRN1vUBOdst99v4q9En21FLa1MwNvCoDeg-TLK54t-NPShmsb4cLWFGS8KAKj2HEqXStw18Di4PTEfFfiJpeBUF8UHgqXfs5vqSJKmtvHPBNGUpCOPEhuNDOOKXvxMQotjoktKCyffJSgtr1fy0rOO4iR4EJjozclIAPVDCfQMVfVZBJEbUfszZ6cOCVsPLZKY3msWo3CFOQOcvXJOjkp0IXCaQxrvofetgmHP_ILsf4ty7_UIA.oIicSl5B8tBykEB-.Xlb-OZBpOdDfTEIjtYDFIm40CJeolfC7C4t2qgqi3Gd4kk-5oEbQzNuFMp8M4eUyDsSvNXdN5mlrOwAj9KsSLWB5FZf51Nvk5YJFN9scaQmdSzU7AlLhM2yMEpOmzZMo1GsiZxD8Rle0LyWmgFtMpGJk3PTEXwYnmNyyDAxhFAaWU2WOc1KofQsPbOjTA_0ijpVHG2FO-8jMPWNvl5GbZPAeId1yYt_mhTXbg6M7VRgazWQsq0n0IK8C3r0hu0UZ0DL0fg.xG8T-AWjAokmvAmBw-tiDA" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408349988,\"sub\":\"alice\",\"nbf\":1408349388,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"0c8db172-5795-4033-badf-2e95fb8a24ac\",\"iat\":1408349388}") } func (s *TestSuite) TestDecrypt_RSA1_5_A256GCM(c *C) { //given token := "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMjU2R0NNIn0.atdPJ2O-zpVFKyT1_EY0OT8WfF78A6fgYabEtGUUg1KrlR-dDat8tAtj58__lu4TFrZ_J0kcWNVkPpRy0IiyCxKtuo2Gfeufiq0MCiOza0XjT87RJinvAQMJU5rjfOC9bnCgEmDdaePRYr2zbnq7cBU6xh4q9sUT6jDhOSQ49aXDZdzIsMz4lwHpEtUwpF8vFuK7CP1AyibVrrCp1PoVyx4kpT7sRP0V3cRrZutO1MGlI3BWHdFCO2Ak0PDtlqx5uh1atB4XlTD0nswLMoKRSSOuP4GviZFoX4v7REFVcNbuIVQz0bbszYSmJXNi0VBGSodrsM2Ok0ufXRxYWaBepg.hSe2EnGM-0CFZzy-.jplzmtN7z5cARKj9kpgFFUD2_4qpFyvfn4F2kUXEkgRSgRN7ej8S0GepH2qOksS0yrwD97NdVA-hqhD7EiixVHaBhyxT9hYMdJLmPygfiXG7WKvLuDR24zVUvD8q98b1lSP55JPKEIBj_y1YVmrybv_dl30wqt4cbDLhmqWScwJRSp53KX26F8-R903Zitr5dke_6G8wMcJTrszus0EDxsurSPkxkDlBmDl6h-J0XNgY7dzB4tXud8q7l6XPvbvSbNBpqg.4ppwz1DXn7ba80wmEKAwaQ" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408349988,\"sub\":\"alice\",\"nbf\":1408349388,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"0b2f4ddf-8ed0-45d5-9e25-973212099e97\",\"iat\":1408349388}") } func (s *TestSuite) TestEncrypt_RSA1_5_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A128CBC_HS256, PubKey()) fmt.Printf("\nRSA1_5 A128CBC-HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA1_5_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A192CBC_HS384, PubKey()) fmt.Printf("\nRSA1_5 A192CBC-HS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA1_5_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A256CBC_HS512, PubKey()) fmt.Printf("\nRSA1_5 A256CBC-HS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA1_5_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A128GCM, PubKey()) fmt.Printf("\nRSA1_5 A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4R0NNIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA1_5_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A192GCM, PubKey()) fmt.Printf("\nRSA1_5 A192GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTkyR0NNIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA1_5_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA1_5, A256GCM, PubKey()) fmt.Printf("\nRSA1_5 A256GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMjU2R0NNIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_RSA_OAEP_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhDQkMtSFMyNTYifQ.mlcD4YXAzTKgKsnkiPD8iBPkUkVijLCf9ODLs-ziHotR10iVPg2G2j1m-_BCgLB0SNWOcvkCTG1jzYJPr7ARs9GIBg63vtlqgk5TJhTko3J6TFwkrqMB_yeweuWvVvJ7R5CvlKRh_diUcB90RX1lPWSTx4wQHOjLssQ-xRG1iVZ2eroA1uhi8gW7Jdds2wmEnDqxfwmMaaK7IY6cpG_rUMYDqG3m9r3-B0j2MAYOtjGzPtwsJfTHsdasWz_pbypViOp35_BrUHRy6qfqR0uK3zfhe8sFfQDTDctMjissAUGo8rpqnVphoojjvxZVlkB2PmcctOzkAiaMusdOsAxhRg.yH5p6nQitVc9YxQJQP6ocw.XeHzeO9nlXJEmnKtEe_uyl72Aqyzje7Eiz96Zpz79Ot8udWPTmVpa902pGSEeLqHSmbvSpleGEGeuJP5HgOQ-VCrUd3FYL9PK88ieEwO2zsXZfGq4L-tVu7sgyYE8yz25dNRoMoXnrPRzv8dciq3XYxgIYeE0gMc9htVb42rXH7lXjbYeA1aCS2sjd-hRbh-5_afChrpDKYTavpd4EikOdz_-d7EddeUOnHmUsFBz6R6PVX4aOSUkIQug4RyXZLLaq0UkfBLfwezgO3t-dWY8Q.vjaIoaOKXR76eOuUZ1fang" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408354731,\"sub\":\"alice\",\"nbf\":1408354131,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"bda732e5-8cbd-4f9d-8205-9e05a77a1f90\",\"iat\":1408354131}") } func (s *TestSuite) TestDecrypt_RSA_OAEP_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExOTJDQkMtSFMzODQifQ.cT1VUi7KyfLuDL2JUVL5nVw7OcVUJTCwU2jPbIJVpPh2oR_89BYb4c5ff21A2F-69CqOgV-FD4zlmOkvjywiVq4BRlo8AO90qbe4dSDkIedXHTb0CM0o5HJCWPRNqlBfoPl8tTk7FFtCQyQIJmmTp88h8P4fEtHPe7v50oBjV6sVVdd0-vJa2Lp8id9ezKmlQ5IcgI6E3-81xIGfGvYERbtI7Tr-VQ8LjtylbgKPljfTtVQ_gn0UmbyLBIOUfQfLdpzF7Gdh9kfkEBy1nEnDuQ8V4BqkWfcb6yOWho_zSS4b9lj5qYisjo5KiOmsNNZcyl-EWbjq98k6gAKvAjWxlw.2yxe4VSlm_No0Ii5NTU3kQ.hN_a2DF0B02g7oBTs-Ft2_8nLPI1i6yzyys6a0TIjmfQZrzZTepORlQfHymBKwJOMDbThehvj4F3Yjjk_fziSN80eeuuvRdsi4wheH_jymcgoHJE1FCgpWpLKUfGlY9lMWeqaeL047W-qPdAmUDLUIiIsA4qguX55aPHFPQyjATg0-XaM1IfLySTxCNwV9Ha6FRtxBT01L9T2hbpucu708HgHCvdXn2jzOIC_Zs7SMdb3BbVeUaAyIobU6jDNd3WrgZxwUW0S0LZhovYip-sYg.xneenkPzCRAUQGO8G4YJMGNGYZzqjKoo" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408439204,\"sub\":\"alice\",\"nbf\":1408438604,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"1d22fd82-84b5-4b24-96db-c13e41097a9f\",\"iat\":1408438604}") } func (s *TestSuite) TestDecrypt_RSA_OAEP_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZDQkMtSFM1MTIifQ.JY7V0pIV5tFYju-WcdfO-KxYdV-d2tjKyuXnq3HwVjQLqttlwnbcxAtUApRuc1UuB6dqp8ggc9d3kgTTZVIveT5MaP57Jm6kU33puHxdujiz0CEFBpf0IWHetq175iFfZWFgAp4BWIK-FaG7_mbinSlNmSxZ4KOM8vgkfvfXQcPwBfsrehsxWRS6BIpJ2PKjOr61z0ry5s19pcMKWzrO-ygtDsusj9ioqH8H0ZahG323um-OtxIw1eVdBsa7rBg8n3zE-Lowgog6wZBOuIzN8bMdRVk5Y08xZRLxmcazJB5aMBB-sVZ5X695ACYTdG55oDpAet5uwyOJybkHF9MSRg.kiHWbMnhKCrSkjOXoIKpAw.xx44_UzBGn_kGOSPZI6QXQTGKq8OFHKyGM1ALZhk51UoiQQe6YzrtwHZcufT3yO0oFcw6TshkdyjKvwXecmSf-LOlUkgaR9o9zQ3PtcFLtgfHdTKBRDBEiubLHMOUTuHCi8laveJ0-RYuYcpwOnSCS_6hPoO86p3aAYzZOmJ3mFLgKQxdt7tgqV7DeRt3j9FyRXmS7vusA7g2oDJz-f7aRs0hWjtPiDN3TGwByacn6T_nlPCvTs6ZR-y9BVNYTaGCJEgujbXebtae_Y94_XZ3g.H2v7BssosabkZEEIk72pFhyYR5VUjQ9EEyQVtFyVvg8" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408439204,\"sub\":\"alice\",\"nbf\":1408438604,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"ccb36bb8-7fe2-43b7-93ba-63c9331d0f47\",\"iat\":1408438604}") } func (s *TestSuite) TestDecrypt_RSA_OAEP_A128GCM(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ.Prr8uxpkVLvASjHK4n_TKrMNQWx9cMN4_t1FIMhXXW9aRD4uLXLTmTasspvbprwPbR47qkCu_KcHC6p5eBpZZIW0Ja96OyQLycnhZkueyelqxeGKYMuHEPQ-cAxoe1Vf47bNYBK-9J9G9cHBjngsISlgoxv2K8AjDnAvwlKRqz1Rjg_zdM6nVpFwrWMNEBg5M8HdLR_P0S_z8S9spOsOCWl_2hybwkmuViXdprwXBVdm7TItuhw0NZVP88FzIO7F3C23788bf4JU_6I7KECuWG9uNoPfORZjNGYCIvFWJvq3Adyk3r3DuQwiWc6tE2vHcMj9f7yFxWqWUsxWOtmfuA.sMJK64MRl7g4A_Qr.D3OvvJkI_D569j6G7o8l54iJUOZ36iqge7wvNkBGP0SksZEwhBB7HOJVH8avWY-CpA6Lhh_FZvvA3phgVIQRTMSzc3pXMnirXh0qGBSvdi4OKJsUKWC0dugGY1j5sgV8mEowepg3iUM_j9WS3FW1mSh65IBlyEsLL6eUiYQepeN4vr4cN3jn-vORYVu-KaRyAnab4IJgzhhyRD48_B9w9_dffcuN4_xXPc-O0IvBsFkJTtPRvWGJFkv0r-JMXJR-BZqBrg.pd51_IhdN5YRuzCB6XIHvw" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408439204,\"sub\":\"alice\",\"nbf\":1408438604,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"3c039563-1d18-48df-8008-d113ac43cf2f\",\"iat\":1408438604}") } func (s *TestSuite) TestDecrypt_RSA_OAEP_A192GCM(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExOTJHQ00ifQ.IuvEhYtqW3TXDfc44FyXtMgWL0urYpZktuo989Y0MhusaZjTsaIRnsl2wyaRUim6vfuRE5Svtfm98UYC5zKx_FOq9CTElI7t9Q3QdvimiIbswaWCA2LKx6aiJxA2eCEhVRMUlDDe49V1HY2_zOiPN87qE-P-htRdxSBuQCDplJ7t8agp9VPM73pRAxt9gGvmlXzdGbCpR1HXhIDK14urfcuEF31w5jk0LOR2TIyt8VBWEYMdFnHpYKAQN3KQrF6yNow7AC0jIgcBM4ep41F5d9gkVp2jZWUsRT1Epgv0UcHC0t6BDArLT6Gy2xemTbs81qmARO5v4iyBRBaIuSehuw.F7NhQ3VzsCGfpRI2.jQZz-Kc6n5jUZzPTdjlbnVk-ujFpTNTsEa3J3L222eLg6cPQ6WQH9kmnoSW9WJXbun1ZFBSESv6ti3fKxEUPqs4vwy8d5JIrjrhXcw8lf2AWfFytX92U-ZqSGaoiqGjp0AHnuCqpNnBvCk2-vIHTAabWnpdGvIszVnodEF299CHDgHS9XIerZTGkQCZrRaH89koVfsO__pXnXcjy5loOV9D3ACfj3bIVRUdmg8P1mvyZfNdDErCMuu1G1TK6yaqpcDbrOg.WwWMv-v1Czh67ltSsbI0-A" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408439204,\"sub\":\"alice\",\"nbf\":1408438604,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"49ea8e2e-5de8-4fdf-a3d8-f8cd348c1289\",\"iat\":1408438604}") } func (s *TestSuite) TestDecrypt_RSA_OAEP_A256GCM(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ.ClRqSlrZ-3uqe5g4iiAtg3KKqFY_28sFgAh_u-_jUDwU7JBtvDazKRMK0guPqXq0pImb-bCDA6QZhzWgrrz9RGOMEJOVmq_JFl2SF-ipTz6Xj8nDAfqDnYbxj2XRdqMdgdu0BM7xXIpc5GbXuutPFcu9aVxyafv5G4JQo5qCx9Yvo-zVuLUvdOom_cIHwkWK3bx4EPBifIPdPfTQXt8yCXdF36CpT_mmbc13Fe-Uw8JgWtoLQ2nfbXjIEsSgr8BZdxfhiCFYAIyHQ2CdSzEh6J34NtF50u0DVOnkSjAMGiukB0k1fW469EutkfrZJIvo_19Qk8n5Eif7gW1WUw9u9w.rmBi9peixHbDA8cX.o5Xt4SHLSKCYX28u4_rArpfC3KgWwiIcWQMZM1YJPrqX2hRvGqg8Tcl80vXEV-mfNntao0QCPA7hsz4gaoHKLTh1nU1ucY9UGICkwgv9D2q3soOwYRlKP1PuDrh6LQPcPcn2yoSMXTjFhcgPlNGEE-mFipQEnMB5Cn47fcXxpJrWyXSo_FHuOWB1_mfSs1n-HMIDE7Wrxtegp0VNU8AFMEIeQj3pDupZhPrvHzwwRKcfyXhccyYDdfAPrL4xkqFs5en_fw.z8Oazv9h_rLZyI0wQx-QiQ" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1408439204,\"sub\":\"alice\",\"nbf\":1408438604,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"7b032524-9b59-4469-b92a-fdf25f2c5a7c\",\"iat\":1408438604}") } func (s *TestSuite) TestEncrypt_RSA_OAEP_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A128CBC_HS256, PubKey()) fmt.Printf("\nRSA-OAEP A128CBC-HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhDQkMtSFMyNTYifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A192CBC_HS384, PubKey()) fmt.Printf("\nRSA-OAEP A192CBC-HS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExOTJDQkMtSFMzODQifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A256CBC_HS512, PubKey()) fmt.Printf("\nRSA-OAEP A256CBC-HS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZDQkMtSFM1MTIifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A128GCM, PubKey()) fmt.Printf("\nRSA-OAEP A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExMjhHQ00ifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A192GCM, PubKey()) fmt.Printf("\nRSA-OAEP A192GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkExOTJHQ00ifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A256GCM, PubKey()) fmt.Printf("\nRSA-OAEP A256GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_A128KW_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.DPRoUHQ3Ac8duyD32nUNH3eNUKzUIMYgEdf5GwJ8rW4MYQdl2PCIHA.B1dR6t93aUPcFC1c1aUjeA.lHPKTK0ehgzq70_Ihdh-svI2icUa9usgqP8sF5j50fsQAGizITZpTTXKOKd9-GSEVmJo07551hq9xscZj4vXsDEx-z-akxg0nlL5fFE24km7l4T3LfAeG17gmrMcJuLP55mFUg-F98j9duV2UCyKJPXP6RwOQ5X17VNw29c4k-_AxYM0EjTv3Fww1o3AGuVa07PfpLWE-GdJeJF9RLgaP_6Pua_mdVJud77bYXOsVxsweVtKIaBeLswMUUSU6PoC5oYURP_ybW76GOCjmgXpjA.avU8f5LK_tbJOyKW6-fRnw" //when test, _, err := Decode(token, aes128Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestDecrypt_A192KW_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJBMTkyS1ciLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0.OLwgc7EaQdvsf54GfU69qH143C79H_eETvM_yGBgJzEB5367k9tbw6qW4TlQ56GMj__5QDJBvAg.BvYY_v4_dxxsK4M8A0T_TA.V0jBe7o-OahMkqGDgWW0Lxq1eTKPJYix7hjKmmqaKlhdVcnT0cdOU0ahdg82Ls-Vg_NaWKas8MhahHspz18Gx2abDSwLIKbU0jcaf0LxWZkEuMmFJs5dodq0ZqQeaEldDsHe9De_V_TQwPFkcMOPYqWhx2XEb13bmFTPtxNST18Cwm_j263Y_Ouz2YNyC4uZENZDWeOXfJLy7c8jt_ToOvXEVpXj7oZN7Ik1S9bGAenTcvUDORP-gdFdJ3stLe9FmKulOlb94Y-KvP_meyIZ7Q.XPPqS5YVJu2utJcAIRTUxlBHlECGRaM5" //when test, _, err := Decode(token, aes192Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestDecrypt_A256KW_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.91z9VM1VLIA_qyTbqeInFoit7c4PWVuQ5mHcDyNsfofDGXS1qUDdPCWRdLC8ybvJflqHej7SCjEUMxuzOtPOUOgo-8rcdeHi.rsx7FYNTunzditC8XTMJXg.k88BLb0qs8g0UnKjSq9rs2PcrhpafEaUEX2kT-wMdmviZ9UEJrECoQY7MmJgCyQYO30hnnay2psJcr_yaDhV-NpctBZ793Xf9tztLZZndIjz5omV9HjcFgheQZj4g1tbNcRLwxod5uYz-OLrKORzeROEM-wkLgHVEqs90wN98NAiyhGyVMw7CXVX5NdU2KFUacbflkJc5AcaiAZYAts1t9bo2877XLYSO1qBoI5k5QKv6ijjM8I03Uyr3H0p0tdF6EB-cdYNcxq68GvA5CTkOw.DBtOuSJTFu5AAIdcgymUR-JflpwfcXJ2AnZU8LNB3UA" //when test, _, err := Decode(token, aes256Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestDecrypt_A128KW_A128GCM(c *C) { //given token := "eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4R0NNIn0.T3p7Vi-P6jVWrvJIF3MYx6lyNtJOeFmL.IVVKIDU6Nlty559s.xFMzgqiPec95flp57O_TUrF8vDcZIz4zVMrnCQZSnGlLyS464A-whc7ORehjL-U8JLIHmnrD89GzXzC0h-0QG5x1QKv6_MzyeuGMvv4WQLapWtjhfU4s0xSyRswKPAKrjPWzBCi39OjIP0DDTjSmfTiQ6OsDf772Xy3RaZ5FmHHiwzhAs4X3J5foCKEZQXrMrE_H4y0f5eey_B5y_XrYjn2jlOHcBydSCW-cUi9q7f3WTQzlHgEzZMcGSg7imIuoSz6IQQ.xIRG_a_6eMNN4aBneKviEw" //when test, _, err := Decode(token, aes128Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestDecrypt_A192KW_A192GCM(c *C) { //given token := "eyJhbGciOiJBMTkyS1ciLCJlbmMiOiJBMTkyR0NNIn0.Rd2X_AyKle5d8IO4MQCxJ7WFiVTjzlQ-sDTpOU7dllk.i6-U-bPS1XU87QLu.vJ7Dgh1OhBjniKDOCzLNHsSvZBb6lyDZsIr2v3br6Zp7xhxhq8Cjwmyd2FGqMKpMtSzdg1Y7QSLH3qIfijjp7lH8AxSvCsE2PZTFUJKjCbYtWWmsa6WCA4LIJU8IHBGr0DVQIRh-77ru1cy5xFWGiU7yJMpZpQ62MvluqBSFNYYmzfy5BwXqYMf8n0P2BhxRl4SxvsOoyi7JZvzfCCMixPJm50u65aak83NEIInqN-76AkekWOP4KY57HyKSYs3Fk7lUgw.rN3AZ46DWMtVZa42lnnIHg" //when test, _, err := Decode(token, aes192Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestDecrypt_A256KW_A256GCM(c *C) { //given token := "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2R0NNIn0.LY3h_i8x7z_Duc68B-DBrKrKqQpgBbiudtRzVkEPgEsASK1QO2ycVw.KOn1Sn5NOZNVFWje.-26uGTnqc72gaUg4GYEysV9P0lApakuMihLAp7MuWXM5Q267oOVjSd-YeFBvN94A8ZvhFPrNXRcALt3FDOVoEswYy9ryloJu-YbsPt_Gcpnvk8_6OJKDU6xKPWRMCCRDyP88hZ9sMGdV12bWqAQA7LZMGKa-KU0_DUeLeWVew_uoKmR1TqbWBw9_Cmqy5qFztP0zOTACzNQQb8xXij1EZfhPTBQXXDQc4tawGNysEif7SWtlDDQ0row38SsApFtU1saB5g.lPTSTfaMmpNbYp9Yg9YgpQ" //when test, _, err := Decode(token, aes256Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392553211,\"sub\":\"alice\",\"nbf\":1392552611,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"586dd129-a29f-49c8-9de7-454af1155e27\",\"iat\":1392552611}") } func (s *TestSuite) TestEncrypt_A128KW_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A128KW, A128CBC_HS256, aes128Key) fmt.Printf("\nA128KW A128CBC_HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0") c.Assert(len(parts[1]), Equals, 54) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes128Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A192KW_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A192KW, A192CBC_HS384, aes192Key) fmt.Printf("\nA192KW A192CBC_HS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMTkyS1ciLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0") c.Assert(len(parts[1]), Equals, 75) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes192Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A256KW_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A256KW, A256CBC_HS512, aes256Key) fmt.Printf("\nA256KW A256CBC_HS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0") c.Assert(len(parts[1]), Equals, 96) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes256Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A128KW_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A128KW, A128GCM, aes128Key) fmt.Printf("\nA128KW A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMTI4S1ciLCJlbmMiOiJBMTI4R0NNIn0") c.Assert(len(parts[1]), Equals, 32) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes128Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A192KW_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A192KW, A192GCM, aes192Key) fmt.Printf("\nA192KW A192GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMTkyS1ciLCJlbmMiOiJBMTkyR0NNIn0") c.Assert(len(parts[1]), Equals, 43) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes192Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A256KW_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A256KW, A256GCM, aes256Key) fmt.Printf("\nA256KW A256GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJBMjU2S1ciLCJlbmMiOiJBMjU2R0NNIn0") c.Assert(len(parts[1]), Equals, 54) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes256Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_A128GCMKW_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJBMTI4R0NNS1ciLCJlbmMiOiJBMTI4Q0JDLUhTMjU2IiwiaXYiOiJ1SDVxVThlN2JVZXhGYWh3IiwidGFnIjoiamdxc2czdHoyUGo0QmhEWU1xTnBrdyJ9.peAzKiVO3_w2tAlSzRZdqqQpnUSpgPDHi_xgTd6VzP4.o8bhvYO_UTkrsxQmm__nIg.MSmgetpjXHWMs0TyuGgmWd-msfbQ7oVWC4WuCJcfAsbhLU9kLDLrd0naL5f_UkWBaM04bfcc31K4FRN20IiUxcHzLnMR-lY-HkvRFWYdur-kLWw1UXjIlPOb0nqCuyd2FRpxMdSfFnYr5Us9T45cF7DdK8p4iA7KqPToMHWBsvAcET_ycMIoERqJrBuiJzh-j7UtDzH6KtUfgD4tzZAm3iM6HWT2lq25Pqsu4qf19LYXxZaMIiFwFKboeexkJ5E0hc7P-wIeknzFJaZhkb5P4g.dTQAed1znLHX4cO-VDgxeA" //when test, _, err := Decode(token, aes128Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_A128GCMKW_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJBMTI4R0NNS1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIiwiaXYiOiI5bUwxR1YzUUZIWGtVbEdUIiwidGFnIjoiU0xrTDVpdmhncy1HNjRBTS01bTBxdyJ9.S3_MudWEzKWCp8RRxIG5p6H2YOtMDCkOXXKM9J8J4lMX5N2CcUqsKkDQ4TE1rG7gD5qYgHsb8AiQFLbhjgDeAA.WiOHBPlws9hImQr6bZ8h5Q.jN9UbuvhTiS6uJi1jc0TsvpheXqHs8vdJzKOUVgFmVHZ_OG4vSNRLx408vSoAgSeqsRmj8C8i9Yi2R6kpgtRXZ-Rw7EQEjZ65kg2uwZuve1ObqK-uBm3UzDmcT_Jh6myp9Df1m28ng8ojfrY_JUz6oE5yEcJdlm7H8ahipJyznWOjFigOqhaiXosjW0kbGGpYE-njD5OX22vR5k0RxHlMCDAH2ONR69kaWbLQvDg7y4yMFSxi3ILUFSVz4uXo6qlb8RVCqMUWzlGho-5Cy9OPA.XQ0UmHH5btv14_km6CIlIUwzOFj-rQUYyEzF9VY0r70" //when test, _, err := Decode(token, aes128Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_A192GCMKW_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJBMTkyR0NNS1ciLCJlbmMiOiJBMTkyQ0JDLUhTMzg0IiwiaXYiOiJzRHRLdnRzZVk2UkFuU2twIiwidGFnIjoiZDFDS3dKWnlXSnlvcW5HTUFwbmR6dyJ9.2L9u7vV0P8bZddbkCKKe6_C5JTLf8wRZC8xzEe4gvmcGoF2K5AledhcqT6mIlaPx.1JY51r77jimrvKxts9EroQ.922BMD0HOscwZxn4pmYTRgV7oshegQ1dooU9njhonPcp46XbegdfsgeZAACVFpCc_CoY_XzOsM5trH1Z30QUDc7IGJmC0NKuPdK2KkrYQPXJAe6nuZMembGsyRkOHahtj7sew-ULZn9y0ztbntPqm5I9O716mv1Cu6_5_mBYu36c_VVd6jlzueUWun09yLDJLFuf5jRXDrqRrY4t6XIcqti8LF-QLowU_pa5DvRV_KzCtD_S8HvzJ217_TI9Y1qaApgvWr_BxDrfTXxO2xaZ2Q.0fnvCkg_ChWuf8F3KY8KUgbdIzifb_JT" //when test, _, err := Decode(token, aes192Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_A256GCMKW_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJBMjU2R0NNS1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIiwiaXYiOiJvUV9xbDNJUHNibEVPaDBXIiwidGFnIjoieTllMEFfY1hZMnNDZ24tamxsNl9TdyJ9.K5BxtxcV0simNM-69RvjZuNBjxaavDVnBzP7EFXSjbWZi3NjZFoTcFljcu2TuzR_F9zdjjBbohEgaf4kUMVZfg.881rEerOD33OLCHKdTWDjQ.LvrzsNicH2slBjwERYFu-Fr4Bus2lcLTdFazEpsHc_0QH4NJ2tGrJJjByli6OaFOwtdWONEu_3Ax8xvEXWHc0WMhYKxaVLZI1HQwE0NnWyqfF9mtOkUCCXn9ljvSGSDQY5VUcupVUT6WQxAkaNe6mJ6qkJOxE4pBpiMskO0luW5PkPexk2N3bJVz-GwzMp3xVT6wtFimThucZm2V71594NPCKIkA0HvtBkW0gW0M66pSTfQTHkU0Uvm7WfRvr6TXpiuKntJUe7RX5pXFXbfN2g.aW8OWGfHFI5zTGfFyKuqeLFT5o0tleSYbpCb7kAv1Bs" //when test, _, err := Decode(token, aes256Key) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestEncrypt_A128GCMKW_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A128GCMKW, A128CBC_HS256, aes128Key) fmt.Printf("\nA128GCMKW A128CBC_HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 128) c.Assert(len(parts[1]), Equals, 43) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes128Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A128GCMKW_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A128GCMKW, A256CBC_HS512, aes128Key) fmt.Printf("\nA128GCMKW A256CBC_HS512= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 128) c.Assert(len(parts[1]), Equals, 86) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes128Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A192GCMKW_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A192GCMKW, A192CBC_HS384, aes192Key) fmt.Printf("\nA192GCMKW A192CBC_HS384= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 128) c.Assert(len(parts[1]), Equals, 64) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes192Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_A256GCMKW_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, A256GCMKW, A256CBC_HS512, aes256Key) fmt.Printf("\nA256GCMKW A256CBC_HS512= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 128) c.Assert(len(parts[1]), Equals, 86) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, aes256Key) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_PBSE2_HS256_A128KW_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJQQkVTMi1IUzI1NitBMTI4S1ciLCJlbmMiOiJBMTI4Q0JDLUhTMjU2IiwicDJjIjo4MTkyLCJwMnMiOiJiMFlFVmxMemtaNW9UUjBMIn0.dhPAhJ9kmaEbP-02VtEoPOF2QSEYM5085V6zYt1U1qIlVNRcHTGDgQ.4QAAq0dVQT41dQKDG7dhRA.H9MgJmesbU1ow6GCa0lEMwv8A_sHvgaWKkaMcdoj_z6O8LaMSgquxA-G85R_5hEILnHUnFllNJ48oJY7VmAJw0BQW73dMnn58u161S6Ftq7Mjxxq7bcksWvFTVtG5RsqqYSol5BZz5xm8Fcj-y5BMYMvrsCyQhYdeGEHkAvwzRdvZ8pGMsU2XPzl6GqxGjjuRh2vApAeNrj6MwKuD-k6AR0MH46EiNkVCmMkd2w8CNAXjJe9z97zky93xbxlOLozaC3NBRO2Q4bmdGdRg5y4Ew.xNqRi0ouQd7uo5UrPraedg" //when test, _, err := Decode(token, "top secret") //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_PBSE2_HS384_A192KW_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJQQkVTMi1IUzM4NCtBMTkyS1ciLCJlbmMiOiJBMTkyQ0JDLUhTMzg0IiwicDJjIjo4MTkyLCJwMnMiOiIxZEdaODBpQTBqb3lGTzFqIn0.iElgf12HbQWt3enumKP_j3WDxGLfbwSePHYAbYEb_w3himk0swcdiTPo1Jm8MU7le7L_Z8rU2Uk.7LoW9-g7U8c3GNAYO3Z5Jw.guSjXuYN9deq6XIsbkbxAptU9Lp1jf9k11QdhsvjfUvaZRXKrWiE9vg3jEJRJnmF7lZq07cp2Ou8PztMg6R_ygT7gadmP_IYdgQwXD6HGQs__uzvFnqtjWALiwLWuL0V0INrKxBn3CivJ5Hg26nJwLACdVuO_k-fNTaphbox-nKefndS4UXaoe3hEuCzHFPgFivMlND4aZJb8pU8sQbGA29gx5U9qNBmWYOXwV2diYQ2q2SfUEbXoMV7uZyvfQ2juTcyqZBVnEfIYGf_8esALQ.QrgRr0TIlJDFkq2YWNXcoFoMpg4yMC6r" //when test, _, err := Decode(token, "top secret") //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_PBSE2_HS512_A256KW_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJQQkVTMi1IUzUxMitBMjU2S1ciLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIiwicDJjIjo4MTkyLCJwMnMiOiJCUlkxQ1M3VXNpaTZJNzhkIn0.ovjAL7yRnB_XdJbK8lAaUDRZ-CyVeio8f4pnqOt1FPj1PoQAdEX3S5x6DlzR8aqN_WR5LUwdqDSyUDYhSurnmq8VLfzd3AEe.YAjH6g_zekXJIlPN4Ooo5Q.tutaltxpeVyayXZ9pQovGXTWTf_GWWvtu25Jeg9jgoH0sUX9KCnL00A69e4GJR6EMxalmWsa45AItffbwjUBmwdyklC4ZbTgaovVRs-UwqsZFBO2fpEb7qLajjwra7o4OegzgXDD0jhrKrUusvRWGBvenvumb5euibUxmIfBUcVF1JbdfYxx7ztFeS-QKJpDkE00zyEkViq-QxfrMVl5p7LGmTz8hMrFL3LXLokypZSDgFBfsUzChJf3mlYzxiGaGUqhs7NksQJDoUYf6prPow.XwRVfVTTPogO74RnxZD_9Mse26fTSehna1pbWy4VHfY" //when test, _, err := Decode(token, "top secret") //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestEncrypt_PBSE2_HS256_A128KW_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, PBES2_HS256_A128KW, A128GCM, "top secret") fmt.Printf("\nPBES2-HS256+A128KW A128GCM= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 107) c.Assert(len(parts[1]), Equals, 32) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, "top secret") c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_PBSE2_HS384_A192KW_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, PBES2_HS384_A192KW, A192GCM, "top secret") fmt.Printf("\nPBES2-HS384+A192KW A192GCM= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 107) c.Assert(len(parts[1]), Equals, 43) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, "top secret") c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_PBSE2_HS512_A256KW_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, PBES2_HS512_A256KW, A256GCM, "top secret") fmt.Printf("\nPBES2-HS512+A256KW A256GCM= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 107) c.Assert(len(parts[1]), Equals, 54) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, "top secret") c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_PBSE2_HS256_A128KW_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, PBES2_HS256_A128KW, A256CBC_HS512, "top secret") fmt.Printf("\nPBES2-HS256+A128KW A256CBC_HS512= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 115) c.Assert(len(parts[1]), Equals, 96) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, "top secret") c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_ECDH_ES_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTIiwiZW5jIjoiQTEyOENCQy1IUzI1NiIsImVwayI6eyJrdHkiOiJFQyIsIngiOiItVk1LTG5NeW9IVHRGUlpGNnFXNndkRm5BN21KQkdiNzk4V3FVMFV3QVhZIiwieSI6ImhQQWNReTgzVS01Qjl1U21xbnNXcFZzbHVoZGJSZE1nbnZ0cGdmNVhXTjgiLCJjcnYiOiJQLTI1NiJ9fQ..UA3N2j-TbYKKD361AxlXUA.XxFur_nY1GauVp5W_KO2DEHfof5s7kUwvOgghiNNNmnB4Vxj5j8VRS8vMOb51nYy2wqmBb2gBf1IHDcKZdACkCOMqMIcpBvhyqbuKiZPLHiilwSgVV6ubIV88X0vK0C8ZPe5lEyRudbgFjdlTnf8TmsvuAsdtPn9dXwDjUR23bD2ocp8UGAV0lKqKzpAw528vTfD0gwMG8gt_op8yZAxqqLLljMuZdTnjofAfsW2Rq3Z6GyLUlxR51DAUlQKi6UpsKMJoXTrm1Jw8sXBHpsRqA.UHCYOtnqk4SfhAknCnymaQ" //when test, _, err := Decode(token, Ecc256Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_ECDH_ES_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTIiwiZW5jIjoiQTE5MkNCQy1IUzM4NCIsImVwayI6eyJrdHkiOiJFQyIsIngiOiJPaFdQMHdYQy10YnotZEZPbzJUZGljZ2dBWnNPUm1CMTFwTHd0T1lGamhTS0diSEo2U05lRVU3akNzeXNRVzJZIiwieSI6IlNRdlFrbnJoRjk5RzJ2aHhkNE82Y1NQb2lOLVhTbm5LMS11UmM4LXZpS2lHTXJIQzkyXzZyeWRPeEtlN0JPdDgiLCJjcnYiOiJQLTM4NCJ9fQ..11aQFJ3lbGxS8hKGG0-qBw.8885t-_OenCjccLenOIsX2OiTe-xGejXJuKl4AyBRugk4VsBC16GQ24kGUtDPNASXcswgJhiCJde6BNte2aq9xyeuT6RSknua7lnl7njtnU19ssz9hhXJ_wuZr_XNGYmuyM0Pb_fmNK0mA0k2vo9rcfLktTFfprdKg7iLeCHt8576g_GGF577BOc5s4Pl0dVBGdiutSdczTf67hGBoTWIr6Q-9cipLinxr9DwbOpCtceX1gFlAxsWjqswICk6Vwah56GZ7_1XqwyBsO5flNyrQ.xzEn_kq5JvwoYpuPT1ePE4QRzje1qBCT" //when test, _, err := Decode(token, Ecc384Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_ECDH_ES_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTIiwiZW5jIjoiQTI1NkNCQy1IUzUxMiIsImVwayI6eyJrdHkiOiJFQyIsIngiOiJBV3JGb092UkRnWWpaUmF4dXVWMk54c1U1NVNlT1QxUTJ4V3I1ektvbUtHS2hZVmxoVFRQWEtka2MtMzM1bDBWRHlXRTlQZl9SLUpCSThtdWpEaHlSYmVfIiwieSI6IkFhbjBIMEcwRVhWaHNpaDBicU1XeGZHb2JsM2FlUTM1eVZCaG5pSmhfMERNRHFUX3hxVHRWaEtGQWlOWEIwTGJKTjJnd0NSY182OE1vS1p5R3FrV3RIVDciLCJjcnYiOiJQLTUyMSJ9fQ..uA7eYAKVhOr6nnO1bQnhpQ.G5qlUuzVAWgN_szXjFa4eAdXVPEcjpStnw4YYFm2p_lsQs6VG5huSGseV3Wgr22gdc0xHk5XgwRyihB5tr4MiXf41mVKwmxT-u9z5N236fDZ6LYYBY1YrUAp_1pOlyO7RpxpHGrZTKTeuIxhTHhs0jkVC_RZlVNlsjEhU3ssWDCJsCxetLwbq8huL1zlzwyAYqV7uPYIrp2JdT7GkZYcxrsaP8dCkPIdfORRn_qhYIwDnum2rLiYMLc8H0KmpzZKYUVxI7PVPK4oRQpv6n801A.QL0cDhvNKWmMMF1fLUXhI80zE5w5Ghm1Z3_7hGOEesQ" //when test, _, err := Decode(token, Ecc512Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_ECDH_ES_A128GCM(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTIiwiZW5jIjoiQTEyOEdDTSIsImVwayI6eyJrdHkiOiJFQyIsIngiOiJPbDdqSWk4SDFpRTFrcnZRTmFQeGp5LXEtY3pQME40RVdPM1I3NTg0aEdVIiwieSI6Ik1kU2V1OVNudWtwOWxLZGU5clVuYmp4a3ozbV9kTWpqQXc5NFd3Q0xaa3MiLCJjcnYiOiJQLTI1NiJ9fQ..E4XwpWZ2kO-Vg0xb.lP5LWPlabtmzS-m2EPGhlPGgllLNhI5OF2nAbbV9tVvtCckKpt358IQNRk-W8-JNL9SsLdWmVUMplrw-GO-KA2qwxEeh_8-muYCw3qfdhVVhLnOF-kL4mW9a00Xls_6nIZponGrqpHCwRQM5aSr365kqTNpfOnXgJTKG2459nqv8n4oSfmwV2iRUBlXEgTO-1Tvrq9doDwZCCHj__JKvbuPfyRBp5T7d-QJio0XRF1TO4QY36GtKMXWR264lS7g-T1xxtA.vFevA9zsyOnNA5RZanKqHA" //when test, _, err := Decode(token, Ecc256Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestEncrypt_ECDH_ES_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES, A128CBC_HS256, Ecc256Public()) fmt.Printf("\nECDH-ES A128CBC_HS256= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 230) c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_ECDH_ES_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES, A192CBC_HS384, Ecc384Public()) fmt.Printf("\nECDH-ES A192CBC_H384= %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 286) c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc384Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_ECDH_ES_A256CBC_HS512(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES, A256CBC_HS512, Ecc512Public()) fmt.Printf("\nECDH-ES A256CBC_HS512 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 350) c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 43) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc512Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_ECDH_ES_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES, A128GCM, Ecc256Public()) fmt.Printf("\nECDH-ES A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 222) c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_ECDH_ES_A128KW_A128GCM(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTK0ExMjhLVyIsImVuYyI6IkExMjhHQ00iLCJlcGsiOnsia3R5IjoiRUMiLCJ4IjoiNnlzVWZVd09vVWxENUpGZG9qUHFXeFd3ZkJ3b2ttWmpOVmxJRFFrcG1PMCIsInkiOiJKZVpia19QazIybWowVFUwcG5uQjNVaUwySzJJcVl6Tk0xVVRPZS1KY3dZIiwiY3J2IjoiUC0yNTYifX0.e1n3YTorJJ-H7eWby-pfGWzVx0aDScCT.VQLnlbAD3N1O-k-S.mJzcAMoxUMQxXIHFGcVjuEVKw70lC6rNbcGqverZBkycPQ2EDgZCiqMgJenHuecvG_YqShi50uZYVyYS4TTrGh1Bj4jP6iFZ8Ksww3hW_jYzKQbp9CdbmOL1f0f25RKwUq61AraXGoJ1Lrs8IM96tvTjKTGpDkNMJ8xN4kVcRcrM5fjTIx973XKo2_nbuCpn-BlAhB6wzYuw_EFsqis8-8cssPENLuGA-n-xX66akqdhycfh5RiqrTPYUnk5ss1Fo_LWWA.l0-CNccSNLTgVdGW1CZr9w" //when test, _, err := Decode(token, Ecc256Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_ECDH_ES_A192KW_A192GCM(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTK0ExOTJLVyIsImVuYyI6IkExOTJHQ00iLCJlcGsiOnsia3R5IjoiRUMiLCJ4IjoiX1huZ0s2a1Q0XzR4dWpBZzFFZWpNZHQ3WW9sTkMySENZMDVyNUNTWUNmQVdUQ0phRi1ic1ZJUnpOY3hDeG5GUSIsInkiOiJPekl2T1NIeERjMTh5eXNqeVpQblZvaVhMZWU4OUhFUklvaVhrLW9nclVlTkFfRFFZTUFmbVFEZWtRbFk2SWZ4IiwiY3J2IjoiUC0zODQifX0.edrJoQt5wA7K11UvLxz3ExKyazayJ2O5fZVUETQh1RA.F886lZeI68UEU666.2woVI6lnFEeLNIxmlUbrTUHvV2dz3h47BVUs4ylSoYZ7OcdamP8cvdnxJY6N_kq2cxhyOzgsJAlbk4uG6UpyK0snl8fNExyNiDwyCCKCbUE8jAoGV7zBRDPioTbMIzprWt9qmBOW-pmzh8l_eiI_fPbvUulcIfqGdUK6fDifQAAjCB5RnxMFbkpVVkkcvHXVzaPnNvkZ_GLLRElInLx2H3mpFaby0a-zEK27qLzAe-t6WupS9rIKUhK0skPgeSkdRmHDxw.Qic27YS5eIoc0M4nMP365w" //when test, _, err := Decode(token, Ecc384Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_ECDH_ES_A256KW_A256GCM(c *C) { //given token := "eyJhbGciOiJFQ0RILUVTK0EyNTZLVyIsImVuYyI6IkEyNTZHQ00iLCJlcGsiOnsia3R5IjoiRUMiLCJ4IjoiQUlMTkMzX2lEN0hhSWFhZEU5bGZPcHI5YzBCYzV6cEtraUtkcUNpeGVubHdydlhFVDF4Y0RqbFMtSWZxSUR6VWNoekhiVFgxN0Z4ZGM2X1dOZ2std3VlUyIsInkiOiJBQlFwLWRsalVrZHlOcHFOTkxlSlEyUEZGVmplUlV4SjRGOFZYNGpOMGw4U1Q3Y0NMY0tmVVpKQmJ5b2FNbzhuX3Q1dDc3a1hSOE1aRllOcFhadFBHQTRWIiwiY3J2IjoiUC01MjEifX0.HbaOJoNm7rKdFPeNNxk5NZGWqyleUBrpme7kBfkPSNgStHua5SGqgA.qvi8Wxs7EFXTvDAI.HnPWLNveG0ypTWGWb-V4ORyshMmoR7IhaWUDKkoV9HoD-V6z9WZqAx3uX45Se2fxO9aqSVWqQbrLkw9C9A4DGGiMv27tr29m_c4jUOF_TEGWuhAUAo3Lv-srLFGxQoA3yNWsCpI5VsUVxqc7Sx1dJcEHe8DQcsYTaroNTh0cUMQuqJX9waQm2H-qFjrkLk3d9bo8rhB3x8JTi_X5uNcB1mNH51pPDtRGO41t7EFII1KmAUgjL8c6bCw__Cc6hoteely2Pg.QRsOLaELO2d2MCjpFZKsCg" //when test, _, err := Decode(token, Ecc512Private()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestEncrypt_ECDH_ES_A128KW_A128CBC_HS256(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES_A128KW, A128CBC_HS256, Ecc256Public()) fmt.Printf("\nECDH-ES+A128KW A128CBC-HS256 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 239) c.Assert(len(parts[1]), Equals, 54) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_ECDH_ES_A192KW_A192CBC_HS384(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES_A192KW, A192CBC_HS384, Ecc384Public()) fmt.Printf("\nECDH-ES+A192KW A192CBC-HS384 = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 295) c.Assert(len(parts[1]), Equals, 75) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 32) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc384Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_ECDH_ES_A256KW_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES_A256KW, A256GCM, Ecc512Public()) fmt.Printf("\nECDH-ES+A256KW A265GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 351) c.Assert(len(parts[1]), Equals, 54) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc512Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_RSA_OAEP_256_A128CBC_HS256(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.bje66yTjMUpyGzbt3QvPNOmCmUPowgEmoBHXw-pByhST2VBSs0_67JKDymKW0VpmQC5Qb7ZLC6nNG8YW5pxTZDOeTQLodhAvzoNAsrx4M2R_N58ZVqBPLKTq7FKi1NNd8oJ80dwWbOJ13dkLH68SlhOK5bhqKFgtbzalnglL2kq8Fki1GkN4YyFnS8-chC-mlrS5bJrPSHUF7oAsG_flL_e9-KzYqYTQgGCB3GYSo_pgalsp2rUO3Oz2Pfe9IEJNlX7R9wOT1nTT0UUg-lSzQ2oOaXNvNyaPgEa76mJ1nk7ZQq7ZNix1m8snjk0Vizd8EOFCSRyOGcp4mHMn7-s00Q.tMFMCdFNQXbhEnwE6mP_XQ.E_O_ZBtJ8P0FvhKOV_W98oxIySDgdd0up0c8FAjo-3OVZ_6XMEQYFDKVG_Zc3zkbaz1Z2hmc7D7M28RbhRdya3yJN6Hcv1KuXeZ9ociI7o739Ni_bPvv8xCmGxlASS5AF7N4JR7XjrWL-SYKGNL1p0XNTlPo3B3qYqgAY6jFNvlcjWupim-pQbWKNqPbO2KmSCtUzyKE5oHjsomH0hnQs0_DXv3cgQ_ZFLFZBc1tC4AjQ8QZex5kWg5BmlJDM5F_jD7QRhb7B1u4Mi563-AKVA.0lraw3IXMM6wPqUZVYA8pg" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_RSA_OAEP_256_A192CBC_HS384(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTkyQ0JDLUhTMzg0In0.COuKvozBVi2vkEPpFdx0HTMpU9tmpP1lLngbmGn8RVphY-vjhVaduv8D_Ay_1j8LuMz4tgP98xWtbJkTyhxY1kBwXe0CgqFUOSJ1mTEPRkKSXpdFR7rT1Pv68qug2yKaXT_qcviyBerIcUVFbXBmtiYAosYO4kaPSOE1IvLadFOrMkxdZv6QiiCROzWgJNCCMgNQZGRoPhqLe3wrcxi86DhNO7Bpqq_yeNVyHdU_qObMuMVZIWWEQIDhiU4nE8WGJLG_NtKElc_nQwbmclL_YYgTiHsIAKWZCdj0nwfLe5mwJQN4r7pjakiUVzCbNNgI1-iBH1vJD5VCPxgWldzfYA.7cDs4wzbNDt1Kq40Q5ae4w.u1bR6ChVd90QkFIp3H6IkOCIMwf5aIKsQOvqgFangRLrDjctl5qO5jTHr1o1GwBQvAkRmaGSE7fRIwWB_l-Ayx2c2WDFOkVXFSR_D23GrWaLMLbugPItQd2Mny6H4QOzO3O0EK_Qm7frqwKQI3og72SB8DUqzEaKsrz7HR2z_qMa2CEEApxai_R6NIlAdMUbYvOfZx262MWFGrITBDmma-Mnqiz9WJUv2wexfwjROaaS4wXfkGy5B6ltESifpZZk5NerExR3GA6yX7cFqJc4pQ.FKcbLyB9eP1UXmxyliTu1_GQrnS-JtAB" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecrypt_RSA_OAEP_256_A256CBC_HS512(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.Pt1q6MNdaiVWhMnY7r6DVpkYQmzyIjhb0cj10LowP_FgMu1dOQVuNwhK14MO1ki1y1Pvxouct9wwmb5gE7jNJBy6vU-FrrY62WNr_hKL3Cq2030LlJwauv1XQrEE-GCw1srxOAsw6LNT14v4f0qjeW46mIHNX4CZMEO9ntwojWsHTNsh4Qk6SU1QlS3WbbVl7gjjfqTP54j2ZwZM38s7Cs4pSAChP04UbW6Uhrm65JSi0lyg25OBXIxMEt1z9WY8lnjuh3iL_WttnFn9lf5fUuuR2N70HwANz2mxH3CxjO0ygXJtV-FhFzz3HqI2-ELrve4Igj_2f2_S6OrRTWRucA.er5K9Gk0wp3wF_sq7ib7BQ.L80B9FGSjUbEblpJ6tuiaq6NAsW89YQGD0awxtE-irKN65PT8nndBd0hlel8RRThXRF0kiYYor2GpgvVVaoOzSQcwL-aDgNO7BeRsaOL5ku2NlyT1erbg_8jEVG5BFMM0-jCb4kD0jBKWYCGoB7qs_QQxZ394H5GPwG68vlizKEa8PoaNIM0at5oFT7EHPdmGmwQyQCHR43e6uN4k28PWNxjN9Ndo5lvlYnxnAyDGVDu8lCjozaA_ZTrEPS-UBb6lOEW39CXdwVk1MgvyQfswQ.yuDMf_77Wr9Er3FG1_0FwHXJTOVQPjzBwGoKEg81mQo" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestEncrypt_RSA_OAEP_256_A128GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP_256, A128GCM, PubKey()) fmt.Printf("\nRSA-OAEP-256 A128GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTI4R0NNIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_256_A192GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP_256, A192GCM, PubKey()) fmt.Printf("\nRSA-OAEP-256 A192GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 51) c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncrypt_RSA_OAEP_256_A256GCM(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP_256, A256GCM, PubKey()) fmt.Printf("\nRSA-OAEP-256 A256GCM = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 51) c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 24) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecrypt_Deflated(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUCIsInppcCI6IkRFRiIsImVuYyI6IkExMjhDQkMtSFMyNTYifQ.nXSS9jDwE0dXkcGI7UquZBhn2nsB2P8u-YSWEuTAgEeuV54qNU4SlE76bToI1z4LUuABHmZOv9S24xkF45b7Mrap_Fu4JXH8euXrQgKQb9o_HL5FvE8m4zk5Ow13MKGPvHvWKOaNEBFriwYIfPi6QBYrpuqn0BaANc_aMyInV0Fn7e8EAgVmvoagmy7Hxic2sPUeLEIlRCDSGa82mpiGusjo7VMJxymkhnMdKufpGPh4wod7pvgb-jDWasUHpsUkHqSKZxlrDQxcy1-Pu1G37TAnImlWPa9NU7500IXc-W07IJccXhR3qhA5QaIyBbmHY0j1Dn3808oSFOYSF85A9w.uwbZhK-8iNzcjvKRb1a2Ig.jxj1GfH9Ndu1y0b7NRz_yfmjrvX2rXQczyK9ZJGWTWfeNPGR_PZdJmddiam15Qtz7R-pzIeyR4_qQoMzOISkq6fDEvEWVZdHnnTUHQzCoGX1dZoG9jXEwfAk2G1vXYT2vynEQZ72xk0V_OBtKhpIAUEFsXwCUeLAAgjFNY4OGWZl_Kmv9RTGhnePZfVbrbwg.WuV64jlV03OZm99qHMP9wQ" //when test, _, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, Equals, "{\"exp\":1392963710,\"sub\":\"alice\",\"nbf\":1392963110,\"aud\":[\"https:\\/\\/app-one.com\",\"https:\\/\\/app-two.com\"],\"iss\":\"https:\\/\\/openid.net\",\"jti\":\"9fa7a38a-28fd-421c-825c-8fab3bbf3fb4\",\"iat\":1392963110}") } func (s *TestSuite) TestEncrypt_Deflated(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, RSA_OAEP, A256GCM, PubKey(), Zip(DEF)) fmt.Printf("\nRSA-OAEP A256GCM DEF = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00iLCJ6aXAiOiJERUYifQ") c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 32) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, PrivKey()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecodeSignedHeader(c *C) { //given token := "eyJhbGciOiJSUzUxMiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.KP_mwCVRIxcF6ErdrzNcXZQDFGcL-Hlyocc4tIl3tJfzSfc7rz7qOLPjHpZ6UFH1ncd5TlpRc1B_pgvY-l0BNtx_s7n_QA55X4c1oeD8csrIoXQ6A6mtvdVGoSlGu2JnP6N2aqlDmlcefKqjl_Z-8nwDMGTMkDNhHKfHlIb2_Dliwxeq8LmNMREEdvNH2XVp_ffxBjiaKv2Eqbwc6I17241GCEmjDCvnagSgjX_5uu-da2H7TK2gtPJYUo8r9nzC7uzZJ5SB8suZH0COSofsP-9wvH0FESO40evCyEBylqg3bh9M9dIzeq8_bdTiC5kG93Fal44OEY8_Zm88wB_VjQ" //when _, test, err := Decode(token, PubKey()) //then c.Assert(err, IsNil) c.Assert(test, DeepEquals, map[string]interface{}{"alg": "RS512", "cty": "text/plain"}) } func (s *TestSuite) TestDecodeEncryptedHeader(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.Pt1q6MNdaiVWhMnY7r6DVpkYQmzyIjhb0cj10LowP_FgMu1dOQVuNwhK14MO1ki1y1Pvxouct9wwmb5gE7jNJBy6vU-FrrY62WNr_hKL3Cq2030LlJwauv1XQrEE-GCw1srxOAsw6LNT14v4f0qjeW46mIHNX4CZMEO9ntwojWsHTNsh4Qk6SU1QlS3WbbVl7gjjfqTP54j2ZwZM38s7Cs4pSAChP04UbW6Uhrm65JSi0lyg25OBXIxMEt1z9WY8lnjuh3iL_WttnFn9lf5fUuuR2N70HwANz2mxH3CxjO0ygXJtV-FhFzz3HqI2-ELrve4Igj_2f2_S6OrRTWRucA.er5K9Gk0wp3wF_sq7ib7BQ.L80B9FGSjUbEblpJ6tuiaq6NAsW89YQGD0awxtE-irKN65PT8nndBd0hlel8RRThXRF0kiYYor2GpgvVVaoOzSQcwL-aDgNO7BeRsaOL5ku2NlyT1erbg_8jEVG5BFMM0-jCb4kD0jBKWYCGoB7qs_QQxZ394H5GPwG68vlizKEa8PoaNIM0at5oFT7EHPdmGmwQyQCHR43e6uN4k28PWNxjN9Ndo5lvlYnxnAyDGVDu8lCjozaA_ZTrEPS-UBb6lOEW39CXdwVk1MgvyQfswQ.yuDMf_77Wr9Er3FG1_0FwHXJTOVQPjzBwGoKEg81mQo" //when _, test, err := Decode(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, DeepEquals, map[string]interface{}{"enc": "A256CBC-HS512", "alg": "RSA-OAEP-256"}) } func (s *TestSuite) TestDecrypt_TwoPhased(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2Q0JDLUhTNTEyIn0.Pt1q6MNdaiVWhMnY7r6DVpkYQmzyIjhb0cj10LowP_FgMu1dOQVuNwhK14MO1ki1y1Pvxouct9wwmb5gE7jNJBy6vU-FrrY62WNr_hKL3Cq2030LlJwauv1XQrEE-GCw1srxOAsw6LNT14v4f0qjeW46mIHNX4CZMEO9ntwojWsHTNsh4Qk6SU1QlS3WbbVl7gjjfqTP54j2ZwZM38s7Cs4pSAChP04UbW6Uhrm65JSi0lyg25OBXIxMEt1z9WY8lnjuh3iL_WttnFn9lf5fUuuR2N70HwANz2mxH3CxjO0ygXJtV-FhFzz3HqI2-ELrve4Igj_2f2_S6OrRTWRucA.er5K9Gk0wp3wF_sq7ib7BQ.L80B9FGSjUbEblpJ6tuiaq6NAsW89YQGD0awxtE-irKN65PT8nndBd0hlel8RRThXRF0kiYYor2GpgvVVaoOzSQcwL-aDgNO7BeRsaOL5ku2NlyT1erbg_8jEVG5BFMM0-jCb4kD0jBKWYCGoB7qs_QQxZ394H5GPwG68vlizKEa8PoaNIM0at5oFT7EHPdmGmwQyQCHR43e6uN4k28PWNxjN9Ndo5lvlYnxnAyDGVDu8lCjozaA_ZTrEPS-UBb6lOEW39CXdwVk1MgvyQfswQ.yuDMf_77Wr9Er3FG1_0FwHXJTOVQPjzBwGoKEg81mQo" //when test, _, err := Decode(token, func(headers map[string]interface{}, payload string) interface{} { //ensure that callback executed with correct arguments c.Assert(headers, DeepEquals, map[string]interface{}{"alg": "RSA-OAEP-256", "enc": "A256CBC-HS512"}) return PrivKey() }) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"exp":1392553211,"sub":"alice","nbf":1392552611,"aud":["https:\/\/app-one.com","https:\/\/app-two.com"],"iss":"https:\/\/openid.net","jti":"586dd129-a29f-49c8-9de7-454af1155e27","iat":1392552611}`) } func (s *TestSuite) TestDecode_TwoPhased(c *C) { //given token := "eyJhbGciOiJFUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.EVnmDMlz-oi05AQzts-R3aqWvaBlwVZddWkmaaHyMx5Phb2NSLgyI0kccpgjjAyo1S5KCB3LIMPfmxCX_obMKA" //when test, _, err := Decode(token, func(headers map[string]interface{}, payload string) interface{} { //ensure that callback executed with correct arguments c.Assert(headers, DeepEquals, map[string]interface{}{"alg": "ES256", "cty": "text/plain"}) c.Assert(payload, Equals, `{"hello": "world"}`) return Ecc256Public() }) //then c.Assert(err, IsNil) c.Assert(test, Equals, `{"hello": "world"}`) } func (s *TestSuite) TestDecode_TwoPhased_Error(c *C) { //given token := "eyJhbGciOiJFUzI1NiIsImN0eSI6InRleHRcL3BsYWluIn0.eyJoZWxsbyI6ICJ3b3JsZCJ9.EVnmDMlz-oi05AQzts-R3aqWvaBlwVZddWkmaaHyMx5Phb2NSLgyI0kccpgjjAyo1S5KCB3LIMPfmxCX_obMKA" //when test, _, err := Decode(token, func(headers map[string]interface{}, payload string) interface{} { return errors.New("Test error") }) //then fmt.Printf("\ntwo phased err= %v\n", err) c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestSignWithExtraHeaders(c *C) { //given payload := `{"hello": "world"}` //when test, err := Sign(payload, ES256, Ecc256Private(), Header("keyid", "111-222-333"), Header("trans-id", "aaa-bbb"), Headers(map[string]interface{}{"alg": "RS256", "cty": "text/plain"})) fmt.Printf("\nES256 + extra headers = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 3) c.Assert(parts[0], Equals, "eyJhbGciOiJFUzI1NiIsImN0eSI6InRleHQvcGxhaW4iLCJrZXlpZCI6IjExMS0yMjItMzMzIiwidHJhbnMtaWQiOiJhYWEtYmJiIn0") c.Assert(parts[1], Equals, "eyJoZWxsbyI6ICJ3b3JsZCJ9") c.Assert(len(parts[2]), Equals, 86) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Public()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestEncryptWithExtraHeaders(c *C) { //given payload := `{"hello": "world"}` //when test, err := Encrypt(payload, ECDH_ES, A128CBC_HS256, Ecc256Public(), Header("keyid", "111-222-333"), Header("trans-id", "aaa-bbb"), Headers(map[string]interface{}{"alg": "RS256", "cty": "text/plain", "zip": "DEFLATE"})) fmt.Printf("\nECDH-ES A128CBC_HS256 + extra headers = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(len(parts[0]), Equals, 312) c.Assert(len(parts[1]), Equals, 0) c.Assert(len(parts[2]), Equals, 22) c.Assert(len(parts[3]), Equals, 43) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := Decode(test, Ecc256Private()) c.Assert(t, Equals, payload) } func (s *TestSuite) TestDecodeMissingAlgHeader(c *C) { //given token := "eyJjdHkiOiJ0ZXh0XC9wbGFpbiJ9.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E" //when test, _, err := Decode(token, shaKey) fmt.Printf("\nmissing sign 'alg' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecodeInvalidAlgHeader(c *C) { //given token := "eyJhbGciOjEyMywiY3R5IjoidGV4dFwvcGxhaW4ifQ.eyJoZWxsbyI6ICJ3b3JsZCJ9.chIoYWrQMA8XL5nFz6oLDJyvgHk2KA4BrFGrKymjC8E" //when test, _, err := Decode(token, shaKey) fmt.Printf("\ninvalid sign 'alg' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecryptMissingAlgHeader(c *C) { //given token := "eyJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.bje66yTjMUpyGzbt3QvPNOmCmUPowgEmoBHXw-pByhST2VBSs0_67JKDymKW0VpmQC5Qb7ZLC6nNG8YW5pxTZDOeTQLodhAvzoNAsrx4M2R_N58ZVqBPLKTq7FKi1NNd8oJ80dwWbOJ13dkLH68SlhOK5bhqKFgtbzalnglL2kq8Fki1GkN4YyFnS8-chC-mlrS5bJrPSHUF7oAsG_flL_e9-KzYqYTQgGCB3GYSo_pgalsp2rUO3Oz2Pfe9IEJNlX7R9wOT1nTT0UUg-lSzQ2oOaXNvNyaPgEa76mJ1nk7ZQq7ZNix1m8snjk0Vizd8EOFCSRyOGcp4mHMn7-s00Q.tMFMCdFNQXbhEnwE6mP_XQ.E_O_ZBtJ8P0FvhKOV_W98oxIySDgdd0up0c8FAjo-3OVZ_6XMEQYFDKVG_Zc3zkbaz1Z2hmc7D7M28RbhRdya3yJN6Hcv1KuXeZ9ociI7o739Ni_bPvv8xCmGxlASS5AF7N4JR7XjrWL-SYKGNL1p0XNTlPo3B3qYqgAY6jFNvlcjWupim-pQbWKNqPbO2KmSCtUzyKE5oHjsomH0hnQs0_DXv3cgQ_ZFLFZBc1tC4AjQ8QZex5kWg5BmlJDM5F_jD7QRhb7B1u4Mi563-AKVA.0lraw3IXMM6wPqUZVYA8pg" //when test, _, err := Decode(token, shaKey) fmt.Printf("\nmissing encrypt 'alg' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecryptInvalidAlgHeader(c *C) { //given token := "eyJhbGciOiAxMTEsICJlbmMiOiJBMTI4Q0JDLUhTMjU2In0.bje66yTjMUpyGzbt3QvPNOmCmUPowgEmoBHXw-pByhST2VBSs0_67JKDymKW0VpmQC5Qb7ZLC6nNG8YW5pxTZDOeTQLodhAvzoNAsrx4M2R_N58ZVqBPLKTq7FKi1NNd8oJ80dwWbOJ13dkLH68SlhOK5bhqKFgtbzalnglL2kq8Fki1GkN4YyFnS8-chC-mlrS5bJrPSHUF7oAsG_flL_e9-KzYqYTQgGCB3GYSo_pgalsp2rUO3Oz2Pfe9IEJNlX7R9wOT1nTT0UUg-lSzQ2oOaXNvNyaPgEa76mJ1nk7ZQq7ZNix1m8snjk0Vizd8EOFCSRyOGcp4mHMn7-s00Q.tMFMCdFNQXbhEnwE6mP_XQ.E_O_ZBtJ8P0FvhKOV_W98oxIySDgdd0up0c8FAjo-3OVZ_6XMEQYFDKVG_Zc3zkbaz1Z2hmc7D7M28RbhRdya3yJN6Hcv1KuXeZ9ociI7o739Ni_bPvv8xCmGxlASS5AF7N4JR7XjrWL-SYKGNL1p0XNTlPo3B3qYqgAY6jFNvlcjWupim-pQbWKNqPbO2KmSCtUzyKE5oHjsomH0hnQs0_DXv3cgQ_ZFLFZBc1tC4AjQ8QZex5kWg5BmlJDM5F_jD7QRhb7B1u4Mi563-AKVA.0lraw3IXMM6wPqUZVYA8pg" //when test, _, err := Decode(token, shaKey) fmt.Printf("\ninvalid encrypt 'alg' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecryptMissingEncHeader(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYifQ.bje66yTjMUpyGzbt3QvPNOmCmUPowgEmoBHXw-pByhST2VBSs0_67JKDymKW0VpmQC5Qb7ZLC6nNG8YW5pxTZDOeTQLodhAvzoNAsrx4M2R_N58ZVqBPLKTq7FKi1NNd8oJ80dwWbOJ13dkLH68SlhOK5bhqKFgtbzalnglL2kq8Fki1GkN4YyFnS8-chC-mlrS5bJrPSHUF7oAsG_flL_e9-KzYqYTQgGCB3GYSo_pgalsp2rUO3Oz2Pfe9IEJNlX7R9wOT1nTT0UUg-lSzQ2oOaXNvNyaPgEa76mJ1nk7ZQq7ZNix1m8snjk0Vizd8EOFCSRyOGcp4mHMn7-s00Q.tMFMCdFNQXbhEnwE6mP_XQ.E_O_ZBtJ8P0FvhKOV_W98oxIySDgdd0up0c8FAjo-3OVZ_6XMEQYFDKVG_Zc3zkbaz1Z2hmc7D7M28RbhRdya3yJN6Hcv1KuXeZ9ociI7o739Ni_bPvv8xCmGxlASS5AF7N4JR7XjrWL-SYKGNL1p0XNTlPo3B3qYqgAY6jFNvlcjWupim-pQbWKNqPbO2KmSCtUzyKE5oHjsomH0hnQs0_DXv3cgQ_ZFLFZBc1tC4AjQ8QZex5kWg5BmlJDM5F_jD7QRhb7B1u4Mi563-AKVA.0lraw3IXMM6wPqUZVYA8pg" //when test, _, err := Decode(token, shaKey) fmt.Printf("\nmissing encrypt 'enc' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecryptInvalidEncHeader(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOjExMX0.bje66yTjMUpyGzbt3QvPNOmCmUPowgEmoBHXw-pByhST2VBSs0_67JKDymKW0VpmQC5Qb7ZLC6nNG8YW5pxTZDOeTQLodhAvzoNAsrx4M2R_N58ZVqBPLKTq7FKi1NNd8oJ80dwWbOJ13dkLH68SlhOK5bhqKFgtbzalnglL2kq8Fki1GkN4YyFnS8-chC-mlrS5bJrPSHUF7oAsG_flL_e9-KzYqYTQgGCB3GYSo_pgalsp2rUO3Oz2Pfe9IEJNlX7R9wOT1nTT0UUg-lSzQ2oOaXNvNyaPgEa76mJ1nk7ZQq7ZNix1m8snjk0Vizd8EOFCSRyOGcp4mHMn7-s00Q.tMFMCdFNQXbhEnwE6mP_XQ.E_O_ZBtJ8P0FvhKOV_W98oxIySDgdd0up0c8FAjo-3OVZ_6XMEQYFDKVG_Zc3zkbaz1Z2hmc7D7M28RbhRdya3yJN6Hcv1KuXeZ9ociI7o739Ni_bPvv8xCmGxlASS5AF7N4JR7XjrWL-SYKGNL1p0XNTlPo3B3qYqgAY6jFNvlcjWupim-pQbWKNqPbO2KmSCtUzyKE5oHjsomH0hnQs0_DXv3cgQ_ZFLFZBc1tC4AjQ8QZex5kWg5BmlJDM5F_jD7QRhb7B1u4Mi563-AKVA.0lraw3IXMM6wPqUZVYA8pg" //when test, _, err := Decode(token, shaKey) fmt.Printf("\ninvalid encrypt 'enc' header err= %v\n", err) //then c.Assert(err, NotNil) c.Assert(test, Equals, "") } func (s *TestSuite) TestDecodeBytes_HS512(c *C) { //given token := "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.AAECAwQFBgcICQ.iTZ3VKv6n2JdDxMyM4qRZMuiYZOOaZ-58yCvs48vRaCRYQZmbAK6q-DWuBNEutL1LorEVGo8LZC0LyE7b8L1UA" //when test, _, err := DecodeBytes(token, shaKey) //then c.Assert(err, IsNil) c.Assert(test, DeepEquals, []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}) } func (s *TestSuite) TestDecodeBytes_RSA_OAEP_A256GCM(c *C) { //given token := "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMjU2R0NNIn0.G23wC6QtVVaxoCp9ijgvbK5veMJ6YvoQW_Zdcaxb_2-cNHBbRP8E44kDRVkHXXIj_gPlm1knqK9-y-7lyxhyVbG0w71gZnfSuOKegKwXO9KpCX60dc8NbkrlTSDDey5EbSjmoqLlnllajdCdkssrF1KFPzIcnct8ecfJkhxTeKnmjis8xSfGB2sk6HP8C8eYDAEjeO5qPuYmfGwpm4BaYycbylqv4r0zZpFMOADZx2oJw3u7aFe8DL-JYAo5WbfFukg30MBHAfNNiLMu1tLRrjXvcr9i7MeHaUGgo281d9B8d7KUonbwJSwi4Ov3Lm00zrGYFE5WTgtan3vb33ndpg.tLpzdIKoJeytyZv_.RKIL2pXKTmIa3g.5SjeG9R0jmNtgdNY-sMZKw" //when test, _, err := DecodeBytes(token, PrivKey()) //then c.Assert(err, IsNil) c.Assert(test, DeepEquals, []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}) } func (s *TestSuite) TestEncodeBytes_HS256(c *C) { //given payload := []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9} //when test, err := SignBytes(payload, HS256, shaKey) fmt.Printf("\nHS256 (bytes) = %v\n", test) //then c.Assert(err, IsNil) c.Assert(test, Equals, "eyJhbGciOiJIUzI1NiJ9.AAECAwQFBgcICQ.HmKT9jcQJZVtDWPipYjkbyy7cdCMUjyUhiTw25B49Gc") //make sure we consistent with ourselfs t, _, _ := DecodeBytes(test, shaKey) c.Assert(t, DeepEquals, payload) } func (s *TestSuite) TestEncryptBytes_RSA_OAEP_256_A128GCM(c *C) { //given payload := []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9} //when test, err := EncryptBytes(payload, RSA_OAEP_256, A128GCM, PubKey()) fmt.Printf("\nRSA-OAEP-256 A128GCM (bytes) = %v\n", test) //then c.Assert(err, IsNil) parts := strings.Split(test, ".") c.Assert(len(parts), Equals, 5) c.Assert(parts[0], Equals, "eyJhbGciOiJSU0EtT0FFUC0yNTYiLCJlbmMiOiJBMTI4R0NNIn0") c.Assert(len(parts[1]), Equals, 342) c.Assert(len(parts[2]), Equals, 16) c.Assert(len(parts[3]), Equals, 14) c.Assert(len(parts[4]), Equals, 22) //make sure we consistent with ourselfs t, _, _ := DecodeBytes(test, PrivKey()) c.Assert(t, DeepEquals, payload) } //test utils func PubKey() *rsa.PublicKey { key, _ := Rsa.ReadPublic([]byte(pubKey)) return key } func PrivKey() *rsa.PrivateKey { key, _ := Rsa.ReadPrivate([]byte(privKey)) return key } func Ecc256Public() *ecdsa.PublicKey { return ecc.NewPublic([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}) } func Ecc256Private() *ecdsa.PrivateKey { return ecc.NewPrivate([]byte{4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9}, []byte{131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53}, []byte{42, 148, 231, 48, 225, 196, 166, 201, 23, 190, 229, 199, 20, 39, 226, 70, 209, 148, 29, 70, 125, 14, 174, 66, 9, 198, 80, 251, 95, 107, 98, 206}) } func Ecc384Public() *ecdsa.PublicKey { return ecc.NewPublic([]byte{70, 151, 220, 179, 62, 0, 79, 232, 114, 64, 58, 75, 91, 209, 232, 128, 7, 137, 151, 42, 13, 148, 15, 133, 93, 215, 7, 3, 136, 124, 14, 101, 242, 207, 192, 69, 212, 145, 88, 59, 222, 33, 127, 46, 30, 218, 175, 79}, []byte{189, 202, 196, 30, 153, 53, 22, 122, 171, 4, 188, 42, 71, 2, 9, 193, 191, 17, 111, 180, 78, 6, 110, 153, 240, 147, 203, 45, 152, 236, 181, 156, 232, 223, 227, 148, 68, 148, 221, 176, 57, 149, 44, 203, 83, 85, 75, 55}) } func Ecc384Private() *ecdsa.PrivateKey { return ecc.NewPrivate([]byte{70, 151, 220, 179, 62, 0, 79, 232, 114, 64, 58, 75, 91, 209, 232, 128, 7, 137, 151, 42, 13, 148, 15, 133, 93, 215, 7, 3, 136, 124, 14, 101, 242, 207, 192, 69, 212, 145, 88, 59, 222, 33, 127, 46, 30, 218, 175, 79}, []byte{189, 202, 196, 30, 153, 53, 22, 122, 171, 4, 188, 42, 71, 2, 9, 193, 191, 17, 111, 180, 78, 6, 110, 153, 240, 147, 203, 45, 152, 236, 181, 156, 232, 223, 227, 148, 68, 148, 221, 176, 57, 149, 44, 203, 83, 85, 75, 55}, []byte{137, 199, 183, 105, 188, 90, 128, 82, 116, 47, 161, 100, 221, 97, 208, 64, 173, 247, 9, 42, 186, 189, 181, 110, 24, 225, 254, 136, 75, 156, 242, 209, 94, 218, 58, 14, 33, 190, 15, 82, 141, 238, 207, 214, 159, 140, 247, 139}) } func Ecc512Public() *ecdsa.PublicKey { return ecc.NewPublic([]byte{0, 248, 73, 203, 53, 184, 34, 69, 111, 217, 230, 255, 108, 212, 241, 229, 95, 239, 93, 131, 100, 37, 86, 152, 87, 98, 170, 43, 25, 35, 80, 137, 62, 112, 197, 113, 138, 116, 114, 55, 165, 128, 8, 139, 148, 237, 109, 121, 40, 205, 3, 61, 127, 28, 195, 58, 43, 228, 224, 228, 82, 224, 219, 148, 204, 96}, []byte{0, 60, 71, 97, 112, 106, 35, 121, 80, 182, 20, 167, 143, 8, 246, 108, 234, 160, 193, 10, 3, 148, 45, 11, 58, 177, 190, 172, 26, 178, 188, 240, 91, 25, 67, 79, 64, 241, 203, 65, 223, 218, 12, 227, 82, 178, 66, 160, 19, 194, 217, 172, 61, 250, 23, 78, 218, 130, 160, 105, 216, 208, 235, 124, 46, 32}) } func Ecc512Private() *ecdsa.PrivateKey { return ecc.NewPrivate([]byte{0, 248, 73, 203, 53, 184, 34, 69, 111, 217, 230, 255, 108, 212, 241, 229, 95, 239, 93, 131, 100, 37, 86, 152, 87, 98, 170, 43, 25, 35, 80, 137, 62, 112, 197, 113, 138, 116, 114, 55, 165, 128, 8, 139, 148, 237, 109, 121, 40, 205, 3, 61, 127, 28, 195, 58, 43, 228, 224, 228, 82, 224, 219, 148, 204, 96}, []byte{0, 60, 71, 97, 112, 106, 35, 121, 80, 182, 20, 167, 143, 8, 246, 108, 234, 160, 193, 10, 3, 148, 45, 11, 58, 177, 190, 172, 26, 178, 188, 240, 91, 25, 67, 79, 64, 241, 203, 65, 223, 218, 12, 227, 82, 178, 66, 160, 19, 194, 217, 172, 61, 250, 23, 78, 218, 130, 160, 105, 216, 208, 235, 124, 46, 32}, []byte{0, 222, 129, 9, 133, 207, 123, 116, 176, 83, 95, 169, 29, 121, 160, 137, 22, 21, 176, 59, 203, 129, 62, 111, 19, 78, 14, 174, 20, 211, 56, 160, 83, 42, 74, 219, 208, 39, 231, 33, 84, 114, 71, 106, 109, 161, 116, 243, 166, 146, 252, 231, 137, 228, 99, 149, 152, 123, 201, 157, 155, 131, 181, 106, 179, 112}) } jose2go-1.5/kdf/000077500000000000000000000000001373537523000135035ustar00rootroot00000000000000jose2go-1.5/kdf/nist_sp800_56a.go000066400000000000000000000020771373537523000164220ustar00rootroot00000000000000package kdf import ( "hash" "math" "github.com/dvsekhvalnov/jose2go/arrays" ) const ( MaxInt = int(^uint(0)>>1); ) // DeriveConcatKDF implements NIST SP 800-56A Concatenation Key Derivation Function. Derives // key material of keydatalen bits size given Z (sharedSecret), OtherInfo (AlgorithmID | // PartyUInfo | PartyVInfo | SuppPubInfo | SuppPrivInfo) and hash function func DeriveConcatKDF(keydatalen int, sharedSecret, algId, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo []byte, h hash.Hash) []byte { otherInfo := arrays.Concat(algId, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo) keyLenBytes := keydatalen >> 3 reps := int(math.Ceil(float64(keyLenBytes) / float64(h.Size()))) if reps > MaxInt { panic("kdf.DeriveConcatKDF: too much iterations (more than 2^32-1).") } dk:=make([]byte, 0, keyLenBytes) for counter := 1;counter <= reps;counter++ { h.Reset() counterBytes:=arrays.UInt32ToBytes(uint32(counter)) h.Write(counterBytes) h.Write(sharedSecret) h.Write(otherInfo) dk = h.Sum(dk) } return dk[:keyLenBytes] } jose2go-1.5/kdf/nist_sp800_56a_test.go000066400000000000000000000045311373537523000174560ustar00rootroot00000000000000package kdf import ( . "gopkg.in/check.v1" "crypto/sha256" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/base64url" ) var z=[]byte{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31} var z2=[]byte{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47} var algId=prependDatalen([]byte("alg")) var partyUInfo=datalenFormat("pui") var partyVInfo=datalenFormat("pvi") func (s *TestSuite) Test256Secret_256Key(c *C) { //when test:=DeriveConcatKDF(256,z,algId,partyUInfo,partyVInfo,arrays.UInt32ToBytes(256),nil,sha256.New()) //then c.Assert(test, DeepEquals, []byte{190, 69, 15, 62, 38, 64, 30, 141, 208, 163, 55, 202, 18, 71, 176, 174, 114, 221, 249, 255, 207, 131, 190, 77, 12, 115, 220, 144, 102, 149, 78, 28}) } func (s *TestSuite) Test256Secret_384Key(c *C) { //when test:=DeriveConcatKDF(384,z,algId,partyUInfo,partyVInfo,arrays.UInt32ToBytes(384),nil,sha256.New()) //then c.Assert(test, DeepEquals, []byte{187, 16, 110, 253, 151, 199, 57, 235, 219, 8, 73, 191, 208, 108, 63, 241, 235, 137, 178, 149, 3, 199, 216, 99, 105, 217, 45, 114, 109, 213, 83, 198, 52, 101, 99, 146, 193, 31, 172, 157, 19, 140, 25, 202, 153, 92, 252, 192}) } func (s *TestSuite) Test256Secret_521Key(c *C) { //when test:=DeriveConcatKDF(521,z,algId,partyUInfo,partyVInfo,arrays.UInt32ToBytes(521),nil,sha256.New()) //then c.Assert(test, DeepEquals, []byte{245, 40, 159, 13, 25, 70, 170, 74, 210, 240, 242, 224, 37, 215, 23, 201, 126, 90, 108, 103, 205, 180, 48, 193, 131, 40, 86, 183, 97, 144, 1, 150, 154, 186, 196, 127, 6, 19, 17, 230, 75, 144, 229, 195, 61, 240, 20, 173, 167, 159, 50, 103, 133, 177, 241, 145, 134, 84, 50, 246, 157, 252, 51, 24, 35}) } func (s *TestSuite) Test384Secret_256Key(c *C) { //when test:=DeriveConcatKDF(256,z2,algId,partyUInfo,partyVInfo,arrays.UInt32ToBytes(256),nil,sha256.New()) //then c.Assert(test, DeepEquals, []byte{27, 55, 33, 99, 20, 191, 202, 69, 84, 176, 250, 108, 99, 7, 91, 49, 200, 47, 219, 142, 190, 216, 197, 154, 235, 17, 76, 12, 165, 75, 201, 108}) } //test utils func datalenFormat(str string) []byte { bytes,_:=base64url.Decode(str) return prependDatalen(bytes) } func prependDatalen(bytes []byte) []byte { return arrays.Concat(arrays.UInt32ToBytes(uint32(len(bytes))),bytes) }jose2go-1.5/kdf/pbkdf2.go000066400000000000000000000031521373537523000152030ustar00rootroot00000000000000// package kdf contains implementations of various key derivation functions package kdf import ( "crypto/hmac" "fmt" "hash" "math" "github.com/dvsekhvalnov/jose2go/arrays" ) // DerivePBKDF2 implements Password Based Key Derivation Function 2, RFC 2898. Derives key of keyBitLength size, given password, salt, iteration count and hash function func DerivePBKDF2(password, salt []byte, iterationCount, keyBitLength int, h func() hash.Hash) []byte { prf := hmac.New(h, password) hLen := prf.Size() dkLen := keyBitLength >> 3 //size of derived key in bytes l := int(math.Ceil(float64(dkLen) / float64(hLen))) // l = CEIL (dkLen / hLen) r := dkLen - (l-1)*hLen // 1. If dkLen > (2^32 - 1) * hLen, output "derived key too long" and stop. if dkLen > MaxInt { panic(fmt.Sprintf("kdf.DerivePBKDF2: expects derived key size to be not more that (2^32-1) bits, but was requested %v bits.", keyBitLength)) } dk := make([]byte, 0, dkLen) for i := 0; i < l; i++ { t := f(salt, iterationCount, i+1, prf) // T_l = F (P, S, c, l) if i == (l - 1) { t = t[:r] } // truncate last block to r bits dk = append(dk, t...) // DK = T_1 || T_2 || ... || T_l<0..r-1> } return dk } func f(salt []byte, iterationCount, blockIndex int, prf hash.Hash) []byte { prf.Reset() prf.Write(salt) prf.Write(arrays.UInt32ToBytes(uint32(blockIndex))) u := prf.Sum(nil) // U_1 = PRF (P, S || INT (i)) result := u for i := 2; i <= iterationCount; i++ { prf.Reset() prf.Write(u) u = prf.Sum(nil) // U_c = PRF (P, U_{c-1}) . result = arrays.Xor(result, u) // U_1 \xor U_2 \xor ... \xor U_c } return result } jose2go-1.5/kdf/pbkdf2_test.go000066400000000000000000000132031373537523000162400ustar00rootroot00000000000000package kdf import ( "crypto/sha256" "crypto/sha512" . "gopkg.in/check.v1" "testing" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) var password = []byte("password") var salt = []byte("salt") func (s *TestSuite) TestDerivePbkdf2Sha256Count1(c *C) { //when test := DerivePBKDF2(password, salt, 1, 256, sha256.New) //then c.Assert(test, DeepEquals, []byte{18, 15, 182, 207, 252, 248, 179, 44, 67, 231, 34, 82, 86, 196, 248, 55, 168, 101, 72, 201, 44, 204, 53, 72, 8, 5, 152, 124, 183, 11, 225, 123}) } func (s *TestSuite) TestDerivePbkdf2Sha256Count2(c *C) { //when test := DerivePBKDF2(password, salt, 2, 256, sha256.New) //then c.Assert(test, DeepEquals, []byte{174, 77, 12, 149, 175, 107, 70, 211, 45, 10, 223, 249, 40, 240, 109, 208, 42, 48, 63, 142, 243, 194, 81, 223, 214, 226, 216, 90, 149, 71, 76, 67}) } func (s *TestSuite) TestDerivePbkdf2Sha256Count4096(c *C) { //when test := DerivePBKDF2(password, salt, 4096, 256, sha256.New) //then c.Assert(test, DeepEquals, []byte{197, 228, 120, 213, 146, 136, 200, 65, 170, 83, 13, 182, 132, 92, 76, 141, 150, 40, 147, 160, 1, 206, 78, 17, 164, 150, 56, 115, 170, 152, 19, 74}) } func (s *TestSuite) TestDerivePbkdf2Sha256Count4096Len320(c *C) { //when test := DerivePBKDF2([]byte("passwordPASSWORDpassword"), []byte("saltSALTsaltSALTsaltSALTsaltSALTsalt"), 4096, 320, sha256.New) //then c.Assert(test, DeepEquals, []byte{52, 140, 137, 219, 203, 211, 43, 47, 50, 216, 20, 184, 17, 110, 132, 207, 43, 23, 52, 126, 188, 24, 0, 24, 28, 78, 42, 31, 184, 221, 83, 225, 198, 53, 81, 140, 125, 172, 71, 233}) } func (s *TestSuite) TestDerivePbkdf2Sha384Count1Len384(c *C) { //when test := DerivePBKDF2(password, salt, 1, 384, sha512.New384) //then c.Assert(test, DeepEquals, []byte{192, 225, 79, 6, 228, 158, 50, 215, 63, 159, 82, 221, 241, 208, 197, 199, 25, 22, 9, 35, 54, 49, 218, 221, 118, 165, 103, 219, 66, 183, 134, 118, 179, 143, 200, 0, 204, 83, 221, 182, 66, 245, 199, 68, 66, 230, 43, 228}) } func (s *TestSuite) TestDerivePbkdf2Sha384Count2Len384(c *C) { //when test := DerivePBKDF2(password, salt, 2, 384, sha512.New384) //then c.Assert(test, DeepEquals, []byte{84, 247, 117, 198, 215, 144, 242, 25, 48, 69, 145, 98, 252, 83, 93, 191, 4, 169, 57, 24, 81, 39, 1, 106, 4, 23, 106, 7, 48, 198, 241, 244, 251, 72, 131, 42, 209, 38, 27, 170, 221, 44, 237, 213, 8, 20, 177, 200}) } func (s *TestSuite) TestDerivePbkdf2Sha384Count4096Len384(c *C) { //when test := DerivePBKDF2(password, salt, 4096, 384, sha512.New384) //then c.Assert(test, DeepEquals, []byte{85, 151, 38, 190, 56, 219, 18, 91, 200, 94, 215, 137, 95, 110, 60, 245, 116, 199, 160, 28, 8, 12, 52, 71, 219, 30, 138, 118, 118, 77, 235, 60, 48, 123, 148, 133, 63, 190, 66, 79, 100, 136, 197, 244, 241, 40, 150, 38}) } func (s *TestSuite) TestDerivePbkdf2Sha384Count4096Len768(c *C) { //when test := DerivePBKDF2([]byte("passwordPASSWORDpassword"), []byte("saltSALTsaltSALTsaltSALTsaltSALTsalt"), 4096, 768, sha512.New384) //then c.Assert(test, DeepEquals, []byte{129, 145, 67, 173, 102, 223, 154, 85, 37, 89, 185, 225, 49, 197, 42, 230, 197, 193, 176, 238, 209, 143, 77, 40, 59, 140, 92, 158, 174, 185, 43, 57, 44, 20, 124, 194, 210, 134, 157, 88, 255, 226, 247, 218, 19, 209, 95, 141, 146, 87, 33, 240, 237, 26, 250, 250, 36, 72, 13, 85, 207, 96, 96, 177, 127, 17, 42, 61, 231, 76, 174, 37, 253, 243, 86, 158, 36, 127, 41, 228, 219, 184, 68, 33, 132, 120, 34, 234, 153, 189, 32, 40, 60, 58, 37, 166}) } func (s *TestSuite) TestDerivePbkdf2Sha512Count1Len512(c *C) { //when test := DerivePBKDF2(password, salt, 1, 512, sha512.New) //then c.Assert(test, DeepEquals, []byte{134, 127, 112, 207, 26, 222, 2, 207, 243, 117, 37, 153, 163, 165, 61, 196, 175, 52, 199, 166, 105, 129, 90, 229, 213, 19, 85, 78, 28, 140, 242, 82, 192, 45, 71, 10, 40, 90, 5, 1, 186, 217, 153, 191, 233, 67, 192, 143, 5, 2, 53, 215, 214, 139, 29, 165, 94, 99, 247, 59, 96, 165, 127, 206}) } func (s *TestSuite) TestDerivePbkdf2Sha512Count2Len512(c *C) { //when test := DerivePBKDF2(password, salt, 2, 512, sha512.New) //then c.Assert(test, DeepEquals, []byte{225, 217, 193, 106, 166, 129, 112, 138, 69, 245, 199, 196, 226, 21, 206, 182, 110, 1, 26, 46, 159, 0, 64, 113, 63, 24, 174, 253, 184, 102, 213, 60, 247, 108, 171, 40, 104, 163, 155, 159, 120, 64, 237, 206, 79, 239, 90, 130, 190, 103, 51, 92, 119, 166, 6, 142, 4, 17, 39, 84, 242, 124, 207, 78}) } func (s *TestSuite) TestDerivePbkdf2Sha512Count4096Len512(c *C) { //when test := DerivePBKDF2(password, salt, 4096, 512, sha512.New) //then c.Assert(test, DeepEquals, []byte{209, 151, 177, 179, 61, 176, 20, 62, 1, 139, 18, 243, 209, 209, 71, 158, 108, 222, 189, 204, 151, 197, 192, 248, 127, 105, 2, 224, 114, 244, 87, 181, 20, 63, 48, 96, 38, 65, 179, 213, 92, 211, 53, 152, 140, 179, 107, 132, 55, 96, 96, 236, 213, 50, 224, 57, 183, 66, 162, 57, 67, 74, 242, 213}) } func (s *TestSuite) TestDerivePbkdf2Sha256Count4096Len1024(c *C) { //when test := DerivePBKDF2([]byte("passwordPASSWORDpassword"), []byte("saltSALTsaltSALTsaltSALTsaltSALTsalt"), 4096, 1024, sha512.New) //then c.Assert(test, DeepEquals, []byte{140, 5, 17, 244, 198, 229, 151, 198, 172, 99, 21, 216, 240, 54, 46, 34, 95, 60, 80, 20, 149, 186, 35, 184, 104, 192, 5, 23, 77, 196, 238, 113, 17, 91, 89, 249, 230, 12, 217, 83, 47, 163, 62, 15, 117, 174, 254, 48, 34, 92, 88, 58, 24, 108, 216, 43, 212, 218, 234, 151, 36, 163, 211, 184, 4, 247, 91, 221, 65, 73, 79, 163, 36, 202, 178, 75, 204, 104, 15, 179, 185, 106, 48, 207, 93, 33, 250, 195, 194, 135, 89, 19, 145, 159, 51, 153, 177, 217, 206, 126, 181, 76, 149, 186, 73, 17, 133, 150, 207, 116, 101, 113, 155, 190, 2, 196, 236, 171, 27, 21, 65, 41, 140, 50, 29, 19, 198, 246}) } jose2go-1.5/keys/000077500000000000000000000000001373537523000137125ustar00rootroot00000000000000jose2go-1.5/keys/ecc/000077500000000000000000000000001373537523000144445ustar00rootroot00000000000000jose2go-1.5/keys/ecc/ec_cert.pem000066400000000000000000000014461373537523000165600ustar00rootroot00000000000000-----BEGIN CERTIFICATE----- MIICJjCCAc6gAwIBAgIJAOCtH/xv+cfpMAkGByqGSM49BAEwRTELMAkGA1UEBhMC QVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoTGEludGVybmV0IFdpZGdp dHMgUHR5IEx0ZDAeFw0xNDA4MTIxMTU5MTVaFw0xODA1MDgxMTU5MTVaMEUxCzAJ BgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5l dCBXaWRnaXRzIFB0eSBMdGQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASqGi1p Eudyh+Nw//zeAGIYSQG/H/q/x6Xz2TIg3GN4hbD5BS1f4/vEitpui+TpmtJyggzo x5D55N9kjq0X/hyyo4GnMIGkMB0GA1UdDgQWBBQvGSEecx9JdDECRIorVpeWy7oA ujB1BgNVHSMEbjBsgBQvGSEecx9JdDECRIorVpeWy7oAuqFJpEcwRTELMAkGA1UE BhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUxITAfBgNVBAoTGEludGVybmV0IFdp ZGdpdHMgUHR5IEx0ZIIJAOCtH/xv+cfpMAwGA1UdEwQFMAMBAf8wCQYHKoZIzj0E AQNHADBEAiAUQheZrGjbsy6PfpWGZEhTFzqvBVXtbqtz+6aTkOCrCQIgLfvw9C+0 SDn/abV4NtgYOM0OLkoNRTCIzzguHxhhaJ4= -----END CERTIFICATE----- jose2go-1.5/keys/ecc/ec_private.key000066400000000000000000000003431373537523000172770ustar00rootroot00000000000000-----BEGIN EC PRIVATE KEY----- MHcCAQEEIA/32XgQpS/tKRhw8jSdr8ivBmMyD/vbG5KT3s3XPArcoAoGCCqGSM49 AwEHoUQDQgAEqhotaRLncofjcP/83gBiGEkBvx/6v8el89kyINxjeIWw+QUtX+P7 xIrabovk6ZrScoIM6MeQ+eTfZI6tF/4csg== -----END EC PRIVATE KEY----- jose2go-1.5/keys/ecc/ec_private.pem000066400000000000000000000003611373537523000172700ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgD/fZeBClL+0pGHDy NJ2vyK8GYzIP+9sbkpPezdc8CtyhRANCAASqGi1pEudyh+Nw//zeAGIYSQG/H/q/ x6Xz2TIg3GN4hbD5BS1f4/vEitpui+TpmtJyggzox5D55N9kjq0X/hyy -----END PRIVATE KEY----- jose2go-1.5/keys/ecc/ec_public.key000066400000000000000000000002621373537523000171030ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqhotaRLncofjcP/83gBiGEkBvx/6 v8el89kyINxjeIWw+QUtX+P7xIrabovk6ZrScoIM6MeQ+eTfZI6tF/4csg== -----END PUBLIC KEY----- jose2go-1.5/keys/ecc/ecc.go000066400000000000000000000046041373537523000155310ustar00rootroot00000000000000//package ecc provides helpers for creating elliptic curve leys package ecc import ( "math/big" "crypto/ecdsa" "crypto/elliptic" "crypto/x509" "encoding/pem" "errors" ) // ReadPublic loads ecdsa.PublicKey from given PKCS1 X509 or PKIX blobs func ReadPublic(raw []byte) (key *ecdsa.PublicKey,err error) { var encoded *pem.Block if encoded, _ = pem.Decode(raw); encoded == nil { return nil, errors.New("Ecc.ReadPublic(): Key must be PEM encoded PKCS1 X509 certificate or PKIX EC public key") } var parsedKey interface{} var cert *x509.Certificate if parsedKey, err = x509.ParsePKIXPublicKey(encoded.Bytes); err != nil { if cert,err = x509.ParseCertificate(encoded.Bytes);err!=nil { return nil, err } parsedKey=cert.PublicKey } var ok bool if key, ok = parsedKey.(*ecdsa.PublicKey); !ok { return nil, errors.New("Ecc.ReadPublic(): Key is not a valid *ecdsa.PublicKey") } return key, nil } // ReadPrivate loads ecdsa.PrivateKey from given PKCS1 or PKCS8 blobs func ReadPrivate(raw []byte) (key *ecdsa.PrivateKey,err error) { var encoded *pem.Block if encoded, _ = pem.Decode(raw); encoded == nil { return nil, errors.New("Ecc.ReadPrivate(): Key must be PEM encoded PKCS1 or PKCS8 EC private key") } var parsedKey interface{} if parsedKey,err=x509.ParseECPrivateKey(encoded.Bytes);err!=nil { if parsedKey, err = x509.ParsePKCS8PrivateKey(encoded.Bytes);err!=nil { return nil,err } } var ok bool if key,ok=parsedKey.(*ecdsa.PrivateKey);!ok { return nil, errors.New("Ecc.ReadPrivate(): Key is not valid *ecdsa.PrivateKey") } return key,nil } // NewPublic constructs ecdsa.PublicKey from given (X,Y) func NewPublic(x,y []byte) (*ecdsa.PublicKey) { return &ecdsa.PublicKey{ Curve: curve(len(x)), X:new(big.Int).SetBytes(x), Y:new(big.Int).SetBytes(y) } } // NewPrivate constructs ecdsa.PrivateKey from given (X,Y) and D func NewPrivate(x,y,d []byte) (*ecdsa.PrivateKey) { return &ecdsa.PrivateKey {D:new(big.Int).SetBytes(d), PublicKey: ecdsa.PublicKey{ Curve:curve(len(x)), X:new(big.Int).SetBytes(x), Y:new(big.Int).SetBytes(y)}} } func curve(size int) (elliptic.Curve) { switch size { case 32: return elliptic.P256() case 48: return elliptic.P384() case 65,66: return elliptic.P521() //adjust for P-521 curve, which can be 65 or 66 bytes default: return nil //unsupported curve } }jose2go-1.5/keys/ecc/ecc_test.go000066400000000000000000000077561373537523000166030ustar00rootroot00000000000000package ecc import ( "testing" . "gopkg.in/check.v1" "io/ioutil" "math/big" "crypto/elliptic" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestNewPublic(c *C) { //given x:=[]byte {4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9} y:=[]byte {131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53} //when test:=NewPublic(x,y) //then c.Assert(test.X, DeepEquals, bigInt("2010878128539620107131539503221291822343443356718189500659356750794038206985")) c.Assert(test.Y, DeepEquals, bigInt("59457993017710823357637488495120101390437944162821778556218889662829000218677")) c.Assert(test.Curve, Equals, elliptic.P256()) } func (s *TestSuite) TestNewPrivate(c *C) { //given x:=[]byte {4, 114, 29, 223, 58, 3, 191, 170, 67, 128, 229, 33, 242, 178, 157, 150, 133, 25, 209, 139, 166, 69, 55, 26, 84, 48, 169, 165, 67, 232, 98, 9} y:=[]byte {131, 116, 8, 14, 22, 150, 18, 75, 24, 181, 159, 78, 90, 51, 71, 159, 214, 186, 250, 47, 207, 246, 142, 127, 54, 183, 72, 72, 253, 21, 88, 53} d:=[]byte{ 42, 148, 231, 48, 225, 196, 166, 201, 23, 190, 229, 199, 20, 39, 226, 70, 209, 148, 29, 70, 125, 14, 174, 66, 9, 198, 80, 251, 95, 107, 98, 206 } //when test:=NewPrivate(x,y,d) //then c.Assert(test.X, DeepEquals, bigInt("2010878128539620107131539503221291822343443356718189500659356750794038206985")) c.Assert(test.Y, DeepEquals, bigInt("59457993017710823357637488495120101390437944162821778556218889662829000218677")) c.Assert(test.D, DeepEquals, bigInt("19260228627344101198652694952536756709538941185117188878548538012226554651342")) c.Assert(test.Curve, Equals, elliptic.P256()) } func (s *TestSuite) TestReadPublicPKIX(c *C) { //given keyBytes, _ := ioutil.ReadFile("./ec_public.key") //when test,e := ReadPublic(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.X, DeepEquals, bigInt("76939435694210362824363841832595476784225842365248086547769733757874741672069")) c.Assert(test.Y, DeepEquals, bigInt("80047042001812490693675653292813886154388201612539715595028491948003157744818")) c.Assert(test.Curve, Equals, elliptic.P256()) } func (s *TestSuite) TestReadPublicPKCS1(c *C) { //given keyBytes, _ := ioutil.ReadFile("./ec_cert.pem") //when test,e := ReadPublic(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.X, DeepEquals, bigInt("76939435694210362824363841832595476784225842365248086547769733757874741672069")) c.Assert(test.Y, DeepEquals, bigInt("80047042001812490693675653292813886154388201612539715595028491948003157744818")) c.Assert(test.Curve, Equals, elliptic.P256()) } func (s *TestSuite) TestReadPrivatePKCS1(c *C) { //given keyBytes, _ := ioutil.ReadFile("./ec_private.key") //when test,e := ReadPrivate(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.X, DeepEquals, bigInt("76939435694210362824363841832595476784225842365248086547769733757874741672069")) c.Assert(test.Y, DeepEquals, bigInt("80047042001812490693675653292813886154388201612539715595028491948003157744818")) c.Assert(test.D, DeepEquals, bigInt("7222604869653061109880849859470152714201198955914263913554931724612175399644")) c.Assert(test.Curve, Equals, elliptic.P256()) } func (s *TestSuite) TestReadPrivatePKCS8(c *C) { //given keyBytes, _ := ioutil.ReadFile("./ec_private.pem") //when test,e := ReadPrivate(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.X, DeepEquals, bigInt("76939435694210362824363841832595476784225842365248086547769733757874741672069")) c.Assert(test.Y, DeepEquals, bigInt("80047042001812490693675653292813886154388201612539715595028491948003157744818")) c.Assert(test.D, DeepEquals, bigInt("7222604869653061109880849859470152714201198955914263913554931724612175399644")) c.Assert(test.Curve, Equals, elliptic.P256()) } //utils func bigInt(value string) *big.Int { i:=new (big.Int) i.SetString(value,10) return i }jose2go-1.5/keys/rsa/000077500000000000000000000000001373537523000144775ustar00rootroot00000000000000jose2go-1.5/keys/rsa/priv.key000066400000000000000000000016241373537523000161740ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALx97GSHCGkevvUS sXMscNd+08MjO8BbkrzzlDuokJzVvQQprSEFYCO1ojp1UheAImeQvMe1wAWrGNfb Fw34jQCSkv8liWLh5aHqHPrU8DTgKsL+XjHGaMwsg8y68pEmZrpyV/N49yXKlh3C 1PLnFJrTmZq0PHLqOXINNvMWFv7jAgMBAAECgYEAsYc0RzY7AK7ZkX7KrLw1h3FH R2n+09wrp1UOzuWjVmOkw6/xBMHIW7mtkrt+1u1y+fIDK2GN+oi8PEl4PEtVmI8L jaExLu5fsp/Z+BbHfcs4L5So9pdGZn5Dhfh606LWRZ0qqSjdtXitpNMrjx736+Jt J6/kHlCdmYDyThtljbECQQDoDDAznyi6Yl2T+taoi2VcCP7wFAIYf3Mu6nqiEBhc p1lVOuWjyR+mBU8+o6hDs40oVAOdpCdqtDJ3ppWABKKZAkEAz/LIq8Uwq8ephNwn WOSuhkjUz+O01v74GHyS6tc7WGckFR7JS1cughXlRRq7hD1z1dhTYq0W2g4Yrujf GFTW2wJBAIwtQLkOfqYJYgpQz3fFrZdpf8g77gAqjcRbtXVNT8o49gg8qhjFGK9M KdDnQHCVeMJR7lU+oukcrhgFs+4/3pECQBcvX5ZfPwT4Fvt8PFrZ7GeGeUvQfJo4 BVtdkFfktXYu0cQVEaZ3yvSwEkb5Kw0ceOzP2MQ4vkKDrdbamf0xgF8CQFiz2P8h Vq/Q3fFKCWamZ1olx08zo4x4y2kYKO275GSZabhiVoulVhUtRgi9BcPfW9kakqps wEe4//EeSbl38Bk= -----END PRIVATE KEY----- jose2go-1.5/keys/rsa/priv.pem000066400000000000000000000015671373537523000161730ustar00rootroot00000000000000-----BEGIN RSA PRIVATE KEY----- MIICXQIBAAKBgQC8fexkhwhpHr71ErFzLHDXftPDIzvAW5K885Q7qJCc1b0EKa0h BWAjtaI6dVIXgCJnkLzHtcAFqxjX2xcN+I0AkpL/JYli4eWh6hz61PA04CrC/l4x xmjMLIPMuvKRJma6clfzePclypYdwtTy5xSa05matDxy6jlyDTbzFhb+4wIDAQAB AoGBALGHNEc2OwCu2ZF+yqy8NYdxR0dp/tPcK6dVDs7lo1ZjpMOv8QTByFu5rZK7 ftbtcvnyAythjfqIvDxJeDxLVZiPC42hMS7uX7Kf2fgWx33LOC+UqPaXRmZ+Q4X4 etOi1kWdKqko3bV4raTTK48e9+vibSev5B5QnZmA8k4bZY2xAkEA6AwwM58oumJd k/rWqItlXAj+8BQCGH9zLup6ohAYXKdZVTrlo8kfpgVPPqOoQ7ONKFQDnaQnarQy d6aVgASimQJBAM/yyKvFMKvHqYTcJ1jkroZI1M/jtNb++Bh8kurXO1hnJBUeyUtX LoIV5UUau4Q9c9XYU2KtFtoOGK7o3xhU1tsCQQCMLUC5Dn6mCWIKUM93xa2XaX/I O+4AKo3EW7V1TU/KOPYIPKoYxRivTCnQ50BwlXjCUe5VPqLpHK4YBbPuP96RAkAX L1+WXz8E+Bb7fDxa2exnhnlL0HyaOAVbXZBX5LV2LtHEFRGmd8r0sBJG+SsNHHjs z9jEOL5Cg63W2pn9MYBfAkBYs9j/IVav0N3xSglmpmdaJcdPM6OMeMtpGCjtu+Rk mWm4YlaLpVYVLUYIvQXD31vZGpKqbMBHuP/xHkm5d/AZ -----END RSA PRIVATE KEY----- jose2go-1.5/keys/rsa/pub.key000066400000000000000000000004201373537523000157730ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8fexkhwhpHr71ErFzLHDXftPD IzvAW5K885Q7qJCc1b0EKa0hBWAjtaI6dVIXgCJnkLzHtcAFqxjX2xcN+I0AkpL/ JYli4eWh6hz61PA04CrC/l4xxmjMLIPMuvKRJma6clfzePclypYdwtTy5xSa05ma tDxy6jlyDTbzFhb+4wIDAQAB -----END PUBLIC KEY----- jose2go-1.5/keys/rsa/pub.pem000066400000000000000000000011301373537523000157630ustar00rootroot00000000000000-----BEGIN CERTIFICATE----- MIIBjTCB9wIEchk3tjANBgkqhkiG9w0BAQUFADAOMQwwCgYDVQQDEwNqd3QwHhcN MTQwMTA4MTM0NDUxWhcNMTUwMjA3MjAwMDAwWjAOMQwwCgYDVQQDEwNqd3QwgZ8w DQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALx97GSHCGkevvUSsXMscNd+08MjO8Bb krzzlDuokJzVvQQprSEFYCO1ojp1UheAImeQvMe1wAWrGNfbFw34jQCSkv8liWLh 5aHqHPrU8DTgKsL+XjHGaMwsg8y68pEmZrpyV/N49yXKlh3C1PLnFJrTmZq0PHLq OXINNvMWFv7jAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAJcAJ4zK0ZZLUHRdxhQdj e0Xv7fPYosE7gV0apbPJXnuhU1XH4XKFQQNYWyxjwfFSjghAyyZqlfcWgl0STOXx JnFfEbSQL1EB5xKj9e1taMd+84mFXkVNvhN3wphe3EbPr9M99BRLic/MSGAqnJRS OPIdhqg16dZmPJ4kCG8lLmc= -----END CERTIFICATE----- jose2go-1.5/keys/rsa/rsa.go000066400000000000000000000030101373537523000156050ustar00rootroot00000000000000//package Rsa provides helpers for creating rsa leys package Rsa import ( "crypto/rsa" "crypto/x509" "encoding/pem" "errors" ) // ReadPrivate loads rsa.PrivateKey from PKCS1 or PKCS8 blobs func ReadPrivate(raw []byte) (key *rsa.PrivateKey,err error) { var encoded *pem.Block if encoded, _ = pem.Decode(raw); encoded == nil { return nil, errors.New("Rsa.NewPrivate(): Key must be PEM encoded PKCS1 or PKCS8 private key") } var parsedKey interface{} if parsedKey,err=x509.ParsePKCS1PrivateKey(encoded.Bytes);err!=nil { if parsedKey, err = x509.ParsePKCS8PrivateKey(encoded.Bytes);err!=nil { return nil,err } } var ok bool if key,ok=parsedKey.(*rsa.PrivateKey);!ok { return nil, errors.New("Rsa.NewPrivate(): Key is not valid *rsa.PrivateKey") } return key,nil } // ReadPublic loads rsa.PublicKey from PKIX or PKCS1 X509 blobs func ReadPublic(raw []byte) (key *rsa.PublicKey,err error) { var encoded *pem.Block if encoded, _ = pem.Decode(raw); encoded == nil { return nil, errors.New("Rsa.NewPublic(): Key must be PEM encoded PKCS1 X509 certificate or PKIX public key") } var parsedKey interface{} var cert *x509.Certificate if parsedKey, err = x509.ParsePKIXPublicKey(encoded.Bytes); err != nil { if cert,err = x509.ParseCertificate(encoded.Bytes);err!=nil { return nil, err } parsedKey=cert.PublicKey } var ok bool if key, ok = parsedKey.(*rsa.PublicKey); !ok { return nil, errors.New("Rsa.NewPublic(): Key is not a valid RSA public key") } return key, nil }jose2go-1.5/keys/rsa/rsa_test.go000066400000000000000000000100641373537523000166530ustar00rootroot00000000000000package Rsa import ( "io/ioutil" "math/big" "testing" . "gopkg.in/check.v1" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestNewPrivateRsaKeyPKCS1(c *C) { //given keyBytes, _ := ioutil.ReadFile("priv.pem") //when test,e := ReadPrivate(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.D, DeepEquals, bigInt("124664500442337916425629948081980373708538939606058968438393904444884872144817323585651521088406960965803456218656807473171367526874204593887158860695954252405916280866383288176587587469870736553178754458686625418367566925639753001190058223163696966510495553421774149906056482201169970508069587759758018186673")) c.Assert(test.Primes, HasLen, 2) c.Assert(test.Primes[0], DeepEquals, bigInt("12153319500662601635346432957857245055929638609873673015885135318360261418965835817520733410832489021447922460160007366037402643276624674886502627435389593")) c.Assert(test.Primes[1], DeepEquals, bigInt("10891140096045830766355607974974880425030121636560867106153739255802668290122259699296919947637286459736524694263050343032461619592457541146877906031793883")) c.Assert(test.E, Equals, 65537) c.Assert(test.N, DeepEquals, bigInt("132363505313722155184876628715249052276006747427497555521215412160460427148722445294983292629743653314149228192824806664548107146354876411009845771623017501212568714555984634301944063168503260813720165931647377932654326833738173931173570212088015547040743996672392373035728084429156775233489529905624779259619")) } func (s *TestSuite) TestNewPrivateRsaKeyPKCS8(c *C) { //given keyBytes, _ := ioutil.ReadFile("priv.pem") //when test,e := ReadPrivate(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.D, DeepEquals, bigInt("124664500442337916425629948081980373708538939606058968438393904444884872144817323585651521088406960965803456218656807473171367526874204593887158860695954252405916280866383288176587587469870736553178754458686625418367566925639753001190058223163696966510495553421774149906056482201169970508069587759758018186673")) c.Assert(test.Primes, HasLen, 2) c.Assert(test.Primes[0], DeepEquals, bigInt("12153319500662601635346432957857245055929638609873673015885135318360261418965835817520733410832489021447922460160007366037402643276624674886502627435389593")) c.Assert(test.Primes[1], DeepEquals, bigInt("10891140096045830766355607974974880425030121636560867106153739255802668290122259699296919947637286459736524694263050343032461619592457541146877906031793883")) c.Assert(test.E, Equals, 65537) c.Assert(test.N, DeepEquals, bigInt("132363505313722155184876628715249052276006747427497555521215412160460427148722445294983292629743653314149228192824806664548107146354876411009845771623017501212568714555984634301944063168503260813720165931647377932654326833738173931173570212088015547040743996672392373035728084429156775233489529905624779259619")) } func (s *TestSuite) TestNewPublicRsaKeyPKCS1(c *C) { //given keyBytes, _ := ioutil.ReadFile("pub.pem") //when test,e := ReadPublic(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.E, Equals, 65537) c.Assert(test.N, DeepEquals, bigInt("132363505313722155184876628715249052276006747427497555521215412160460427148722445294983292629743653314149228192824806664548107146354876411009845771623017501212568714555984634301944063168503260813720165931647377932654326833738173931173570212088015547040743996672392373035728084429156775233489529905624779259619")) } func (s *TestSuite) TestNewPublicRsaKeyPKIX(c *C) { //given keyBytes, _ := ioutil.ReadFile("pub.key") //when test,e := ReadPublic(keyBytes) //then c.Assert(e, IsNil) c.Assert(test.E, Equals, 65537) c.Assert(test.N, DeepEquals, bigInt("132363505313722155184876628715249052276006747427497555521215412160460427148722445294983292629743653314149228192824806664548107146354876411009845771623017501212568714555984634301944063168503260813720165931647377932654326833738173931173570212088015547040743996672392373035728084429156775233489529905624779259619")) } //utils func bigInt(value string) *big.Int { i:=new (big.Int) i.SetString(value,10) return i }jose2go-1.5/padding/000077500000000000000000000000001373537523000143455ustar00rootroot00000000000000jose2go-1.5/padding/align.go000066400000000000000000000007051373537523000157700ustar00rootroot00000000000000// package padding provides various padding algorithms package padding import ( "bytes" ) // Align left pads given byte array with zeros till it have at least bitSize length. func Align(data []byte, bitSize int) []byte { actual:=len(data) required:=bitSize >> 3 if (bitSize % 8) > 0 { required++ //extra byte if needed } if (actual >= required) { return data } return append(bytes.Repeat([]byte{0}, required-actual), data...) }jose2go-1.5/padding/align_test.go000066400000000000000000000013371373537523000170310ustar00rootroot00000000000000package padding import ( . "gopkg.in/check.v1" ) func (s *TestSuite) TestAlignOneByte(c *C) { //given data:=[]byte{1,2,3} //when test:=Align(data,27) //then c.Assert(test, DeepEquals, []byte{0,1,2,3}) } func (s *TestSuite) TestAlignMultiByte(c *C) { //given data:=[]byte{1,2,3} //when test:=Align(data,40) //then c.Assert(test, DeepEquals, []byte{0,0,1,2,3}) } func (s *TestSuite) TestAlignMultiBytePartial(c *C) { //given data:=[]byte{1,2,3} //when test:=Align(data,43) //then c.Assert(test, DeepEquals, []byte{0,0,0,1,2,3}) } func (s *TestSuite) TestAlignedArray(c *C) { //given data:=[]byte{1,2,3} //when test:=Align(data,24) //then c.Assert(test, DeepEquals, []byte{1,2,3}) }jose2go-1.5/padding/pkcs7.go000066400000000000000000000017551373537523000157330ustar00rootroot00000000000000package padding import ( "bytes" ) // AddPkcs7 pads given byte array using pkcs7 padding schema till it has blockSize length in bytes func AddPkcs7(data []byte, blockSize int) []byte { var paddingCount int if paddingCount = blockSize - (len(data) % blockSize);paddingCount == 0 { paddingCount=blockSize } return append(data, bytes.Repeat([]byte{byte(paddingCount)}, paddingCount)...) } // RemovePkcs7 removes pkcs7 padding from previously padded byte array func RemovePkcs7(padded []byte, blockSize int) []byte { dataLen:=len(padded) paddingCount:=int(padded[dataLen-1]) if(paddingCount > blockSize || paddingCount <= 0) { return padded //data is not padded (or not padded correctly), return as is } padding := padded[dataLen-paddingCount : dataLen-1] for _, b := range padding { if int(b) != paddingCount { return padded //data is not padded (or not padded correcly), return as is } } return padded[:len(padded)-paddingCount] //return data - padding }jose2go-1.5/padding/pkcs7_test.go000066400000000000000000000036121373537523000167640ustar00rootroot00000000000000package padding import ( "testing" . "gopkg.in/check.v1" ) func Test(t *testing.T) { TestingT(t) } type TestSuite struct{} var _ = Suite(&TestSuite{}) func (s *TestSuite) TestRemovePkcs7NoPadding(c *C) { //given padded:=[]byte{1,2,3,4,5,6,7,8} //when test:=RemovePkcs7(padded,8) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,6,7,8}) } func (s *TestSuite) TestRemovePkcs7(c *C) { //given padded:=[]byte{1,2,3,4,5,3,3,3} //when test:=RemovePkcs7(padded,8) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5}) } func (s *TestSuite) TestRemovePkcs7OneBytePadding(c *C) { //given padded:=[]byte{1,2,3,4,5,1} //when test:=RemovePkcs7(padded,6) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5}) } func (s *TestSuite) TestRemovePkcs7TrailingZeroByte(c *C) { //given padded:=[]byte{1,2,3,4,5,0} //when test:=RemovePkcs7(padded,6) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,0}) } func (s *TestSuite) TestRemovePkcs7ExtraBlockPadding(c *C) { //given padded:=[]byte{1,2,3,4,5,5,5,5,5,5} //when test:=RemovePkcs7(padded,5) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5}) } func (s *TestSuite) TestRemovePkcs7TrailingByteGreaterBlockSize(c *C) { //given padded:=[]byte{1,2,3,4,5,10} //when test:=RemovePkcs7(padded,6) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,10}) } func (s *TestSuite) TestAddPkcs7(c *C) { //given in:=[]byte{1,2,3,4,5} //when test := AddPkcs7(in,8) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,3,3,3}) } func (s *TestSuite) TestAddPkcs7OneBytePadding(c *C) { //given in:=[]byte{1,2,3,4,5} //when test := AddPkcs7(in,6) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,1}) } func (s *TestSuite) TestAddPkcs7ExtraBlockPadding(c *C) { //given in:=[]byte{1,2,3,4,5,6,7,8} //when test := AddPkcs7(in,8) //then c.Assert(test, DeepEquals, []byte{1,2,3,4,5,6,7,8,8,8,8,8,8,8,8,8}) }jose2go-1.5/pbse2_hmac_aeskw.go000066400000000000000000000052331373537523000164660ustar00rootroot00000000000000package jose import ( "crypto/sha256" "crypto/sha512" "errors" "hash" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/base64url" "github.com/dvsekhvalnov/jose2go/kdf" ) func init() { RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 128, aesKW: &AesKW{keySizeBits: 128}}) RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 192, aesKW: &AesKW{keySizeBits: 192}}) RegisterJwa(&Pbse2HmacAesKW{keySizeBits: 256, aesKW: &AesKW{keySizeBits: 256}}) } // PBSE2 with HMAC key management algorithm implementation type Pbse2HmacAesKW struct { keySizeBits int aesKW JwaAlgorithm } func (alg *Pbse2HmacAesKW) Name() string { switch alg.keySizeBits { case 128: return PBES2_HS256_A128KW case 192: return PBES2_HS384_A192KW default: return PBES2_HS512_A256KW } } func (alg *Pbse2HmacAesKW) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if passphrase, ok := key.(string); ok { algId := []byte(header["alg"].(string)) iterationCount := 8192 var saltInput []byte if saltInput, err = arrays.Random(12); err != nil { return nil, nil, err } header["p2c"] = iterationCount header["p2s"] = base64url.Encode(saltInput) salt := arrays.Concat(algId, []byte{0}, saltInput) kek := kdf.DerivePBKDF2([]byte(passphrase), salt, iterationCount, alg.keySizeBits, alg.prf) return alg.aesKW.WrapNewKey(cekSizeBits, kek, header) } return nil, nil, errors.New("Pbse2HmacAesKW.WrapNewKey(): expected key to be 'string' array") } func (alg *Pbse2HmacAesKW) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if passphrase, ok := key.(string); ok { var p2s string var p2c float64 if p2c, ok = header["p2c"].(float64); !ok { return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected 'p2c' param in JWT header, but was not found.") } if p2s, ok = header["p2s"].(string); !ok { return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected 'p2s' param in JWT header, but was not found.") } var saltInput []byte algId := []byte(header["alg"].(string)) if saltInput, err = base64url.Decode(p2s); err != nil { return nil, err } salt := arrays.Concat(algId, []byte{0}, saltInput) kek := kdf.DerivePBKDF2([]byte(passphrase), salt, int(p2c), alg.keySizeBits, alg.prf) return alg.aesKW.Unwrap(encryptedCek, kek, cekSizeBits, header) } return nil, errors.New("Pbse2HmacAesKW.Unwrap(): expected key to be 'string' array") } func (alg *Pbse2HmacAesKW) prf() hash.Hash { switch alg.keySizeBits { case 128: return sha256.New() case 192: return sha512.New384() default: return sha512.New() } } jose2go-1.5/plaintext.go000066400000000000000000000013311373537523000152740ustar00rootroot00000000000000package jose import ( "errors" ) // Plaintext (no signing) signing algorithm implementation type Plaintext struct{} func init() { RegisterJws(new(Plaintext)) } func (alg *Plaintext) Name() string { return NONE } func (alg *Plaintext) Verify(securedInput []byte, signature []byte, key interface{}) error { if key != nil { return errors.New("Plaintext.Verify() expects key to be nil") } if len(signature) != 0 { return errors.New("Plaintext.Verify() expects signature to be empty.") } return nil } func (alg *Plaintext) Sign(securedInput []byte, key interface{}) (signature []byte, err error) { if key != nil { return nil, errors.New("Plaintext.Verify() expects key to be nil") } return []byte{}, nil } jose2go-1.5/rsa_oaep.go000066400000000000000000000026231373537523000150620ustar00rootroot00000000000000package jose import ( "errors" "crypto/rsa" "crypto/rand" "hash" "crypto/sha1" "crypto/sha256" "github.com/dvsekhvalnov/jose2go/arrays" ) // RS-AES using OAEP key management algorithm implementation func init() { RegisterJwa(&RsaOaep {shaSizeBits:1}) RegisterJwa(&RsaOaep {shaSizeBits:256}) } type RsaOaep struct{ shaSizeBits int // func shaF() hash.Hash } func (alg *RsaOaep) Name() string { switch alg.shaSizeBits { case 1: return RSA_OAEP default: return RSA_OAEP_256 } } func (alg *RsaOaep) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if pubKey,ok:=key.(*rsa.PublicKey);ok { if cek,err = arrays.Random(cekSizeBits>>3);err==nil { encryptedCek,err=rsa.EncryptOAEP(alg.sha(),rand.Reader,pubKey,cek,nil) return } return nil,nil,err } return nil,nil,errors.New("RsaOaep.WrapNewKey(): expected key to be '*rsa.PublicKey'") } func (alg *RsaOaep) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if privKey,ok:=key.(*rsa.PrivateKey);ok { return rsa.DecryptOAEP(alg.sha(), rand.Reader, privKey, encryptedCek, nil) } return nil,errors.New("RsaOaep.Unwrap(): expected key to be '*rsa.PrivateKey'") } func (alg *RsaOaep) sha() hash.Hash { switch alg.shaSizeBits { case 1: return sha1.New() default: return sha256.New() } } jose2go-1.5/rsa_pkcs1v15.go000066400000000000000000000021351373537523000155110ustar00rootroot00000000000000package jose import ( "errors" "crypto/rsa" "crypto/rand" "github.com/dvsekhvalnov/jose2go/arrays" ) func init() { RegisterJwa(new(RsaPkcs1v15)) } // RS-AES using PKCS #1 v1.5 padding key management algorithm implementation type RsaPkcs1v15 struct{ } func (alg *RsaPkcs1v15) Name() string { return RSA1_5 } func (alg *RsaPkcs1v15) WrapNewKey(cekSizeBits int, key interface{}, header map[string]interface{}) (cek []byte, encryptedCek []byte, err error) { if pubKey,ok:=key.(*rsa.PublicKey);ok { if cek,err = arrays.Random(cekSizeBits>>3);err==nil { encryptedCek,err=rsa.EncryptPKCS1v15(rand.Reader,pubKey,cek) return } return nil,nil,err } return nil,nil,errors.New("RsaPkcs1v15.WrapNewKey(): expected key to be '*rsa.PublicKey'") } func (alg *RsaPkcs1v15) Unwrap(encryptedCek []byte, key interface{}, cekSizeBits int, header map[string]interface{}) (cek []byte, err error) { if privKey,ok:=key.(*rsa.PrivateKey);ok { return rsa.DecryptPKCS1v15(rand.Reader,privKey,encryptedCek) } return nil,errors.New("RsaPkcs1v15.Unwrap(): expected key to be '*rsa.PrivateKey'") } jose2go-1.5/rsa_using_sha.go000066400000000000000000000023731373537523000161200ustar00rootroot00000000000000package jose import ( "crypto/rand" "crypto/rsa" "errors" ) func init() { RegisterJws(&RsaUsingSha{keySizeBits: 256}) RegisterJws(&RsaUsingSha{keySizeBits: 384}) RegisterJws(&RsaUsingSha{keySizeBits: 512}) } // RSA using SHA signature algorithm implementation type RsaUsingSha struct{ keySizeBits int } func (alg *RsaUsingSha) Name() string { switch alg.keySizeBits { case 256: return RS256 case 384: return RS384 default: return RS512 } } func (alg *RsaUsingSha) Verify(securedInput, signature []byte, key interface{}) error { if pubKey,ok:=key.(*rsa.PublicKey);ok { return rsa.VerifyPKCS1v15(pubKey, hashFunc(alg.keySizeBits), sha(alg.keySizeBits, securedInput), signature) } return errors.New("RsaUsingSha.Verify(): expects key to be '*rsa.PublicKey'") } func (alg *RsaUsingSha) Sign(securedInput []byte, key interface{}) (signature []byte, err error) { if privKey,ok:=key.(*rsa.PrivateKey);ok { return rsa.SignPKCS1v15(rand.Reader, privKey, hashFunc(alg.keySizeBits), sha(alg.keySizeBits, securedInput)) } return nil,errors.New("RsaUsingSha.Sign(): expects key to be '*rsa.PrivateKey'") } func sha(keySizeBits int, input []byte) (hash []byte) { hasher := hashAlg(keySizeBits) hasher.Write(input) return hasher.Sum(nil) }jose2go-1.5/rsapss_using_sha.go000066400000000000000000000024601373537523000166430ustar00rootroot00000000000000package jose import ( "crypto/rand" "crypto/rsa" "errors" ) func init() { RegisterJws(&RsaPssUsingSha{keySizeBits: 256, saltSizeBytes: 32}) RegisterJws(&RsaPssUsingSha{keySizeBits: 384, saltSizeBytes: 48}) RegisterJws(&RsaPssUsingSha{keySizeBits: 512, saltSizeBytes: 64}) } // RSA with PSS using SHA signing algorithm implementation type RsaPssUsingSha struct{ keySizeBits int saltSizeBytes int } func (alg *RsaPssUsingSha) Name() string { switch alg.keySizeBits { case 256: return PS256 case 384: return PS384 default: return PS512 } } func (alg *RsaPssUsingSha) Verify(securedInput, signature []byte, key interface{}) error { if pubKey,ok:=key.(*rsa.PublicKey);ok { return rsa.VerifyPSS(pubKey, hashFunc(alg.keySizeBits), sha(alg.keySizeBits, securedInput), signature, &rsa.PSSOptions{SaltLength:alg.saltSizeBytes}) } return errors.New("RsaPssUsingSha.Verify(): expects key to be '*rsa.PublicKey'") } func (alg *RsaPssUsingSha) Sign(securedInput []byte, key interface{}) (signature []byte, err error) { if privKey,ok:=key.(*rsa.PrivateKey);ok { return rsa.SignPSS(rand.Reader, privKey, hashFunc(alg.keySizeBits), sha(alg.keySizeBits, securedInput), &rsa.PSSOptions{SaltLength:alg.saltSizeBytes}) } return nil,errors.New("RsaPssUsingSha.Sign(): expects key to be '*rsa.PrivateKey'") } jose2go-1.5/sec_test/000077500000000000000000000000001373537523000145505ustar00rootroot00000000000000jose2go-1.5/sec_test/security_vulnerabilities_test.go000066400000000000000000000076631373537523000233020ustar00rootroot00000000000000package sec_test import ( "crypto/ecdsa" "fmt" "github.com/dvsekhvalnov/jose2go" "github.com/dvsekhvalnov/jose2go/arrays" "github.com/dvsekhvalnov/jose2go/keys/ecc" . "gopkg.in/check.v1" "testing" ) func Test(t *testing.T) { TestingT(t) } type SecurityTestSuite struct{} var _ = Suite(&SecurityTestSuite{}) func (s *SecurityTestSuite) Test_InvalidCurve(c *C) { // https://www.cs.bris.ac.uk/Research/CryptographySecurity/RWC/2017/nguyen.quan.pdf // Attack exploits some ECDH implementations which do not check // that ephemeral public key is on the private key's curve. //given //JWT encrypted with attacker private key, which is equals to (reciever_pk mod 113) attackMod113 := "eyJhbGciOiJFQ0RILUVTK0ExMjhLVyIsImVuYyI6IkExMjhDQkMtSFMyNTYiLCJlcGsiOnsia3R5IjoiRUMiLCJ4IjoiZ1RsaTY1ZVRRN3otQmgxNDdmZjhLM203azJVaURpRzJMcFlrV0FhRkpDYyIsInkiOiJjTEFuakthNGJ6akQ3REpWUHdhOUVQclJ6TUc3ck9OZ3NpVUQta2YzMEZzIiwiY3J2IjoiUC0yNTYifX0.qGAdxtEnrV_3zbIxU2ZKrMWcejNltjA_dtefBFnRh9A2z9cNIqYRWg.pEA5kX304PMCOmFSKX_cEg.a9fwUrx2JXi1OnWEMOmZhXd94-bEGCH9xxRwqcGuG2AMo-AwHoljdsH5C_kcTqlXS5p51OB1tvgQcMwB5rpTxg.72CHiYFecyDvuUa43KKT6w" //JWT encrypted with attacker private key, which is equals to (reciever_pk mod 2447) attackMod2447 := "eyJhbGciOiJFQ0RILUVTK0ExMjhLVyIsImVuYyI6IkExMjhDQkMtSFMyNTYiLCJlcGsiOnsia3R5IjoiRUMiLCJ4IjoiWE9YR1E5XzZRQ3ZCZzN1OHZDSS1VZEJ2SUNBRWNOTkJyZnFkN3RHN29RNCIsInkiOiJoUW9XTm90bk56S2x3aUNuZUprTElxRG5UTnc3SXNkQkM1M1ZVcVZqVkpjIiwiY3J2IjoiUC0yNTYifX0.UGb3hX3ePAvtFB9TCdWsNkFTv9QWxSr3MpYNiSBdW630uRXRBT3sxw.6VpU84oMob16DxOR98YTRw.y1UslvtkoWdl9HpugfP0rSAkTw1xhm_LbK1iRXzGdpYqNwIG5VU33UBpKAtKFBoA1Kk_sYtfnHYAvn-aes4FTg.UZPN8h7FcvA5MIOq-Pkj8A" //when test, _, err := jose.Decode(attackMod113, Ecc256()) //then c.Assert(err, NotNil) fmt.Printf("\nerr= %v\n", err) c.Assert(test, Equals, "") //when test, _, err = jose.Decode(attackMod2447, Ecc256()) //then c.Assert(err, NotNil) fmt.Printf("\nerr= %v\n", err) c.Assert(test, Equals, "") } func (s *SecurityTestSuite) Test_AAD_IntegerOverflow(c *C) { //Borrowed test case from https://bitbucket.org/b_c/jose4j/commits/b79e67c13c23 cek := []byte{57, 188, 52, 101, 199, 208, 135, 76, 159, 67, 65, 71, 196, 136, 137, 113, 227, 232, 28, 1, 61, 157, 73, 156, 68, 103, 67, 250, 215, 162, 181, 161} aad := []byte{0, 1, 2, 3, 4, 5, 6, 7} plainText := make([]byte, 536870928, 536870928) //generate random plaintext for i := 0; i < len(plainText); i += 8 { bytes := arrays.UInt64ToBytes(uint64(i)) plainText[i] = bytes[0] plainText[i+1] = bytes[1] plainText[i+2] = bytes[2] plainText[i+3] = bytes[3] plainText[i+4] = bytes[4] plainText[i+5] = bytes[5] plainText[i+6] = bytes[6] plainText[i+7] = bytes[7] } enc := &jose.AesCbcHmac{} enc.SetKeySizeBits(256) iv, cipherText, authTag, _ := enc.Encrypt(aad, plainText, cek) // Now shift aad and ciphertext around so that HMAC doesn't change, // but the plaintext will change. buffer := arrays.Concat(aad, iv, cipherText) // Note that due to integer overflow 536870920 * 8 = 64 newAadSize := 536870920 newAad := buffer[0:newAadSize] newIv := buffer[newAadSize : newAadSize+16] newCipherText := buffer[newAadSize+16:] //decrypt shifted binary, it should fail, since content is different now test, err := enc.Decrypt(newAad, cek, newIv, newCipherText, authTag) //if we reach that point HMAC check was bypassed although the decrypted data is different c.Assert(err, NotNil) fmt.Printf("\nerr= %v\n", err) c.Assert(test, IsNil) } func Ecc256() *ecdsa.PrivateKey { return ecc.NewPrivate([]byte{193, 227, 73, 203, 97, 236, 112, 36, 140, 232, 1, 3, 76, 56, 52, 225, 184, 142, 190, 17, 97, 203, 37, 175, 56, 116, 31, 120, 95, 207, 196, 196}, []byte{123, 201, 103, 8, 239, 128, 149, 43, 83, 248, 210, 85, 95, 231, 43, 132, 30, 208, 69, 136, 98, 139, 29, 55, 138, 89, 73, 57, 80, 14, 201, 201}, []byte{84, 73, 131, 102, 144, 215, 92, 175, 41, 240, 221, 2, 157, 219, 49, 179, 221, 184, 171, 169, 210, 213, 21, 197, 1, 36, 101, 232, 23, 212, 169, 220}) } jose2go-1.5/sha.go000066400000000000000000000006421373537523000140430ustar00rootroot00000000000000package jose import ( "hash" "crypto" "crypto/sha256" "crypto/sha512" ) func hashFunc(keySizeBits int) crypto.Hash { switch keySizeBits { case 256: return crypto.SHA256 case 384: return crypto.SHA384 default: return crypto.SHA512 } } func hashAlg(keySizeBits int) hash.Hash { switch keySizeBits { case 256: return sha256.New() case 384: return sha512.New384() default: return sha512.New() } }