pax_global_header00006660000000000000000000000064130213015600014501gustar00rootroot0000000000000052 comment=3135718e6f6f9044cd3d93cdb447396ade65d56f javaOIDCMsg-3.0.0/000077500000000000000000000000001302130156000135305ustar00rootroot00000000000000javaOIDCMsg-3.0.0/.codecov.yml000066400000000000000000000003521302130156000157530ustar00rootroot00000000000000coverage: precision: 2 round: down range: "70...100" status: patch: default: if_no_uploads: error changes: true project: default: target: auto if_no_uploads: error comment: falsejavaOIDCMsg-3.0.0/.gitignore000066400000000000000000000030701302130156000155200ustar00rootroot00000000000000# Created by .ignore support plugin (hsz.mobi) ### OSX template *.DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear in the root of a volume .DocumentRevisions-V100 .fseventsd .Spotlight-V100 .TemporaryItems .Trashes .VolumeIcon.icns .com.apple.timemachine.donotpresent # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk ### JetBrains template # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 # Intellij .idea/ *.iml ## File-based project format: *.iws ## Plugin-specific files: # IntelliJ /out/ # mpeltonen/sbt-idea plugin .idea_modules/ # JIRA plugin atlassian-ide-plugin.xml # Crashlytics plugin (for Android Studio and IntelliJ) com_crashlytics_export_strings.xml crashlytics.properties crashlytics-build.properties fabric.properties ### Java template *.class # Mobile Tools for Java (J2ME) .mtj.tmp/ # Package Files # *.jar *.war *.ear # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* ### Gradle template .gradle build/ target/ dependency-reduced-pom.xml # Ignore Gradle GUI config gradle-app.setting # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) !gradle-wrapper.jar # Cache of project .gradletasknamecache # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898 # gradle/wrapper/gradle-wrapper.properties javaOIDCMsg-3.0.0/.travis.yml000066400000000000000000000010051302130156000156350ustar00rootroot00000000000000language: java jdk: - openjdk7 - oraclejdk7 - oraclejdk8 before_cache: - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock - rm -fr $HOME/.gradle/caches/*/plugin-resolution/ sudo: false cache: directories: - $HOME/.gradle/caches/ - $HOME/.gradle/wrapper/ script: - "./gradlew clean check jacocoTestReport --continue" after_success: - bash <(curl -s https://codecov.io/bash) after_failure: - cat $HOME/travis/build/auth0/java-jwt/lib/build/reports/tests/index.html branches: only: - v3javaOIDCMsg-3.0.0/CHANGELOG.md000066400000000000000000000020051302130156000153360ustar00rootroot00000000000000# Change Log ## [3.0.0](https://github.com/auth0/java-jwt/tree/3.0.0) (2016-12-01) Reimplemented java-jwt to improve API and include more signing algorithms ## Installation ### Maven ```xml com.auth0 java-jwt 3.0.0 ``` ### Gradle ```gradle compile 'com.auth0:java-jwt:3.0.0' ``` ## Available Algorithms The library implements JWT Verification and Signing using the following algorithms: | JWS | Algorithm | Description | | :-------------: | :-------------: | :----- | | HS256 | HMAC256 | HMAC with SHA-256 | | HS384 | HMAC384 | HMAC with SHA-384 | | HS512 | HMAC512 | HMAC with SHA-512 | | RS256 | RSA256 | RSASSA-PKCS1-v1_5 with SHA-256 | | RS384 | RSA384 | RSASSA-PKCS1-v1_5 with SHA-384 | | RS512 | RSA512 | RSASSA-PKCS1-v1_5 with SHA-512 | | ES256 | ECDSA256 | ECDSA with curve P-256 and SHA-256 | | ES384 | ECDSA384 | ECDSA with curve P-384 and SHA-384 | | ES512 | ECDSA512 | ECDSA with curve P-521 and SHA-512 |javaOIDCMsg-3.0.0/README.md000066400000000000000000000253001302130156000150070ustar00rootroot00000000000000 # Java JWT [![Build Status](https://travis-ci.org/auth0/java-jwt.svg?branch=v3)](https://travis-ci.org/auth0/java-jwt) [![Coverage Status](https://img.shields.io/codecov/c/github/auth0/java-jwt/v3.svg?style=flat-square)](https://codecov.io/github/auth0/java-jwt) [![License](http://img.shields.io/:license-mit-blue.svg?style=flat)](http://doge.mit-license.org) A Java implementation of [JSON Web Tokens (draft-ietf-oauth-json-web-token-08)](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html) ## Installation ### Maven ```xml com.auth0 java-jwt 3.0.0 ``` ### Gradle ```gradle compile 'com.auth0:java-jwt:3.0.0' ``` ## Available Algorithms The library implements JWT Verification and Signing using the following algorithms: | JWS | Algorithm | Description | | :-------------: | :-------------: | :----- | | HS256 | HMAC256 | HMAC with SHA-256 | | HS384 | HMAC384 | HMAC with SHA-384 | | HS512 | HMAC512 | HMAC with SHA-512 | | RS256 | RSA256 | RSASSA-PKCS1-v1_5 with SHA-256 | | RS384 | RSA384 | RSASSA-PKCS1-v1_5 with SHA-384 | | RS512 | RSA512 | RSASSA-PKCS1-v1_5 with SHA-512 | | ES256 | ECDSA256 | ECDSA with curve P-256 and SHA-256 | | ES384 | ECDSA384 | ECDSA with curve P-384 and SHA-384 | | ES512 | ECDSA512 | ECDSA with curve P-521 and SHA-512 | ## Usage ### Decode a Token ```java String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJpc3MiOiJhdXRoMCJ9.AbIJTDMFc7yUa5MhvcP03nJPyCPzZtQcGEp-zWfOkEE"; try { JWT jwt = JWT.decode(token); } catch (JWTDecodeException exception){ //Invalid token } ``` If the token has an invalid syntax or the header or payload are not JSONs, a `JWTDecodeException` will raise. ### Create and Sign a Token You'll first need to create a `JWTCreator` instance by calling `JWT.create()`. Use the builder to define the custom Claims your token needs to have. Finally to get the String token call `sign()` and pass the Algorithm instance. * Example using `HS256` ```java try { String token = JWT.create() .withIssuer("auth0") .sign(Algorithm.HMAC256("secret")); } catch (JWTCreationException exception){ //Invalid Signing configuration / Couldn't convert Claims. } ``` * Example using `RS256` ```java PrivateKey key = //Get the key instance try { String token = JWT.create() .withIssuer("auth0") .sign(Algorithm.RSA256(key)); } catch (JWTCreationException exception){ //Invalid Signing configuration / Couldn't convert Claims. } ``` If a Claim couldn't be converted to JSON or the Key used in the signing process was invalid a `JWTCreationException` will raise. ### Verify a Token You'll first need to create a `JWTVerifier` instance by calling `JWT.require()` and passing the Algorithm instance. If you require the token to have specific Claim values, use the builder to define them. The instance returned by the method `build()` is reusable, so you can define it once and use it to verify different tokens. Finally call `verifier.verify()` passing the token. * Example using `HS256` ```java String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJpc3MiOiJhdXRoMCJ9.AbIJTDMFc7yUa5MhvcP03nJPyCPzZtQcGEp-zWfOkEE"; try { JWTVerifier verifier = JWT.require(Algorithm.HMAC256("secret")) .withIssuer("auth0") .build(); //Reusable verifier instance JWT jwt = verifier.verify(token); } catch (JWTVerificationException exception){ //Invalid signature/claims } ``` * Example using `RS256` ```java String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJpc3MiOiJhdXRoMCJ9.AbIJTDMFc7yUa5MhvcP03nJPyCPzZtQcGEp-zWfOkEE"; PublicKey key = //Get the key instance try { JWTVerifier verifier = JWT.require(Algorithm.RSA256(key)) .withIssuer("auth0") .build(); //Reusable verifier instance JWT jwt = verifier.verify(token); } catch (JWTVerificationException exception){ //Invalid signature/claims } ``` If the token has an invalid signature or the Claim requirement is not met, a `JWTVerificationException` will raise. #### Time Validation The JWT token may include DateNumber fields that can be used to validate that: * The token was issued in a past date `"iat" < TODAY` * The token hasn't expired yet `"exp" > TODAY` and * The token can already be used. `"nbf" > TODAY` When verifying a token the time validation occurs automatically, resulting in a `JWTVerificationException` being throw when the values are invalid. If any of the previous fields are missing they won't be considered in this validation. To specify a **leeway window** in which the Token should still be considered valid, use the `acceptLeeway()` method in the `JWTVerifier` builder and pass a positive seconds value. This applies to every item listed above. ```java JWTVerifier verifier = JWT.require(Algorithm.RSA256(key)) .acceptLeeway(1) // 1 sec for nbf, iat and exp .build(); ``` You can also specify a custom value for a given Date claim and override the default one for only that claim. ```java JWTVerifier verifier = JWT.require(Algorithm.RSA256(key)) .acceptLeeway(1) //1 sec for nbf and iat .acceptExpiresAt(5) //5 secs for exp .build(); ``` ### Header Claims #### Algorithm ("alg") Returns the Algorithm value or null if it's not defined in the Header. ```java String algorithm = jwt.getAlgorithm(); ``` #### Type ("typ") Returns the Type value or null if it's not defined in the Header. ```java String type = jwt.getType(); ``` #### Content Type ("cty") Returns the Content Type value or null if it's not defined in the Header. ```java String contentType = jwt.getContentType(); ``` #### Key Id ("kid") Returns the Key Id value or null if it's not defined in the Header. ```java String keyId = jwt.getKeyId(); ``` #### Private Claims Additional Claims defined in the token's Header can be obtained by calling `getHeaderClaim()` and passing the Claim name. A Claim will always be returned, even if it can't be found. You can check if a Claim's value is null by calling `claim.isNull()`. ```java Claim claim = jwt.getHeaderClaim("owner"); ``` ### Payload Claims #### Issuer ("iss") Returns the Issuer value or null if it's not defined in the Payload. ```java String issuer = jwt.getIssuer(); ``` #### Subject ("sub") Returns the Subject value or null if it's not defined in the Payload. ```java String subject = jwt.getSubject(); ``` #### Audience ("aud") Returns the Audience value or null if it's not defined in the Payload. ```java List audience = jwt.getAudience(); ``` #### Expiration Time ("exp") Returns the Expiration Time value or null if it's not defined in the Payload. ```java Date expiresAt = jwt.getExpiresAt(); ``` #### Not Before ("nbf") Returns the Not Before value or null if it's not defined in the Payload. ```java Date notBefore = jwt.getNotBefore(); ``` #### Issued At ("iat") Returns the Issued At value or null if it's not defined in the Payload. ```java Date issuedAt = jwt.getIssuedAt(); ``` #### JWT ID ("jti") Returns the JWT ID value or null if it's not defined in the Payload. ```java String id = jwt.getId(); ``` #### Private Claims Additional Claims defined in the token's Payload can be obtained by calling `getClaim()` and passing the Claim name. A Claim will always be returned, even if it can't be found. You can check if a Claim's value is null by calling `claim.isNull()`. ```java Claim claim = jwt.getClaim("isAdmin"); ``` When creating a Token with the `JWT.create()` you can specify a custom Claim by calling `withClaim()` and passing both the name and the value. ```java JWT.create() .withClaim("name", 123) .sign(Algorithm.HMAC256("secret")); ``` You can also verify custom Claims on the `JWT.require()` by calling `withClaim()` and passing both the name and the required value. ```java JWT.require(Algorithm.HMAC256("secret")) .withClaim("name", 123) .build() .verify("my.jwt.token"); ``` > The value of the custom Claim in all the cases must be of a `Integer`, `Double`, `Date`, `String`, or `Boolean` class. ### Claim Class The Claim class is a wrapper for the Claim values. It allows you to get the Claim as different class types. The available helpers are: #### Primitives * **asBoolean()**: Returns the Boolean value or null if it can't be converted. * **asInt()**: Returns the Integer value or null if it can't be converted. * **asDouble()**: Returns the Double value or null if it can't be converted. * **asString()**: Returns the String value or null if it can't be converted. * **asDate()**: Returns the Date value or null if it can't be converted. This must be a NumericDate (Unix Epoch/Timestamp). Note that the [JWT Standard](https://tools.ietf.org/html/rfc7519#section-2) specified that all the *NumericDate* values must be in seconds. #### Collections To obtain a Claim as a Collection you'll need to provide the **Class Type** of the contents to convert from. * **asArray(class)**: Returns the value parsed as an Array of elements of type **Class Type**, or null if the value isn't a JSON Array. * **asList(class)**: Returns the value parsed as a List of elements of type **Class Type**, or null if the value isn't a JSON Array. If the values inside the JSON Array can't be converted to the given **Class Type**, a `JWTDecodeException` will raise. ## What is Auth0? Auth0 helps you to: * Add authentication with [multiple authentication sources](https://docs.auth0.com/identityproviders), either social like **Google, Facebook, Microsoft Account, LinkedIn, GitHub, Twitter, Box, Salesforce, among others**, or enterprise identity systems like **Windows Azure AD, Google Apps, Active Directory, ADFS or any SAML Identity Provider**. * Add authentication through more traditional **[username/password databases](https://docs.auth0.com/mysql-connection-tutorial)**. * Add support for **[linking different user accounts](https://docs.auth0.com/link-accounts)** with the same user. * Support for generating signed [Json Web Tokens](https://docs.auth0.com/jwt) to call your APIs and **flow the user identity** securely. * Analytics of how, when and where users are logging in. * Pull data from other sources and add it to the user profile, through [JavaScript rules](https://docs.auth0.com/rules). ## Create a free account in Auth0 1. Go to [Auth0](https://auth0.com) and click Sign Up. 2. Use Google, GitHub or Microsoft Account to login. ## Issue Reporting If you have found a bug or if you have a feature request, please report them at this repository issues section. Please do not report security vulnerabilities on the public GitHub issue tracker. The [Responsible Disclosure Program](https://auth0.com/whitehat) details the procedure for disclosing security issues. ## Author [Auth0](auth0.com) ## License This project is licensed under the MIT license. See the [LICENSE](LICENSE) file for more info. javaOIDCMsg-3.0.0/build.gradle000066400000000000000000000006161302130156000160120ustar00rootroot00000000000000// Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:2.2.2' classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7' } } allprojects { group = 'com.auth0' repositories { jcenter() } } javaOIDCMsg-3.0.0/gradle.properties000066400000000000000000000013321302130156000171030ustar00rootroot00000000000000# Project-wide Gradle settings. # IDE (e.g. Android Studio) users: # Gradle settings configured through the IDE *will override* # any settings specified in this file. # For more details on how to configure your build environment visit # http://www.gradle.org/docs/current/userguide/build_environment.html # Specifies the JVM arguments used for the daemon process. # The setting is particularly useful for tweaking memory settings. org.gradle.jvmargs=-Xmx1536m # When configured, Gradle will run in incubating parallel mode. # This option should only be used with decoupled projects. More details, visit # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects # org.gradle.parallel=true javaOIDCMsg-3.0.0/gradle/000077500000000000000000000000001302130156000147665ustar00rootroot00000000000000javaOIDCMsg-3.0.0/gradle/wrapper/000077500000000000000000000000001302130156000164465ustar00rootroot00000000000000javaOIDCMsg-3.0.0/gradle/wrapper/gradle-wrapper.jar000066400000000000000000001506041302130156000220660ustar00rootroot00000000000000PK *G META-INF/PK *GוR?UMETA-INF/MANIFEST.MFMLK-. K-*ϳR03-IM+I, dZ)%bµrPK Gorg/PK G org/gradle/PK Gorg/gradle/wrapper/PK Ghdf#org/gradle/wrapper/Download$1.class}M 0h5Z+v/ ׆p!.H3SK;a(Id0®lWO*i)2Xsd1,:"! G5=R+ȃɹws??~XªQx)I)`^F\F ṂzQFRhMK K [A*_ɮoANϖvӟtp854˰ZsM0ݍ+e錞K{zahӱa{jr⿅ >4fڦ?(06 %L7k}8e*)v0 DqZ5*>F]m4xqNuj}g'-mZ0Zjw䜦[b!ڋ3)UD0A\>yIA$Rf MxfFӴ*e]ӫxwԯ x wuH𘗽P`{!!}%nx/ q}Jhͮ0,މ=q@{,Qzii“G7 !8CH3 `_[(`+8$U)<$4OZd4}/z@:CYׅ"D "Vv I (&%꿮)[|SW/9s ,n%BrUv/PK G] 3org/gradle/wrapper/ExclusiveFileAccessManager.classVKpem&im!@!PlP(ӂbhZ 6]ݍMK} >u蝣2#-XGGǃ://߷6?  Gw^D>tIq WiA9% NߏQ#583x6HSq0(3dD-*pWb~~֤':u$SzOut$%R1%+F.k[kP0vU 6E AJJΛ4lStAjfPM&$xf5)PVuU33ާX^{XXʴrdu56n)j/dbAS;4]mdBK1jOqڢnr-hkz,ceK(.<4̋y5cӘ![vnfF$Թ gPaL13 aД 5R96YK,Ap/]l \ak:rAC}ѫ .ZjMǗf}uUQebPMfA=YT[ {[K8Lb<sHi"3+/a2FXY22֯u{(2NS)G//T> 3h ڸ7B(^:Ga*{Pl6\;#4͠v )l y&ͳ`sua$&&s"\^&x3^9O&39qߝ}~9z(sL7R <7o :ǐG3ăVL=W_ߠ(~׉_hy?;Cr|1C_JV,9fx6'2!Ƽ!09'($)^RV-=wj$\7ud/j-'I%4۵ 2ۤG*1 <PK G ^F-org/gradle/wrapper/WrapperConfiguration.classmOAփ>"!3 U1U H|Cp#]5Si"1e[733\_(K`6 q?<7yBi9w(w7͋fzusY.xCCF4Ĩ75%c0.w*&UVVqF IJrN kxB \»'/;'k00#IR,TkA i CeG4G۳B1p3r중2SL6 zl'K9lF#N,wEc"Ұ(v 6[+U32vٸfL;6bfDt,f&6nh4# T;j nID5/G'"皶EY(sJhfZ)Ԭ&Yv숔XH`8BVXnə"Rd`KQW8kKtedTgȄejrm)3.oer$K.uڡz9Gp]LY[pcxb٧ NRzFKKSA7sȧy+:2`ligh鰑qUܠt~`fVT;j:V03v; glcJusyI\\+ؘ_b?ڭbA">qHǸY|u*qSr*-=~PqKǏIAtK.XڮG&`ۊ5K 2c3EݾH}tױHk/u5kXlH"5 "M;|L^x|I;Y%79R, [rng}zlj2 t᳼w2iIa%EVFi.OoΔu9mX<VM{ 7J/Q7و 70_C<.ȿ&(r>)U>'K۱T/) nEh<AXBC4E%/ADo_݃>蓛='O/6.6my">FA_ ,b` ("TCj;'JT|p3Q}4}gx[C8AP"AB;&ꇈ.JziE\"&?nqAKO8:aN>GbF'-&=eh=q /ӋONOp 7gBC8\QJ Xzc^sw PK Gy0Vorg/gradle/wrapper/Logger.classoPǿ*1pL EWo1&d  f&Ki Xs9* OHfp+ۨ&Q,D];Bܕp A`w 32 I^m{]⯧>wީ}N6Ǫc;8ƄԵ]u`r壣FQs5mP힩TT-]鹎a-PDս +TYb|Tuz|<[(N$&cbXC3RWu:+mf=mdϞ:?2RlDLBZB3{/AQHGB< 2og\+j/>M\> {JQV \ZWHcHXŠ\_)Gt } РF If:B~@R &~ 6H#J2b&J9򼉖ekY4|3}(4y0 TРJ =-u/g5ېur Bwek++ܥ~FLMvo 3zgF{(lMtwoIlquu 9&ilb\cEx{q֩|d/k%З˺h}(莫WrŒmkS? ;(PmVW ?suS^uu2(̆c΂9 s.nxSWXvq`w*CRPJ.d pQy<ŏT *5sxZSEnYO,Jע(żn ?gF*~! _k̻gMU1YN$K\E1pC_tCFGŸUU_xG.;`rkp Ⲃu;Y2]cYgU*擦&HܤaܤO>]aF(TdžKF Irfח7(In 3%I$K u`obM%Tw-5ִp-UhWf^A;]Tp!joCb1 Cݾ۫S(#-S:^p>if~y"c<{Fw12~C %FJ+yͥpD"s( 6]eL/-yk63u1Y;)-lé\}j_,iEfӚ~'lpv2:oFx *W p}nۺ?vV1r WpV8(z t ~J rC')q1μ}$i8ӳt,$0m6KOQηә2+{*{3D΅6b@|&2&qh q(c›v&vzROPdҭH-[!1PiaуUfWB 6.q\Kȱ [Fͅ=$Oq|}t]s,v玬s@14:,v-21)hbf1C,]gM>|C _kdqB]32Rռ$hbFhy'[ZpU<ћ!/b机A==HW=fd`TaF2fƓ jUڶaGy\Qy}ĿT8yN22IAүa=VBD=d+xﺔ%|4#j>K>GXy B:|P;XLJ|PK G8޶) org/gradle/wrapper/Install.classY |?',+kD"y7 I0 dw#ΒDZJվP[Vb-UQI(j}Vko*fv7d/f{|_^Gh!>Η'"_4iɧ2(el4\S";X 4g aMt ->Zk k67ouƦ՛75otCݦL͗ifsx,i1kIAk|xg`Ott&pĨIFJ80lM qҭ[]uɤmn 6ӌP$4wk̈Q :=۲ոQh<4cҏ59e[4ٌ-hؤcP<-z”t2L3]9o"H% 2̤t['avec+";TvʤQf{J7'"L1êټ Srv鋖.kME&GDACwn&)0KNjy@Ei0YLڲl3lnYT3C#T܂e2_aϋ"Bf9ӓF(0u&p`vIKVvAt0u$`>J*ИiXu#avjc<H-hF!8 F20zfLrV`ѨCXOzLn5cئl'[tYY6"ӄ0QIb О5B(?҄s\c)FJe}aKkeD8"s6dcP)Y8rc,5I\2GsOCtb(ݗK]sT`-&OD,m[`SƜzHPEC +2u8Bʱʭ2IsKU5Zۆ/ռC\ cvwndH-NjJwU:L*~ =ukUzUFTpʢϪnPz»UoT&ޣfo[U<ߊJI}A/EֵuUS{6vpzAUWN].ew5~oHs ⍩eFlf|['-V$kḑbqKCAjfLc}~V57_͊kHы}:ҧ-F1}V|@ L;N(Dw,ZIm! GG`+-3d]-ޡСAKb%6uNTӺ]n1ңݲgk=U]KDTt w-k݉8Z},'UVښԭq#%h˵D<隕H%^N U-iŦV+I2QPCvhuv6j@G|W ~C.$}<@?S?6ћ@Kl'q.S~燺q!K,*GU>)]'`,kiZaarN紎xV{^T>?QSevT~_^az*{PS?$^L^6k6x*C=y[ozRpɹXbNGę6{%ј_:b67!(du ??柨S~c=N% ?GZ!BUWNң4 o;3G:cmznJ?+nyO?G V*w"x[@鑐Gͷhgm 岔MMW(qNRi;#&itXD>эBCVb4y˅ݟnSVν$LF6P ?fC8a g|]P/ ]e' Ⓘ &.kFnIpZoi\L{qV|}IQi+|8tZ]v/0g֏b2n GD_s(GU"72i^ zQȺg\A%NNaډd< d*у-" `:Nq9+"WKFi{8W W3hlԝ83ِ) 38XLNz,C)qVr `K>a[2אCwGuƤ^dsJܱOxr#w\`ebN dWՔM%렕cBK%ɗ;ҥ*әd9$[.6f3$NCJW} xB9kO'xN&{u(xW>@h+7^ 0/8LJyaW lC{JaͦI7cܡIЭDHg\~HsUE?M\fRK4/kAo?cJヾAV++=Gŏ :r%dT rue\E_/A|:L{A%@K6׃t; f@}tfͥt7|5bױUGnB_#7N?ButZ[h,NDkyifU0f.y9`J:p~] - VxAhd:_sN-\4.LZOgl *5on?8zP駒!hBh"4."deA&uhw-Elv@˰^. t֬70"!DEߤ0k!%!FEìxṊw\?B Fj-k~KSt&7i~[aY*kT!F+JF{zsޒմo"yXe{DON?ӳpmz+[%_p- n-\آWyѱ-*RZ6sm\ 88b*"1X< loc> ~>fV1f#=eyoOq (<%i9|h1-UGy= VUӊ}V}O<ں;H~r7mA;*΅X/ﷃt*UG~:p~F 9pY~x//=I|6{^p).:gy Rq[E:w ymgS+࿆jt7 $8eXMӧxSs?;@kmַ tmLъj1ZTT 8P[iVIimx^ؕ21 ^Cнr<@qv  ݇M~{bD}-~5ִ#{!oALG<(x~a wK| p O/ay^=4^W5xvdG;l؆YSEyÆv\f7m؟Vxq0O({s0z61MjDi4o&[vXɅyσRŽjХb@Ļۆ @JW2 K:@ূʱooAt9`AY3\x7J7"4 zp_/ tǍ/_`I5~+%hg)Aws9wMڴYV5#nͬI,_ m5F:-HO͌i:tV"0 ! a\~X@]T-B4 3L5HpO̎JTpP;"%5)%YҎ:l/O~1yn$۷5JьTL]f9dzByd.hNuT'[UzifJ9TV"܃ )xt\:JFvhؓDA| KAt'zEܪE=gϱ()xCM{T G >Ed4Ѕ׵m _+5rÏÏFyK7 wT92`fg̜ ԩ6 ڻ,R}5(Nimm;==荜+AU*tS(\z&+PUYȲ"Z?,S*O8TTp#]p7ZLgw)⾵,+̞;CנӺBͧ`Z%ܮqfLUE:jښq`>;|4{Dj6R\a(\K$"\&T)3զ@j1-2 X#5E|@-봋,:u;O`L!&;͡cԭ“?G1&1_҄7_&ƄM<'|@3LZ p0b CyJ&_1@$CҊC4}xWnM+vuon$"I&/OP1EѼtİyt,mbiory\ ˿+Z$|cqVv (Aq=:Mawxq1):L%>=ZYJDvPK GHַ$ #(org/gradle/wrapper/WrapperExecutor.classWy`UMn6ӄn)),%mEݖ#ISlҚ4Y ((*"DEA>oL6m }{s? `-~[(~DnYǏpoxg/J]AT`9-{d8${dx| Ca}$/G|20+ex(;'x$GŊDŽAOS2tdY?>8|_|)/*O OUH % ~4)=:ܷ{hxpgxdLA2m֑RQL&6)XmҖvhɌ`ehGBP6押$ SK؋v-;EߟD=cTT ֓+Hz;<ɤwzSICEHnvCr_>Uq@9O+砌͡d,*oec(oƖX3@3t˜Sc됙haU`"';"pV̡b,=ʱHAXUWRF:ENRYl}`!Tl)Sfr)~ ,oc彗^\Mog>euH\ Jj췛AGJb![51|q Cȷy[BPG:Ƶ.SAVQaTo6ԫrE?%x9]w̺?_ eN;ສЙk29_x*kqIFK :6Zd5Zur/^E{v=#Rb^lfHP|9$7:-@Ea8Ї=%i vEMTHj-&FO$7rVb˼ٕy 2QX6l7ze3DEmFYз@XMY!‹6&ܿÃccΖƜ--2{O +)aFzC`72t ڐVh?PK G B*org/gradle/wrapper/GradleWrapperMain.classXxNjU8 Ô Ԑ΀Y fmVQb؉H8=N8'يM'Nwz;gwu:-B_yy O>֋*.2\.PJ\W)8ǫxܽVpzoPQ&Fyx7 ޢUM|\!wRn~ zxXX PQ#܇*ŇU1!&\cʏT9c*T|PIb3T|֏I__O/KFO~|Mץ-w~.ǷT|Q]?'\~g ~ypoǁûz;+:1=>635R@(=çEї.#*Gm |m0uE#ѧRI3DT]&vHB }|HwAg׭G47_%uM8P]λ@5;1 VHJ0M=Jq=4:[H,n34vCFE3~$e1/#*A4y(e<u1{':bWrM<4A^`ܰ:{O-TFacL[IU3`$6F崌xApUII3InIIEc2h6l-7]8M>/rBp˒ ,jj-nM&V ]$ tU;5;M)b62)4 V s\x*jg+?O /+jBғjH l T/ zSX<0ksrRq36MOF[Ic5!˅.@UiI^KB,`eu(gʢdP>MBM(S5QXFa5$BŒNcOWD&JE"5HQJXK4Q%9+=/Rq+:fdAE,ER_Qeb6=7аAw1BLӳf"bMc=ij$kgiϑcF RJ ib 7)\Y>Z-.fh!%䢄UHŇ)ҫkFZQ+q5KcѨuQmX6E:DRo!3OoL74Br`=ut2/ՓԘ.Z FGR ^5ye7 cxYdvc+1X=ݱŝcGʸ>g/*^.Ʈ(Aeys;Sv{NďyӻO,zE)]7'cV1͇yVƒ#e4̝j;Þ7<ƘlTB3r0 pwzv qơ`Va! rD(~(kr0k_}))|p0 4L@<`ZhWzG[Ebq {| 'o &P PGZ(4f%\*S(#eyKA@. NE *N(XFU'-iAYR.X4ZԠ0eC),X1MaP?x 5&3F:z-mQ,G#.:B3mWc= b3nG ^8+Zm;"Q;|99J!D%C XH9Ĉ18~=nK!9\Kh eq(6і"3N2"l9 t𷖾BPCn\Pch!T hG:QKVJ:f+27ɮw6': VV8uk 4i\2캳Uez46qii}( \q2Z[z%0plZ;x9W \u֖UN\j2^C%:LyfWɐ݊琾I\whJl}:%v0uwv5R]4vw#1QWys{쳽=}%m/c*%,ULLs#}`Է0mw3a0Y HKoJx!+ }Xx$pg.(Jcݨti>DL(!L Xa_..)i %L?7nRrjPK Gx"org/gradle/wrapper/Install$1.classWkwY3瞳9>|rF}qXwD|WD< ˆcdc"C c2xPz(ƥD3![d ppePĺhp j6?p~bx\()&FF\'#x^}ʰ;m7kأVN6Vd&)#mi)M*pYmYc%r=71}J̲/y)te\/{F6G=P0Hכr~1ѻipiR! 'V*vnPhe)m6˱ '2\fZ/zQQwT2c9PircRxFr,WR 0m&5,΍\Fg,T{10WPNbu*\2vz7 I;bzr4scFNA2i/D^& u} WxP[庆)B!(v˚k1J~0iٰw uqlLO3SYae`z5=bv[das:~ulVQG[pMج6ܮ/W}(/c•U9^ zGtL˸xoxS[{({ _3ZbtN<&wuS:V{:|Os?ea0`ڦ/NH&FpV'8_t癹CV $:ߥLB,c)M5TXd r~ipz–E-hoǗM!D82&Ff~N695Ĩ*N*JW j+sXѵKǙ#5_ƂURK\ScLqpr@vk;`k Wт (IGwy#7A*]}0yb>2/r{!]hNU`v_ LܼuFC$h̹ Z YozW]r !󨨰>Chmo `[myUZ^r\Et}ۋDޘZ?y-R mZ*A8hAk "Ѳ;([9|^߈o8MB+zo%[=-e,;ء3h Fz+(XyjCeƚeħ %et03")hӘXsX=">gqe0~?SUW߿!;pff ZZB; ^.k>Ctk!usjDx׏U4,YVe-x2VfW]Z%6s~$B:ՔHC[Ȣ sȜdICV<7v+8TkqjȨأ^z<㯠I8s=b//ə1MRQRM~U8v^biaaU_5z|~QQ3ܾ~\^QSe|z "PHULs;PK Gj jV8org/gradle/wrapper/PathAssembler$LocalDistribution.classR[KAftq[yk[KA!|(L!N MJP?U<3Ҩ|ؙs.s˿ū9`OM}Q&m5ȏT0芟"VY~ܪ+Mc56-ډiK` {DjyT򏄽Ilֲ$,4T*? {M Fɡkmjs M%ydw-~[ؑ%Ru<[5'_n$6E<`=fAxwZIDډ?7 U46?S@h=W-ĝPK GcJK!org/gradle/wrapper/Download.classWg~f3; 9X( l" $v4, ]Pq;,lgf TmnU^[l(UT#bσ*Ge|LU4*ISb Q|V4Sy|A%<|YW𸌯*zDoxT-TSL-S TU=WOe<# Aafu1 k,췭a;on&-qS#wNO-AIX=j "J FMh[`J Z8n遴q`[yV8X愾`HՏYL];c-\mưvtqk̸{$DZsJf$G7gLc"0k٬Գ3gMͬ I˜ˤ2 ³*)H-gTjd /LYOláڭD!e8n,nՕ;4rbё nckئe1^?ً}l8s~}uECwY) vl7qfhF+E;.ﭺ/y#8Ǯbph%!-!tj{#w|roרQ+23wavb#v&J2pÄގy  S(a8IfUVe`->Cx d~M"ɾ|X,HיHxT'v"v] /`x@trfelO4P!H F 7h!mʩLA-^8LB-JAPK G>PN#gradle-wrapper-classpath.propertiesSO)IUHIM,RSpIMV02T022421Qpv Q0204*(JM.)M/JLIM**+MPK  G$ٖebuild-receipt.properties5n0 wJA3hVҢkAK I6}au~C \/ZIlP)T^`[vƲ*96Qo;hgT5p-o(Dvf.Z-=Ҝ7b(:!Åw~%Ԫā3xgS#y~k@1B(_8PK  Gorg/gradle/cli/PK  G<S1org/gradle/cli/AbstractCommandLineConverter.classT]oA= +mt>BHhBem` Cߢ/42YPa9{s?p# 5ϕBy9yEx\Ye ZpՆaEjw I7|ZU c:tiw]HaٲzQdu;BrQfظ&DV\%6# ǹƙun]s̷X3ػe9H%ҲIk.=,ȍ-1ak^1蔕)9(id0^}y_7бp:%`i6t*㰊jBL F vUWm_ImuוD I8H7Լ&%DDՄ3qONB :ACvsπb0\8y 3CEw&T*kY+$@B!K͡5IYF6VANwh`+&XEKH,έQFV# J#hRq +dAy ~#TN*)oްOOSxΑ 86'??'k<ų@zV`PK  G2_e(org/gradle/cli/CommandLineParser$1.classA 0EhZ v庈kCPEv-iIp.<S\p>?fxCDlnmMJ]k'iu#0BWՔ!f,By@wZ͕t!BI]#HI9|g|{ -|PK  GRB <org/gradle/cli/CommandLineParser$MissingOptionArgState.class]O`6d 2 c&/1N4`W5S/ ^H#2-sKƖ&9O״ 1UQ4%ի*gE)D15u KD10ؓp :@^3\ٲŪ+^1UqQ)B&@)ʊ! B@n!fU(AiW|ۤᲵMnR# yd8!>] ZEGO*%UoulGQ/\TMn˹-02#/hAlu@t%-q*2Nw e&BgsQ\gݧ-F͌& nX{~ϐ2zfZC R6A Ӱἆ%GAa3@Lv0Lc8~csC7]Saf=/b !i!WiXN$!9!:">i!z&|'d&w`8Ig9NOXFiХ uD5x Rl( 38qhKCO p:mO.6p'%0o %rC?7o@Ӹ<=@QO b쫇|CMa"!˰߰d^7Uܰ^t^EY3G5Dh8%h+aVE3D*PK  GM2=org/gradle/cli/CommandLineParser$OptionStringComparator.classTOAfeam`ZPd) HJ  ަ Yvɛ{&ƳvBkj8tޛyo/ jѱcр%:UlQNJU-`!?`nbHzT(gHuO:{|"<Cbq,l ߷YqDݶ̚-M oyޕJ z-Qӹ|H Nl#Kݑ]:Պ}^!C ެ\kW=jA;W{D9!ŒeAS/@%ئRƾj n5nIJ dOcy_e[o9 =}&fH]ͰqiR-x/ rahf2=BF=Y \ KaڙdiZ_L*SHhpPsED?!Fq`pZl{ݺ=1#[s!B{./zi|CG1ǐIVy&$nR$B;C'r."{i"Llr".03m`Y(N͒V055QM<3t Ʃ`1< mcd3B= `OPK  G# GK1org/gradle/cli/CommandLineArgumentException.classJ1O3Zm+Uו0tD23k*|(1IK-Y  2aEE9炧=OQzTqvK9fU v#tiˀFCb!ė*BE{2ȅ 9`)K,Ihh\x &J>p1YITةQcBW~ͿDcD y f@]tӻLA^%6uV18(c]3 2gy=ݴoa̝̩ kqv>PK  G?h=org/gradle/cli/CommandLineParser$KnownOptionParserState.classXkx~dY&Vdsд!@LawL73ۙJ[^6V{zJB^֢Oy<}ߟ=gfvݰ?ܾs@;ޕw%!cL!XIy^l^^\OIcB w10X/LtL{$|Uz|={el}2oɷd|a=_P8? cu 'yy(agL K%yT¯$PkXk戄ٗmivOBsh['Xh43g~vt&@A˰qlŀ1bjn&5 wfbqԴ]L0 KB}qeF;zylXqLҟ;C Dl2XwiMU9^܀¬[2ԘnհT ky|qG\R-VlFtw[^ZpwL&tJ%Fڬuu[s-ά }A*I/m^E> @YK#m^:y}` b(`Vʎ7hZ8h W '̇۶g vGVlWpv(؉)BA 4.nS:vA :WV:ujմ\UTBq>:ȲI6)Oݦ%ݣ6uBsԤmq=ajl-N+8*7+xC bH”.k8e9tTij$ *9 cNsxF ^ ~ڛJjFN趾d/?BQ2xEE*~!Ů656ד#f"zHxS[,mUbj%pAMi /}2h4i-lӨo/F[Xulxz o,<#^Z<;^=F݉5y豖 g7eÿ%8#^+XLw6j=K֕ xr^ i/=Tqܼ42b6vc&>ܰh0g|,eŨCgm}C~Rqᦊl>hAdf^]2gbV% %jO2!ǃL&~spfc9OvtYSr\w 7V*9dpŮ[ [3Gҩ7~vOrDx (Sl}izKg:$D)ahJb9gP6hhVD +$D땐h<Y<*6JBx M'X>bAlwĶ%Y9!e} n/*XO߯i;BPK  Gk7org/gradle/cli/CommandLineParser$OptionComparator.classUmOP~nQ:oSD oe b0!c,Zvğ_Hb"6sJC{=9Ϲ~P4dW%,(c ^JX^IXu E ^3tmm2$r}d }w5C}5\ޱgVnkR,)XN];ڡ5P ЬC渺3y  ,#e}0Ђ/]i'jjV]zaՋ S6^~ u- TtY+y&duK< Y$jj7cv 2W[VAۛ+mS*(uB1lņ,i^\r 8;c =x\8npﹸvr CQo *]] 4|[Tuޒ%`anot.AAiU WGŵ S/co4<}u!TZi>Jv!a<@*QȒ̜!q ;G'.!v {nD<|ڊ֋1(Н0Q I9b|b$m:ݳtBHO\g3(W`iL9I k aXtβE$i,:AyLS)""J?QAX_PK  Gb'n?org/gradle/cli/CommandLineParser$UnknownOptionParserState.classURA==$a2@(""UZ`$SdL__\H*~7= B%q}q[A :0A0iDq5k rCw˺& ezabq [vJ%nWL[F ! ɕgY6rkk X>O 6E=}9A{gN)Ҧ>曖.^]S`{jHO~噎-pe}^^rJI=R7٠cSޒ{2iOcinی1^#r޲t1b7?4yvo=)L^)aFZ֜[c9*z'̼n$T BAa F&00 mGd6a4j3 C'/n{._VƵձ+1DX UR%H}4+.L_c=:"L32}F7>L`g%.dJ\)+QLgq.:K^dI׵{""¾j4e8 ț#u`@Ts䥓?|pP{fr mEhQr!"XOٯUVH/.\ 鋘6?9R?SͩUÕ@FcH:U1-NcjXc4Uy<blfq=PK  G"zZ &org/gradle/cli/CommandLineOption.classV[sV˱E  cP@HICEUGT\Y S¤tCg'C~GVdٲKΞ՞ow=m;0%c:6Lu`; fx%p -xK ܆*cAF>ꩂ4!#x,ƠpG(ߍ%qKFI{dY5~G*n4gXBǔ^4Ubkֿn ,[7'yBQbeI3%5r&u#q2Qy[wHHSYJWɬjJf@H7h[Ҭ,J8ڲ -7ܨq&nԝR1GC (ONT4{Zj̨.2jyi~\PSDz5,žcKBO}p,̮V!^ԜUmH(Q"lbQ-#a("Zrw6 ivΝ=w _|dŦmTҜ1d{mC);BNDfQkikɄaXq2ЯܵRB7"$(XAy/A7A#>;:|(F ͹=U&KcEZP|yq- S+·\U|HQS$dú݄31TMZ@wťK) sAChU0^]<. uʓGa(M"%z.업cg"W=d1fIٔd}F6,O).a9Ţ,se,~Bٿŋ#Hp+o(8Y:nY XGQWwe|W}?%d735V?6FeTs q83x[S/W&SwE>F)L+5VeF'1Gy݌`RͫW5OޞJo0LA E.ȸ:V61'!unQúwTK7rXr̐[1E0w$DϞCόm  kV%8py'ЃZT1жO~0͢˚QX|l%>ow l (t((TyN,x0^*QpKWj'DG \! ׇ6!$>!À40d)w[@bbu1NbkP$LװMUWlV Gn"{$ G^FHbp,>"]vqvοVw΄1(|v3A?w2{10]/~ ^&IC9$Egd$}uvNrg5&<gSF2#SӤXLBi ,A|;"AmȜ2BXiL8 G:m$x0$aOI(>*A[Ue/3n3̎Hm ߗzck쉡-,N3U?ϗ^i e;^{*΅e gl͑HC9Y\Y,X f.Ggab@HFSϢ/@tOL]u(#_k#ܩ7onaܾN25h8)Jeb[11_b7İ#j1lFד>^I>7ʢ0uI;, W/pdiM O: 䡟 I%'/;Lق)<$O#30VQ+qvC#B7>8^C~,rPK  Gg*&org/gradle/cli/CommandLineParser.classY xTյ^+8$<"cB2DT0xHNLQ*Q`}WVEIQbm}>l[{o{zk[L&={wD4OE>-NS:`ҩYti]:^4i:TNDOnvsS\stZ5^qNxNHkD KuPft0\s|\'V9OfhH9_>|!E_Gx5n*kDK|(j|NWu\ ⊀_&Zy6xXr:͢ Ѣŭ>nvLdh]ȌŬӘU`$muN3j#Q1M3c֊p ǂN+)^n;ӸKÑ]a{rYƸ4Aŧ`*p3c1gkmj {m[Q{4qi9?B3ˬH׸3e]fʐ<~tk1j4/߲v40Wn3wU]`*jYVqh^4*b+;cTu `[،wE噳!3Ve3X2mj-!9Jme0l.\f(Um$5/XQT(ڲ*5>0X1MB)[C,] K\%uK6 :ZѵBQ+#fh Ġ;S>aogD|IJJ"/?{)KlllQK@pk lw7[ɀ旤Q&3 1exp 2^Њ$W,fHB9iȰTA/L gnqי1:m^W y^937=&3; Y9lays@ 㴒A^WV![Nlf4 wCVMAs6l|r%%,X2ѭъc9#_z`Υ1 N{ng߈d HŊ&oɑ4Vck i cQn2yU@C8dq~r4#3rafmA𝖵Ӑ-tچ1zǓ:H$m}]$ǝB<8&Hj60S+e1+UxvO L͈V)2dcKw$ԧT*fsM;s&A@+srPђd@X%~R,>AŅoBBotEQ ĢRtmAӠ/mAw2O^æa8nˠüzP>6xk&q;( winҠ1⡎A_e+ ?#<ZY} x ˎ-o ?71U )4Y7x `mEo;h%Kc ŕe.Cm5/2Kiy͕eH48MVˣHâY HB3u{>COicOYS}q1y)V\, >!i85~Q迁"%Fڶ!]8S8j/{3fcf]܂" lT/i$jp8/6[Z#ikM 'GmX܌Ƌw3*fTt ݪ¯jdLɱ8u7Gq3fۉfX )TeF'|_7 QdBɦ{6u^U߽S-J ~S%\hC8KpiG OF1wxp:bp4}GR/ŭA qp:UY?z-g= hະtp?"@4t44Ə(J}T0qefl/*_8xnqV?F:fVGdQCYA'vtXA] X1jM4XX"JV8#$Ӷa fdBYs@ֳ X]-pޚ J%+2'|Zy3+vܚ]yZ?IKUfQ S4p[])  7DI+6~6v=N Uҹp#ڢA[ !q7cODh$J5煰PcC`Ff"mXs4|'6ۭneX# kA:ŋ>+ Az /)2{ <dMÌOkfP;#\2fVZwE}Q*Fn2ld/-t\7*błQ%u„֌pUOHzYKxF/GnEտqW-{>Q8+(ڎk1hY?y^=܋h)s> 6GN,\ӛz)5ݽ4BH&Z t0f !Gӗ1gkrʏTW*UnU.=Bb w?7SASٳB^:FSQSY{iLCyw8C|Rz~oOCg' =4Ӥ&Y:ߋ:)=44tEP/6e(fB- T-:KѺ= R{)G0ԇ)TŋXlDMHTѻ 5* fB<Αvj9Kn-U?D+}ͨ3Y z܆|Gh)tIW71e|<$\*Rߍ46Tx-]NZKWi+uS3]M-tYHVDY=K黴~(DR0NH;\JqG]H;y#m͝t%參Gi/?h?O񫴟ߦO7V+9=HndWkIqzGl2A3Þ.6iS$C?jAnnWJӠӠևzk9z=;1Iw2{EnGN_Q='1FQ=6Ľ z1:s1"!llJJ.-\Y bq/Xb%MDU)BJyfxܪv/}[ł0Zre19& D[ /7w5 q`{EG$\hT@'5x^b@̥8$sӇ IyyCMm*[|V5z鼆r·.qW(k8)A6 QH(b0Yl.uK@. R~}NG`v&LO<}Q8ZؾJya `}tKg" h=v^ $%ӊB|L'Y|zw\].J?W:OKb8)`E%ds!1z 5HCo#<ߧi'1;Ԋ(K5dC ~ORiq >5$i\~~D?FY 4plFnJ3I9hm=U[/0fx#=./ˉh]OWf{Ik-\&4=Qx&9ZRV&"s$Яy@( oh9}Pn+G?8*uzö?#܅ϝ頯ֆG med''EѮ@{vG!'Q-KAT8ے۳RH,C H6~7~Z$g/uT*^@ /4?h3 COm>o("N{0w-r 3=81EIBhG1 hAv|v7*8 D O$Wr"'߇LXV<#v?UgWaKwX.ҝQr$a1C2ԭZ?vPX>Bn3TV;Ng(!j<$}E]bݍ;[7+.C{=hg^uuv?ϢEh?7sσ&7no?PK  G_>ң)3org/gradle/cli/CommandLineParser$AfterOptions.classmOP( @ 1Q|Dt1wkծ5wE#]|!Je<1Mz99s۟PƊ'IW1!y &TU,2~=x6x !fu'\lkug!s6tL![/Hvfe׹[‘zdL[N!e`oyXuyej&!&)bA02]yr^5Vf6R\4dr] C0ԖQi26{{J.-ߏ޺&Ww{Ֆ/IU0ᘓ*3Le o13/#|]ˣ%D3zaS2u7XMc qaA78yWN*%1|avť-N x!*JB)>#iIShln|AjTDVИF(J9DRR; %܊1C!˩1(|GFJfKmt$F5kj|EFߧjr dY+!kmrQ>э=ep2n&0ft9\9E'tN* iϤK49hPK  GGf3org/gradle/cli/CommandLineParser$OptionString.classSNA=]ʗ(U-e)'#  XlwD w+Bs;s=??~ &cAYs)TҘa! ei,pW]p_8 =[wfnsak璳bv0[=כ)m1$j^C0dlWv8Bv-(wAP ;e(|¯9<Zkߴ>o8ª;UZ-6d7_8'_AyKBkxy>Eӂ4Ui 1 z]A@Z Moz~]{*Ka:r摎, b^hxc+ ݥNC:`U L1r) ;{2̜?3zE9nB;;esy-w'i< MI^NN֤ʍЛh8Yq|9wvc 91Ȩ(` (OaʓbmDm>X1#Ka ~B>FJg!6l|;4 kaCԍx0r/iA';`CG G¡c#'30@ÌnmaF⺙igM1*[Ĥ=\E7i PK  Gx&T` ;org/gradle/cli/AbstractPropertiesCommandLineConverter.classV[wU L2悡5&I  i-4J`Ei+v fpfD{_ m\KWu dY\go}_p?H8"%ެHO%"ͧ= IX6@7=q|';y !H"r k7b0tuVɫ}%_&I cbj| f1\f)^2bYZ ڦbZ:c듶r*&2 M n8&M2jV)DĜ2W5( ,MIzn)嚺Re9hst4%D  Tmgv֭ttKzAm" e7tv٧) ٹW v"Qys;]^W/ypF,w5h}ے6&FOڕ.e`ZcCQ@Q,_Q+WDh2DDYFCF0-6j qdqțt+#y:*[0JZEf~]r~N WScXD\/ô.'Ƕk_4ЫTS!Wn[0( 5R%պ<a՝ISؾꢦ.Ci$h{wfЪCMx(t'9%f9o=,N=M柃B&; ﭣ/ N?gyO:aeJ^/F}o b b4kt"tZ3 яU0fx'ySr 6 aadB3 /)LF}Atc^l?$ͼA_ !7Vkg렾@ ‡CGGDoЅph.` (rroYJ]kKIrIn#)`,r|4 mYYBY-B1>q?PK  G ,org/gradle/cli/ParsedCommandLineOption.classS[OA-"\A(-ʊP1!iĤoC;Ylw- &JD}G.I|9|93|`+)dPPQL!B0冊I,-,&q[~器+䲤⾊ {lqWAW-+ b^ f~,Cz2$J^YA4_T[Wjls6)5fn2Gsy;+c&k_2U`V]Rm4=a[T.ipoSP0/DND=t=Z+jpS0? KOrbjrjd0ajWKp &N&7YָE4Wl/xY92,BS*jx<Iy2=4yt Zce[ZҚE̙swy' :iB&1!CŴ3*f5$0b^E!YsMKc2\(4ff[\xf}f!?\t]($zr,.épx| luj6%;fOxզPɭq…% v2^l"P+ܧ8ش癄[2۟kVMa*W`sQ(r Q.$uv\ y;>ަVv[fnYx2=Y#X13:ncTŢ%,Xѱ5Pg),V5H3 K; 3'<<JڵSΐ!/g&W;;^ݸ v,ly/x-/TQZ]܉\E/˕=lk<RwgrŁtZ.=EPhh+"J6mL+"F~OA-, f1B 娆E$5"y  3@AU'2P*= QE3D5@}C2Pw'3y=RHI8[-vtn5@ $}_+:)+C EoPK  G'H g)org/gradle/cli/CommandLineConverter.classQMK@}ԯ'"4 FM)HQ ޷lI7ݔ6MBya=t$S l)8A {Oyb :˄3I5' JXdT"qx{a/4OR1=Q615 ڹ6ƇEWbRh{'qj1M8zta,gZTRwZ\SYVSݜnhUYB/n/1Oz_G86\fjAʚajJuG-UʙeZ7^[u(5}2(Y٪Zk$N(@yA(تeٺip|0Xh5UUJ`[QtZw&~ժ:ѷ3<MSn9j*ߌq\6 G J*yN;{2#hfc f*SL Èaq!y" Ǘ axIbtxh.x%0&X}?:Ui4^}R֚Be*"nE& ̗he;*J"b68pÕ7rC.?V-0fO~^y뱉6{*B^*Y-z=:7CRyʍհjHC*dfN͔W{M ^pCMPzkt_gBR,]x;^Vw+eM+" ;zf7i^/O3}xb]C[B]d5c|Q%G7GO=m~} ҈'ҮOC.i^yb;30rؑ^!yڢ{f U5$:2lދ9eX Lm1 }IbR$Yy|M7PK  G;|9org/gradle/cli/SystemPropertiesCommandLineConverter.classJ@ثmjE5BDąR/P~ӑ$&BJW 'iAY3͜l "lYlE <& d@HgL{:rRs:C*X4NĬQ ۴;hZ3a ѽG!]Gv7S"5eb o}ɸGtFMz9y~X{()spL`7e.KV, TXxɢfDTEGPWJmh~49AjxѰ sh gԙn85].FԒs9Q΢*s/@Ug J*ce+s+1 $p6/t-,;h-.Z >kZPK  G-h2org/gradle/cli/CommandLineParser$ParserState.classSoPN) sT4706|3M$m f{@ú[s-?&>GmdiҞ|~pF62΢jv,-4WׄTqB0;%v=^(>{J` aŴ9,D!PK  GF= ;org/gradle/cli/CommandLineParser$AfterFirstSubCommand.classVRPN[J;be-x)U.R(XE_( |gtPq猏C8I K0㟳{v|gw9| E͈4тHA/pK\3*B;ExqOH0ԛoB Нҍ\$gȫy%ͫ!k)USdqW5ռ0l%^--1x[+T^ɓğҳr~I6T/ =]kS1&U`fV Ҍ)F2/ Y88f-IMy$ M1eLo H2ڼ})MzٛZʑ"P\\y6O\}9ݲ'JBKeվm gËYzK/ Z1}**2 ~CG&1%`Z 3t9eaёgںokǔ@g%Ku`|G%E5e uS閻5ϗ4ڪ۲b}B\EU6:YPFJjh>3L578")&COH)YslH#?nA;ΙZwQW+S ^ͼ8W'AE[=|>>Јs6MMT > wH{im::^A:HG8d"Fx&O+\AX!vѸq HW69Z e+˝}с; \G7Ĺ(( ]LSh`cB p.9Bj1 D'($U<"z@'bj']GZ f<_PK  Gi}FDgradle-cli-classpath.propertiesSO)IUHIM,RSpIMV02T022422Ppv Q0204*(JM.)**+MPK *G AMETA-INF/PK *GוR?U)META-INF/MANIFEST.MFPK GAorg/PK G Aorg/gradle/PK GAorg/gradle/wrapper/PK Ghdf#org/gradle/wrapper/Download$1.classPK GޅpDorg/gradle/wrapper/Download$SystemPropertiesProxyAuthenticator.classPK GXs"vorg/gradle/wrapper/IDownload.classPK Gz\Q-`org/gradle/wrapper/GradleUserHomeLookup.classPK G] 3org/gradle/wrapper/ExclusiveFileAccessManager.classPK G ^F-org/gradle/wrapper/WrapperConfiguration.classPK GQ}i 0org/gradle/wrapper/SystemPropertiesHandler.classPK Gy0V,org/gradle/wrapper/Logger.classPK Grn&org/gradle/wrapper/PathAssembler.classPK G8޶)  org/gradle/wrapper/Install.classPK GL -q3org/gradle/wrapper/BootstrapMainStarter.classPK GHַ$ #(8org/gradle/wrapper/WrapperExecutor.classPK G B*Corg/gradle/wrapper/GradleWrapperMain.classPK Gx"Norg/gradle/wrapper/Install$1.classPK Gj jV8sUorg/gradle/wrapper/PathAssembler$LocalDistribution.classPK GcJK!}Worg/gradle/wrapper/Download.classPK G>PN#_gradle-wrapper-classpath.propertiesPK  G$ٖef`build-receipt.propertiesPK  GAjaorg/gradle/cli/PK  G<S1aorg/gradle/cli/AbstractCommandLineConverter.classPK  G2_e($dorg/gradle/cli/CommandLineParser$1.classPK  GRB <eorg/gradle/cli/CommandLineParser$MissingOptionArgState.classPK  GM2=horg/gradle/cli/CommandLineParser$OptionStringComparator.classPK  G# GK1jorg/gradle/cli/CommandLineArgumentException.classPK  G?h=lorg/gradle/cli/CommandLineParser$KnownOptionParserState.classPK  Gk7torg/gradle/cli/CommandLineParser$OptionComparator.classPK  Gb'n?worg/gradle/cli/CommandLineParser$UnknownOptionParserState.classPK  G"zZ &{org/gradle/cli/CommandLineOption.classPK  Gl\ϧ8org/gradle/cli/CommandLineParser$OptionParserState.classPK  G[xn&org/gradle/cli/ParsedCommandLine.classPK  GA5l| :org/gradle/cli/ProjectPropertiesCommandLineConverter.classPK  G2lWJForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classPK  Gg*&Corg/gradle/cli/CommandLineParser.classPK  G_>ң)3org/gradle/cli/CommandLineParser$AfterOptions.classPK  GGf3org/gradle/cli/CommandLineParser$OptionString.classPK  Gx&T` ;ŧorg/gradle/cli/AbstractPropertiesCommandLineConverter.classPK  G ,~org/gradle/cli/ParsedCommandLineOption.classPK  Gs=org/gradle/cli/CommandLineParser$OptionAwareParserState.classPK  G'H g)worg/gradle/cli/CommandLineConverter.classPK  GC| <׳org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classPK  G;|9org/gradle/cli/SystemPropertiesCommandLineConverter.classPK  G-h2org/gradle/cli/CommandLineParser$ParserState.classPK  GF= ;Eorg/gradle/cli/CommandLineParser$AfterFirstSubCommand.classPK  Gi}FDۿgradle-cli-classpath.propertiesPK11^javaOIDCMsg-3.0.0/gradle/wrapper/gradle-wrapper.properties000066400000000000000000000003511302130156000234770ustar00rootroot00000000000000#Mon Dec 28 10:00:20 PST 2015 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip javaOIDCMsg-3.0.0/gradlew000077500000000000000000000115531302130156000151100ustar00rootroot00000000000000#!/usr/bin/env bash ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS="" APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn ( ) { echo "$*" } die ( ) { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; esac # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin, switch paths to Windows format before running java if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=$((i+1)) done case $i in (0) set -- ;; (1) set -- "$args0" ;; (2) set -- "$args0" "$args1" ;; (3) set -- "$args0" "$args1" "$args2" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules function splitJvmOpts() { JVM_OPTS=("$@") } eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" javaOIDCMsg-3.0.0/gradlew.bat000066400000000000000000000045441302130156000156540ustar00rootroot00000000000000@if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS= set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windowz variants if not "%OS%" == "Windows_NT" goto win9xME_args if "%@eval[2+2]" == "4" goto 4NT_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* goto execute :4NT_args @rem Get arguments from the 4NT Shell from JP Software set CMD_LINE_ARGS=%$ :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega javaOIDCMsg-3.0.0/lib/000077500000000000000000000000001302130156000142765ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/.gitignore000066400000000000000000000000071302130156000162630ustar00rootroot00000000000000/build javaOIDCMsg-3.0.0/lib/build.gradle000066400000000000000000000026051302130156000165600ustar00rootroot00000000000000apply plugin: 'jacoco' apply plugin: 'java' apply from: '../scripts/release.gradle' apply from: '../scripts/maven.gradle' apply from: '../scripts/bintray.gradle' logger.lifecycle("Using version ${version} for ${group}.${name}") auth0 { name "java jwt" repo "java-jwt" description "Java implementation of JSON Web Token (JWT)" developer { id = "auth0" name = "Auth0" email = "oss@auth0.com" } developer { id = "lbalmaceda" name = "Luciano Balmaceda" email = "luciano.balmaceda@auth0.com" } developer { id = "hzalaz" name = "Hernan Zalazar" email = "hernan@auth0.com" } } compileJava { sourceCompatibility '1.7' } dependencies { compile 'com.fasterxml.jackson.core:jackson-databind:2.8.4' compile 'commons-codec:commons-codec:1.10' compile 'org.bouncycastle:bcprov-jdk15on:1.55' testCompile 'junit:junit:4.12' testCompile 'net.jodah:concurrentunit:0.4.2' testCompile 'org.hamcrest:hamcrest-library:1.3' testCompile 'org.mockito:mockito-core:2.2.8' } jacocoTestReport { reports { xml.enabled = true html.enabled = true } } test { testLogging { events "passed", "skipped", "failed", "standardError" exceptionFormat "short" } } task clean(type: Delete) { delete rootProject.buildDir delete 'CHANGELOG.md.release' } javaOIDCMsg-3.0.0/lib/src/000077500000000000000000000000001302130156000150655ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/000077500000000000000000000000001302130156000160115ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/000077500000000000000000000000001302130156000167325ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/000077500000000000000000000000001302130156000175105ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/000077500000000000000000000000001302130156000205315ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/000077500000000000000000000000001302130156000213355ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/Clock.java000066400000000000000000000005161302130156000232350ustar00rootroot00000000000000package com.auth0.jwt; import java.util.Date; /** * The Clock class is used to wrap calls to Date class. */ class Clock { Clock() { } /** * Returns a new Date representing Today's time. * * @return a new Date representing Today's time. */ Date getToday() { return new Date(); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/JWT.java000066400000000000000000000027511302130156000226510ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.DecodedJWT; import java.util.Date; import java.util.List; @SuppressWarnings("WeakerAccess") public abstract class JWT implements DecodedJWT { /** * Decode a given JWT token. * * Note that this method doesn't verify the token's signature! Use it only if you trust the token or you already verified it. * * @param token with jwt format as string. * @return a decoded token. * @throws JWTDecodeException if any part of the token contained an invalid jwt or JSON format of each of the jwt parts. */ public static JWT decode(String token) throws JWTDecodeException { return new JWTDecoder(token); } /** * Returns a {@link JWTVerifier} builder with the algorithm to be used to validate token signature. * * @param algorithm that will be used to verify the token's signature. * @return {@link JWTVerifier} builder * @throws IllegalArgumentException if the provided algorithm is null. */ public static JWTVerifier.Verification require(Algorithm algorithm) { return JWTVerifier.init(algorithm); } /** * Returns a JWT builder used to create and sign jwt tokens * * @return a jwt token builder. */ public static JWTCreator.Builder create() { return JWTCreator.init(); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/JWTCreator.java000066400000000000000000000167031302130156000241730ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.exceptions.JWTCreationException; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.impl.ClaimsHolder; import com.auth0.jwt.impl.PayloadSerializer; import com.auth0.jwt.impl.PublicClaims; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.module.SimpleModule; import org.apache.commons.codec.binary.Base64; import java.nio.charset.StandardCharsets; import java.util.Date; import java.util.HashMap; import java.util.Map; /** * The JWTCreator class holds the sign method to generate a complete JWT (with Signature) from a given Header and Payload content. */ @SuppressWarnings("WeakerAccess") public final class JWTCreator { private final Algorithm algorithm; private final String headerJson; private final String payloadJson; private JWTCreator(Algorithm algorithm, Map headerClaims, Map payloadClaims) throws JWTCreationException { this.algorithm = algorithm; try { ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addSerializer(ClaimsHolder.class, new PayloadSerializer()); mapper.registerModule(module); headerJson = mapper.writeValueAsString(headerClaims); payloadJson = mapper.writeValueAsString(new ClaimsHolder(payloadClaims)); } catch (JsonProcessingException e) { throw new JWTCreationException("Some of the Claims couldn't be converted to a valid JSON format.", e); } } /** * Initialize a JWTCreator instance. * * @return a JWTCreator.Builder instance to configure. */ static JWTCreator.Builder init() { return new Builder(); } /** * The Builder class holds the Claims that defines the JWT to be created. */ public static class Builder { private final Map payloadClaims; private Map headerClaims; Builder() { this.payloadClaims = new HashMap<>(); this.headerClaims = new HashMap<>(); } /** * Add specific Claims to set as the Header. * * @param headerClaims the values to use as Claims in the token's Header. * @return this same Builder instance. */ public Builder withHeader(Map headerClaims) { this.headerClaims = new HashMap<>(headerClaims); return this; } /** * Add a specific Issuer ("iss") claim. * * @param issuer the Issuer value. * @return this same Builder instance. */ public Builder withIssuer(String issuer) { addClaim(PublicClaims.ISSUER, issuer); return this; } /** * Add a specific Subject ("sub") claim. * * @param subject the Subject value. * @return this same Builder instance. */ public Builder withSubject(String subject) { addClaim(PublicClaims.SUBJECT, subject); return this; } /** * Add a specific Audience ("aud") claim. * * @param audience the Audience value. * @return this same Builder instance. */ public Builder withAudience(String... audience) { addClaim(PublicClaims.AUDIENCE, audience); return this; } /** * Add a specific Expires At ("exp") claim. * * @param expiresAt the Expires At value. * @return this same Builder instance. */ public Builder withExpiresAt(Date expiresAt) { addClaim(PublicClaims.EXPIRES_AT, expiresAt); return this; } /** * Add a specific Not Before ("nbf") claim. * * @param notBefore the Not Before value. * @return this same Builder instance. */ public Builder withNotBefore(Date notBefore) { addClaim(PublicClaims.NOT_BEFORE, notBefore); return this; } /** * Add a specific Issued At ("iat") claim. * * @param issuedAt the Issued At value. * @return this same Builder instance. */ public Builder withIssuedAt(Date issuedAt) { addClaim(PublicClaims.ISSUED_AT, issuedAt); return this; } /** * Add a specific JWT Id ("jti") claim. * * @param jwtId the Token Id value. * @return this same Builder instance. */ public Builder withJWTId(String jwtId) { addClaim(PublicClaims.JWT_ID, jwtId); return this; } /** * Add a custom Claim value. * * @param name the Claim's name * @param value the Claim's value. Must be an instance of Integer, Double, Boolean, Date or String class. * @return this same Builder instance. * @throws IllegalArgumentException if the name is null or the value class is not allowed. */ public Builder withClaim(String name, Object value) throws IllegalArgumentException { final boolean validValue = value instanceof Integer || value instanceof Double || value instanceof Boolean || value instanceof Date || value instanceof String; if (name == null) { throw new IllegalArgumentException("The Custom Claim's name can't be null."); } if (!validValue) { throw new IllegalArgumentException("The Custom Claim's value class must be an instance of Integer, Double, Boolean, Date or String."); } addClaim(name, value); return this; } /** * Creates a new JWT and signs is with the given algorithm * * @param algorithm used to sign the JWT * @return a new JWT token * @throws IllegalArgumentException if the provided algorithm is null. * @throws JWTCreationException if the claims could not be converted to a valid JSON or there was a problem with the signing key. */ public String sign(Algorithm algorithm) throws IllegalArgumentException, JWTCreationException { if (algorithm == null) { throw new IllegalArgumentException("The Algorithm cannot be null."); } headerClaims.put(PublicClaims.ALGORITHM, algorithm.getName()); return new JWTCreator(algorithm, headerClaims, payloadClaims).sign(); } private void addClaim(String name, Object value) { if (value == null) { payloadClaims.remove(name); return; } payloadClaims.put(name, value); } } private String sign() throws SignatureGenerationException { String header = Base64.encodeBase64URLSafeString((headerJson.getBytes(StandardCharsets.UTF_8))); String payload = Base64.encodeBase64URLSafeString((payloadJson.getBytes(StandardCharsets.UTF_8))); String content = String.format("%s.%s", header, payload); byte[] signatureBytes = algorithm.sign(content.getBytes(StandardCharsets.UTF_8)); String signature = Base64.encodeBase64URLSafeString((signatureBytes)); return String.format("%s.%s", content, signature); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/JWTDecoder.java000066400000000000000000000055401302130156000241360ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.impl.JWTParser; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.DecodedJWT; import com.auth0.jwt.interfaces.Header; import com.auth0.jwt.interfaces.Payload; import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.binary.StringUtils; import java.util.Date; import java.util.List; /** * The JWTDecoder class holds the decode method to parse a given JWT token into it's JWT representation. */ @SuppressWarnings("WeakerAccess") final class JWTDecoder extends JWT { private final String token; private Header header; private Payload payload; private String signature; JWTDecoder(String jwt) throws JWTDecodeException { this.token = jwt; parseToken(jwt); } private void parseToken(String token) throws JWTDecodeException { final String[] parts = TokenUtils.splitToken(token); final JWTParser converter = new JWTParser(); String headerJson; String payloadJson; try { headerJson = StringUtils.newStringUtf8(Base64.decodeBase64(parts[0])); payloadJson = StringUtils.newStringUtf8(Base64.decodeBase64(parts[1])); } catch (NullPointerException e) { throw new JWTDecodeException("The UTF-8 Charset isn't initialized.", e); } header = converter.parseHeader(headerJson); payload = converter.parsePayload(payloadJson); signature = parts[2]; } @Override public String getAlgorithm() { return header.getAlgorithm(); } @Override public String getType() { return header.getType(); } @Override public String getContentType() { return header.getContentType(); } @Override public String getKeyId() { return header.getKeyId(); } @Override public Claim getHeaderClaim(String name) { return header.getHeaderClaim(name); } @Override public String getIssuer() { return payload.getIssuer(); } @Override public String getSubject() { return payload.getSubject(); } @Override public List getAudience() { return payload.getAudience(); } @Override public Date getExpiresAt() { return payload.getExpiresAt(); } @Override public Date getNotBefore() { return payload.getNotBefore(); } @Override public Date getIssuedAt() { return payload.getIssuedAt(); } @Override public String getId() { return payload.getId(); } @Override public Claim getClaim(String name) { return payload.getClaim(name); } @Override public String getSignature() { return signature; } @Override public String getToken() { return token; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/JWTVerifier.java000066400000000000000000000336641302130156000243540ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.exceptions.AlgorithmMismatchException; import com.auth0.jwt.exceptions.InvalidClaimException; import com.auth0.jwt.exceptions.JWTVerificationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import com.auth0.jwt.impl.PublicClaims; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.DecodedJWT; import org.apache.commons.codec.binary.Base64; import java.nio.charset.StandardCharsets; import java.util.*; /** * The JWTVerifier class holds the verify method to assert that a given Token has not only a proper JWT format, but also it's signature matches. */ @SuppressWarnings("WeakerAccess") public final class JWTVerifier { private final Algorithm algorithm; final Map claims; private final Clock clock; JWTVerifier(Algorithm algorithm, Map claims, Clock clock) { this.algorithm = algorithm; this.claims = Collections.unmodifiableMap(claims); this.clock = clock; } /** * Initialize a JWTVerifier instance using the given Algorithm. * * @param algorithm the Algorithm to use on the JWT verification. * @return a JWTVerifier.Verification instance to configure. * @throws IllegalArgumentException if the provided algorithm is null. */ static JWTVerifier.Verification init(Algorithm algorithm) throws IllegalArgumentException { return new Verification(algorithm); } /** * The Verification class holds the Claims required by a JWT to be valid. */ public static class Verification { private final Algorithm algorithm; private final Map claims; private long defaultLeeway; Verification(Algorithm algorithm) throws IllegalArgumentException { if (algorithm == null) { throw new IllegalArgumentException("The Algorithm cannot be null."); } this.algorithm = algorithm; this.claims = new HashMap<>(); this.defaultLeeway = 0; } /** * Require a specific Issuer ("iss") claim. * * @param issuer the required Issuer value * @return this same Verification instance. */ public Verification withIssuer(String issuer) { requireClaim(PublicClaims.ISSUER, issuer); return this; } /** * Require a specific Subject ("sub") claim. * * @param subject the required Subject value * @return this same Verification instance. */ public Verification withSubject(String subject) { requireClaim(PublicClaims.SUBJECT, subject); return this; } /** * Require a specific Audience ("aud") claim. * * @param audience the required Audience value * @return this same Verification instance. */ public Verification withAudience(String... audience) { requireClaim(PublicClaims.AUDIENCE, Arrays.asList(audience)); return this; } /** * Define the default window in milliseconds in which the Not Before, Issued At and Expires At Claims will still be valid. * Setting a specific leeway value on a given Claim will override this value for that Claim. * * @param leeway the window in seconds in which the Not Before, Issued At and Expires At Claims will still be valid. * @return this same Verification instance. * @throws IllegalArgumentException if leeway is negative. */ public Verification acceptLeeway(long leeway) throws IllegalArgumentException { if (leeway < 0) { throw new IllegalArgumentException("Leeway value can't be negative."); } this.defaultLeeway = leeway; return this; } /** * Set a specific leeway window in seconds in which the Expires At ("exp") Claim will still be valid. * Expiration Date is always verified when the value is present. This method overrides the value set with acceptLeeway * * @param leeway the window in seconds in which the Expires At Claim will still be valid. * @return this same Verification instance. * @throws IllegalArgumentException if leeway is negative. */ public Verification acceptExpiresAt(long leeway) throws IllegalArgumentException { if (leeway < 0) { throw new IllegalArgumentException("Leeway value can't be negative."); } requireClaim(PublicClaims.EXPIRES_AT, leeway); return this; } /** * Set a specific leeway window in seconds in which the Not Before ("nbf") Claim will still be valid. * Not Before Date is always verified when the value is present. This method overrides the value set with acceptLeeway * * @param leeway the window in seconds in which the Not Before Claim will still be valid. * @return this same Verification instance. * @throws IllegalArgumentException if leeway is negative. */ public Verification acceptNotBefore(long leeway) throws IllegalArgumentException { if (leeway < 0) { throw new IllegalArgumentException("Leeway value can't be negative."); } requireClaim(PublicClaims.NOT_BEFORE, leeway); return this; } /** * Set a specific leeway window in seconds in which the Issued At ("iat") Claim will still be valid. * Issued At Date is always verified when the value is present. This method overrides the value set with acceptLeeway * * @param leeway the window in seconds in which the Issued At Claim will still be valid. * @return this same Verification instance. * @throws IllegalArgumentException if leeway is negative. */ public Verification acceptIssuedAt(long leeway) throws IllegalArgumentException { if (leeway < 0) { throw new IllegalArgumentException("Leeway value can't be negative."); } requireClaim(PublicClaims.ISSUED_AT, leeway); return this; } /** * Require a specific JWT Id ("jti") claim. * * @param jwtId the required Id value * @return this same Verification instance. */ public Verification withJWTId(String jwtId) { requireClaim(PublicClaims.JWT_ID, jwtId); return this; } /** * Require a specific Claim value. * * @param name the Claim's name * @param value the Claim's value. Must be an instance of Integer, Double, Boolean, Date or String class. * @return this same Verification instance. * @throws IllegalArgumentException if the name is null or the value class is not allowed. */ public Verification withClaim(String name, Object value) throws IllegalArgumentException { final boolean validValue = value instanceof Integer || value instanceof Double || value instanceof Boolean || value instanceof Date || value instanceof String; if (name == null) { throw new IllegalArgumentException("The Custom Claim's name can't be null."); } if (!validValue) { throw new IllegalArgumentException("The Custom Claim's value class must be an instance of Integer, Double, Boolean, Date or String."); } requireClaim(name, value); return this; } /** * Creates a new and reusable instance of the JWTVerifier with the configuration already provided. * * @return a new JWTVerifier instance. */ public JWTVerifier build() { return this.build(new Clock()); } /** * Creates a new and reusable instance of the JWTVerifier with the configuration already provided. * ONLY FOR TEST PURPOSES. * * @param clock the instance that will handle the current time. * @return a new JWTVerifier instance with a custom Clock. */ JWTVerifier build(Clock clock) { addLeewayToDateClaims(); return new JWTVerifier(algorithm, claims, clock); } private void addLeewayToDateClaims() { if (!claims.containsKey(PublicClaims.EXPIRES_AT)) { claims.put(PublicClaims.EXPIRES_AT, defaultLeeway); } if (!claims.containsKey(PublicClaims.NOT_BEFORE)) { claims.put(PublicClaims.NOT_BEFORE, defaultLeeway); } if (!claims.containsKey(PublicClaims.ISSUED_AT)) { claims.put(PublicClaims.ISSUED_AT, defaultLeeway); } } private void requireClaim(String name, Object value) { if (value == null) { claims.remove(name); return; } claims.put(name, value); } } /** * Perform the verification against the given Token, using any previous configured options. * * @param token to verify. * @return a verified and decoded JWT. * @throws JWTVerificationException if any of the required contents inside the JWT is invalid. */ public DecodedJWT verify(String token) throws JWTVerificationException { DecodedJWT jwt = JWTDecoder.decode(token); verifyAlgorithm(jwt, algorithm); verifySignature(TokenUtils.splitToken(token)); verifyClaims(jwt, claims); return jwt; } private void verifySignature(String[] parts) throws SignatureVerificationException { byte[] content = String.format("%s.%s", parts[0], parts[1]).getBytes(StandardCharsets.UTF_8); byte[] signature = Base64.decodeBase64(parts[2]); algorithm.verify(content, signature); } private void verifyAlgorithm(DecodedJWT jwt, Algorithm expectedAlgorithm) throws AlgorithmMismatchException { if (!expectedAlgorithm.getName().equals(jwt.getAlgorithm())) { throw new AlgorithmMismatchException("The provided Algorithm doesn't match the one defined in the JWT's Header."); } } private void verifyClaims(DecodedJWT jwt, Map claims) { for (Map.Entry entry : claims.entrySet()) { switch (entry.getKey()) { case PublicClaims.AUDIENCE: //noinspection unchecked assertValidAudienceClaim(jwt.getAudience(), (List) entry.getValue()); break; case PublicClaims.EXPIRES_AT: assertValidDateClaim(jwt.getExpiresAt(), (Long) entry.getValue(), true); break; case PublicClaims.ISSUED_AT: assertValidDateClaim(jwt.getIssuedAt(), (Long) entry.getValue(), false); break; case PublicClaims.NOT_BEFORE: assertValidDateClaim(jwt.getNotBefore(), (Long) entry.getValue(), false); break; case PublicClaims.ISSUER: assertValidStringClaim(entry.getKey(), jwt.getIssuer(), (String) entry.getValue()); break; case PublicClaims.JWT_ID: assertValidStringClaim(entry.getKey(), jwt.getId(), (String) entry.getValue()); break; case PublicClaims.SUBJECT: assertValidStringClaim(entry.getKey(), jwt.getSubject(), (String) entry.getValue()); break; default: assertValidClaim(jwt.getClaim(entry.getKey()), entry.getKey(), entry.getValue()); break; } } } private void assertValidClaim(Claim claim, String claimName, Object value) { boolean isValid = false; if (value instanceof String) { isValid = value.equals(claim.asString()); } else if (value instanceof Integer) { isValid = value.equals(claim.asInt()); } else if (value instanceof Boolean) { isValid = value.equals(claim.asBoolean()); } else if (value instanceof Double) { isValid = value.equals(claim.asDouble()); } else if (value instanceof Date) { isValid = value.equals(claim.asDate()); } if (!isValid) { throw new InvalidClaimException(String.format("The Claim '%s' value doesn't match the required one.", claimName)); } } private void assertValidStringClaim(String claimName, String value, String expectedValue) { if (!expectedValue.equals(value)) { throw new InvalidClaimException(String.format("The Claim '%s' value doesn't match the required one.", claimName)); } } private void assertValidDateClaim(Date date, long leeway, boolean shouldBeFuture) { Date today = clock.getToday(); today.setTime((long) Math.floor((today.getTime() / 1000) * 1000)); //truncate millis boolean isValid; String errMessage; if (shouldBeFuture) { today.setTime(today.getTime() - leeway * 1000); isValid = date == null || !today.after(date); errMessage = String.format("The Token has expired on %s.", date); } else { today.setTime(today.getTime() + leeway * 1000); isValid = date == null || !today.before(date); errMessage = String.format("The Token can't be used before %s.", date); } if (!isValid) { throw new InvalidClaimException(errMessage); } } private void assertValidAudienceClaim(List audience, List value) { if (audience == null || !audience.containsAll(value)) { throw new InvalidClaimException("The Claim 'aud' value doesn't contain the required audience."); } } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/TokenUtils.java000066400000000000000000000015761302130156000243120ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.exceptions.JWTDecodeException; abstract class TokenUtils { /** * Splits the given token on the "." chars into a String array with 3 parts. * * @param token the string to split. * @return the array representing the 3 parts of the token. * @throws JWTDecodeException if the Token doesn't have 3 parts. */ static String[] splitToken(String token) throws JWTDecodeException { String[] parts = token.split("\\."); if (parts.length == 2 && token.endsWith(".")) { //Tokens with alg='none' have empty String as Signature. parts = new String[]{parts[0], parts[1], ""}; } if (parts.length != 3) { throw new JWTDecodeException(String.format("The token was expected to have 3 parts, but got %s.", parts.length)); } return parts; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/000077500000000000000000000000001302130156000235065ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/Algorithm.java000066400000000000000000000201361302130156000263010ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import java.io.UnsupportedEncodingException; import java.security.interfaces.ECKey; import java.security.interfaces.RSAKey; /** * The Algorithm class represents an algorithm to be used in the Signing or Verification process of a Token. */ public abstract class Algorithm { private final String name; private final String description; /** * Creates a new Algorithm instance using SHA256withRSA. Tokens specify this as "RS256". * * @param key the key to use in the verify or signing instance. * @return a valid RSA256 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm RSA256(RSAKey key) throws IllegalArgumentException { return new RSAAlgorithm("RS256", "SHA256withRSA", key); } /** * Creates a new Algorithm instance using SHA384withRSA. Tokens specify this as "RS384". * * @param key the key to use in the verify or signing instance. * @return a valid RSA384 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm RSA384(RSAKey key) throws IllegalArgumentException { return new RSAAlgorithm("RS384", "SHA384withRSA", key); } /** * Creates a new Algorithm instance using SHA512withRSA. Tokens specify this as "RS512". * * @param key the key to use in the verify or signing instance. * @return a valid RSA512 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm RSA512(RSAKey key) throws IllegalArgumentException { return new RSAAlgorithm("RS512", "SHA512withRSA", key); } /** * Creates a new Algorithm instance using HmacSHA256. Tokens specify this as "HS256". * * @param secret the secret to use in the verify or signing instance. * @return a valid HMAC256 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. * @throws UnsupportedEncodingException if the current Java platform implementation doesn't support the UTF-8 character encoding. */ public static Algorithm HMAC256(String secret) throws IllegalArgumentException, UnsupportedEncodingException { return new HMACAlgorithm("HS256", "HmacSHA256", secret); } /** * Creates a new Algorithm instance using HmacSHA384. Tokens specify this as "HS384". * * @param secret the secret to use in the verify or signing instance. * @return a valid HMAC384 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. * @throws UnsupportedEncodingException if the current Java platform implementation doesn't support the UTF-8 character encoding. */ public static Algorithm HMAC384(String secret) throws IllegalArgumentException, UnsupportedEncodingException { return new HMACAlgorithm("HS384", "HmacSHA384", secret); } /** * Creates a new Algorithm instance using HmacSHA512. Tokens specify this as "HS512". * * @param secret the secret to use in the verify or signing instance. * @return a valid HMAC512 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. * @throws UnsupportedEncodingException if the current Java platform implementation doesn't support the UTF-8 character encoding. */ public static Algorithm HMAC512(String secret) throws IllegalArgumentException, UnsupportedEncodingException { return new HMACAlgorithm("HS512", "HmacSHA512", secret); } /** * Creates a new Algorithm instance using HmacSHA256. Tokens specify this as "HS256". * * @param secret the secret bytes to use in the verify or signing instance. * @return a valid HMAC256 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. */ public static Algorithm HMAC256(byte[] secret) throws IllegalArgumentException { return new HMACAlgorithm("HS256", "HmacSHA256", secret); } /** * Creates a new Algorithm instance using HmacSHA384. Tokens specify this as "HS384". * * @param secret the secret bytes to use in the verify or signing instance. * @return a valid HMAC384 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. */ public static Algorithm HMAC384(byte[] secret) throws IllegalArgumentException { return new HMACAlgorithm("HS384", "HmacSHA384", secret); } /** * Creates a new Algorithm instance using HmacSHA512. Tokens specify this as "HS512". * * @param secret the secret bytes to use in the verify or signing instance. * @return a valid HMAC512 Algorithm. * @throws IllegalArgumentException if the provided Secret is null. */ public static Algorithm HMAC512(byte[] secret) throws IllegalArgumentException { return new HMACAlgorithm("HS512", "HmacSHA512", secret); } /** * Creates a new Algorithm instance using SHA256withECDSA. Tokens specify this as "ES256". * * @param key the key to use in the verify or signing instance. * @return a valid ECDSA256 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm ECDSA256(ECKey key) throws IllegalArgumentException { return new ECDSAAlgorithm("ES256", "SHA256withECDSA", 32, key); } /** * Creates a new Algorithm instance using SHA384withECDSA. Tokens specify this as "ES384". * * @param key the key to use in the verify or signing instance. * @return a valid ECDSA384 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm ECDSA384(ECKey key) throws IllegalArgumentException { return new ECDSAAlgorithm("ES384", "SHA384withECDSA", 48, key); } /** * Creates a new Algorithm instance using SHA512withECDSA. Tokens specify this as "ES512". * * @param key the key to use in the verify or signing instance. * @return a valid ECDSA512 Algorithm. * @throws IllegalArgumentException if the provided Key is null. */ public static Algorithm ECDSA512(ECKey key) throws IllegalArgumentException { return new ECDSAAlgorithm("ES512", "SHA512withECDSA", 66, key); } public static Algorithm none() { return new NoneAlgorithm(); } protected Algorithm(String name, String description) { this.name = name; this.description = description; } /** * Getter for the name of this Algorithm, as defined in the JWT Standard. i.e. "HS256" * * @return the algorithm name. */ public String getName() { return name; } /** * Getter for the description of this Algorithm, required when instantiating a Mac or Signature object. i.e. "HmacSHA256" * * @return the algorithm description. */ String getDescription() { return description; } @Override public String toString() { return description; } /** * Verify the given content using this Algorithm instance. * * @param contentBytes an array of bytes representing the base64 encoded content to be verified against the signature. * @param signatureBytes an array of bytes representing the base64 encoded signature to compare the content against. * @throws SignatureVerificationException if the Token's Signature is invalid, meaning that it doesn't match the signatureBytes, or if the Key is invalid. */ public abstract void verify(byte[] contentBytes, byte[] signatureBytes) throws SignatureVerificationException; /** * Sign the given content using this Algorithm instance. * * @param contentBytes an array of bytes representing the base64 encoded content to be verified against the signature. * @return the signature in a base64 encoded array of bytes * @throws SignatureGenerationException if the Key is invalid. */ public abstract byte[] sign(byte[] contentBytes) throws SignatureGenerationException; } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/CryptoHelper.java000066400000000000000000000026261302130156000267770ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import java.security.*; class CryptoHelper { boolean verifySignatureFor(String algorithm, byte[] secretBytes, byte[] contentBytes, byte[] signatureBytes) throws NoSuchAlgorithmException, InvalidKeyException { return MessageDigest.isEqual(createSignatureFor(algorithm, secretBytes, contentBytes), signatureBytes); } byte[] createSignatureFor(String algorithm, byte[] secretBytes, byte[] contentBytes) throws NoSuchAlgorithmException, InvalidKeyException { final Mac mac = Mac.getInstance(algorithm); mac.init(new SecretKeySpec(secretBytes, algorithm)); return mac.doFinal(contentBytes); } boolean verifySignatureFor(String algorithm, PublicKey publicKey, byte[] contentBytes, byte[] signatureBytes) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { final Signature s = Signature.getInstance(algorithm); s.initVerify(publicKey); s.update(contentBytes); return s.verify(signatureBytes); } byte[] createSignatureFor(String algorithm, PrivateKey privateKey, byte[] contentBytes) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { final Signature s = Signature.getInstance(algorithm); s.initSign(privateKey); s.update(contentBytes); return s.sign(); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/ECDSAAlgorithm.java000066400000000000000000000116131302130156000270410ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.SignatureException; import java.security.interfaces.ECKey; import java.security.interfaces.ECPrivateKey; import java.security.interfaces.ECPublicKey; class ECDSAAlgorithm extends Algorithm { private final CryptoHelper crypto; private final int ecNumberSize; private final ECKey key; ECDSAAlgorithm(CryptoHelper crypto, String id, String algorithm, int ecNumberSize, ECKey key) throws IllegalArgumentException { super(id, algorithm); if (key == null) { throw new IllegalArgumentException("The ECKey cannot be null"); } this.ecNumberSize = ecNumberSize; this.key = key; this.crypto = crypto; } ECDSAAlgorithm(String id, String algorithm, int ecNumberSize, ECKey key) throws IllegalArgumentException { this(new CryptoHelper(), id, algorithm, ecNumberSize, key); } ECKey getKey() { return key; } @Override public void verify(byte[] contentBytes, byte[] signatureBytes) throws SignatureVerificationException { try { if (!(key instanceof ECPublicKey)) { throw new IllegalArgumentException("The given ECKey is not an ECPublicKey."); } if (!isDERSignature(signatureBytes)) { signatureBytes = JOSEToDER(signatureBytes); } boolean valid = crypto.verifySignatureFor(getDescription(), (ECPublicKey) key, contentBytes, signatureBytes); if (!valid) { throw new SignatureVerificationException(this); } } catch (NoSuchAlgorithmException | SignatureException | InvalidKeyException | IllegalArgumentException e) { throw new SignatureVerificationException(this, e); } } @Override public byte[] sign(byte[] contentBytes) throws SignatureGenerationException { try { if (!(key instanceof ECPrivateKey)) { throw new IllegalArgumentException("The given ECKey is not a ECPrivateKey."); } return crypto.createSignatureFor(getDescription(), (PrivateKey) key, contentBytes); } catch (NoSuchAlgorithmException | SignatureException | InvalidKeyException | IllegalArgumentException e) { throw new SignatureGenerationException(this, e); } } private boolean isDERSignature(byte[] signature) { // DER Structure: http://crypto.stackexchange.com/a/1797 // Should begin with 0x30 and have exactly the expected length return signature[0] == 0x30 && signature.length != ecNumberSize * 2; } private byte[] JOSEToDER(byte[] joseSignature) throws SignatureException { if (joseSignature.length != ecNumberSize * 2) { throw new SignatureException(String.format("The signature length was invalid. Expected %d bytes but received %d", ecNumberSize * 2, joseSignature.length)); } // Retrieve R and S number's length and padding. int rPadding = countPadding(joseSignature, 0, ecNumberSize); int sPadding = countPadding(joseSignature, ecNumberSize, joseSignature.length); int rLength = ecNumberSize - rPadding; int sLength = ecNumberSize - sPadding; int length = 2 + rLength + 2 + sLength; if (length > 255) { throw new SignatureException("Invalid ECDSA signature format"); } byte[] derSignature; int offset; if (length > 0x7f) { derSignature = new byte[3 + length]; derSignature[1] = (byte) 0x81; offset = 2; } else { derSignature = new byte[2 + length]; offset = 1; } // DER Structure: http://crypto.stackexchange.com/a/1797 // Header with length info derSignature[0] = (byte) 0x30; derSignature[offset++] = (byte) length; derSignature[offset++] = (byte) 0x02; derSignature[offset++] = (byte) rLength; // R number System.arraycopy(joseSignature, 0, derSignature, offset + (rLength - ecNumberSize), ecNumberSize); offset += rLength; // S number length derSignature[offset++] = (byte) 0x02; derSignature[offset++] = (byte) sLength; // S number System.arraycopy(joseSignature, ecNumberSize, derSignature, offset + (sLength - ecNumberSize), ecNumberSize); return derSignature; } private int countPadding(byte[] bytes, int fromIndex, int toIndex) { int padding = 0; while (fromIndex + padding < toIndex && bytes[fromIndex + padding] == 0) { padding++; } return bytes[fromIndex + padding] > 0x7f ? padding : padding - 1; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/HMACAlgorithm.java000066400000000000000000000045261302130156000267370ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import org.apache.commons.codec.CharEncoding; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; class HMACAlgorithm extends Algorithm { private final CryptoHelper crypto; private final byte[] secret; HMACAlgorithm(CryptoHelper crypto, String id, String algorithm, byte[] secretBytes) throws IllegalArgumentException { super(id, algorithm); if (secretBytes == null) { throw new IllegalArgumentException("The Secret cannot be null"); } this.secret = secretBytes; this.crypto = crypto; } HMACAlgorithm(String id, String algorithm, byte[] secretBytes) throws IllegalArgumentException { this(new CryptoHelper(), id, algorithm, secretBytes); } HMACAlgorithm(String id, String algorithm, String secret) throws IllegalArgumentException, UnsupportedEncodingException { this(new CryptoHelper(), id, algorithm, getSecretBytes(secret)); } static byte[] getSecretBytes(String secret) throws IllegalArgumentException, UnsupportedEncodingException { if (secret == null) { throw new IllegalArgumentException("The Secret cannot be null"); } return secret.getBytes(CharEncoding.UTF_8); } byte[] getSecret() { return secret; } @Override public void verify(byte[] contentBytes, byte[] signatureBytes) throws SignatureVerificationException { try { boolean valid = crypto.verifySignatureFor(getDescription(), secret, contentBytes, signatureBytes); if (!valid) { throw new SignatureVerificationException(this); } } catch (IllegalStateException | InvalidKeyException | NoSuchAlgorithmException e) { throw new SignatureVerificationException(this, e); } } @Override public byte[] sign(byte[] contentBytes) throws SignatureGenerationException { try { return crypto.createSignatureFor(getDescription(), secret, contentBytes); } catch (NoSuchAlgorithmException | InvalidKeyException e) { throw new SignatureGenerationException(this, e); } } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/NoneAlgorithm.java000066400000000000000000000011721302130156000271200ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; class NoneAlgorithm extends Algorithm { NoneAlgorithm() { super("none", "none"); } @Override public void verify(byte[] contentBytes, byte[] signatureBytes) throws SignatureVerificationException { if (signatureBytes.length > 0) { throw new SignatureVerificationException(this); } } @Override public byte[] sign(byte[] contentBytes) throws SignatureGenerationException { return new byte[0]; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/algorithms/RSAAlgorithm.java000066400000000000000000000042641302130156000266530ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import java.security.*; import java.security.interfaces.RSAKey; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; class RSAAlgorithm extends Algorithm { private final RSAKey key; private final CryptoHelper crypto; RSAAlgorithm(CryptoHelper crypto, String id, String algorithm, RSAKey key) throws IllegalArgumentException { super(id, algorithm); if (key == null) { throw new IllegalArgumentException("The RSAKey cannot be null"); } this.key = key; this.crypto = crypto; } RSAAlgorithm(String id, String algorithm, RSAKey key) throws IllegalArgumentException { this(new CryptoHelper(), id, algorithm, key); } RSAKey getKey() { return key; } @Override public void verify(byte[] contentBytes, byte[] signatureBytes) throws SignatureVerificationException { try { if (!(key instanceof PublicKey)) { throw new IllegalArgumentException("The given RSAKey is not a RSAPublicKey."); } boolean valid = crypto.verifySignatureFor(getDescription(), (RSAPublicKey) key, contentBytes, signatureBytes); if (!valid) { throw new SignatureVerificationException(this); } } catch (NoSuchAlgorithmException | SignatureException | InvalidKeyException | IllegalArgumentException e) { throw new SignatureVerificationException(this, e); } } @Override public byte[] sign(byte[] contentBytes) throws SignatureGenerationException { try { if (!(key instanceof PrivateKey)) { throw new IllegalArgumentException("The given RSAKey is not a RSAPrivateKey."); } return crypto.createSignatureFor(getDescription(), (RSAPrivateKey) key, contentBytes); } catch (NoSuchAlgorithmException | SignatureException | InvalidKeyException | IllegalArgumentException e) { throw new SignatureGenerationException(this, e); } } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/000077500000000000000000000000001302130156000235165ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/AlgorithmMismatchException.java000066400000000000000000000003061302130156000316530ustar00rootroot00000000000000package com.auth0.jwt.exceptions; public class AlgorithmMismatchException extends JWTVerificationException { public AlgorithmMismatchException(String message) { super(message); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/InvalidClaimException.java000066400000000000000000000002751302130156000306000ustar00rootroot00000000000000package com.auth0.jwt.exceptions; public class InvalidClaimException extends JWTVerificationException { public InvalidClaimException(String message) { super(message); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/JWTCreationException.java000066400000000000000000000003121302130156000303650ustar00rootroot00000000000000package com.auth0.jwt.exceptions; public class JWTCreationException extends RuntimeException { public JWTCreationException(String message, Throwable cause) { super(message, cause); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/JWTDecodeException.java000066400000000000000000000004421302130156000300100ustar00rootroot00000000000000package com.auth0.jwt.exceptions; public class JWTDecodeException extends JWTVerificationException { public JWTDecodeException(String message) { this(message, null); } public JWTDecodeException(String message, Throwable cause) { super(message, cause); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/JWTVerificationException.java000066400000000000000000000004541302130156000312520ustar00rootroot00000000000000package com.auth0.jwt.exceptions; public class JWTVerificationException extends RuntimeException { public JWTVerificationException(String message) { this(message, null); } public JWTVerificationException(String message, Throwable cause) { super(message, cause); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/SignatureGenerationException.java000066400000000000000000000005441302130156000322200ustar00rootroot00000000000000package com.auth0.jwt.exceptions; import com.auth0.jwt.algorithms.Algorithm; public class SignatureGenerationException extends JWTCreationException { public SignatureGenerationException(Algorithm algorithm, Throwable cause) { super("The Token's Signature couldn't be generated when signing using the Algorithm: " + algorithm, cause); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/exceptions/SignatureVerificationException.java000066400000000000000000000007171302130156000325510ustar00rootroot00000000000000package com.auth0.jwt.exceptions; import com.auth0.jwt.algorithms.Algorithm; public class SignatureVerificationException extends JWTVerificationException { public SignatureVerificationException(Algorithm algorithm) { this(algorithm, null); } public SignatureVerificationException(Algorithm algorithm, Throwable cause) { super("The Token's Signature resulted invalid when verified using the Algorithm: " + algorithm, cause); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/000077500000000000000000000000001302130156000222765ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/BasicHeader.java000066400000000000000000000026241302130156000252770ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.Header; import com.fasterxml.jackson.databind.JsonNode; import java.util.Collections; import java.util.HashMap; import java.util.Map; import static com.auth0.jwt.impl.JsonNodeClaim.extractClaim; /** * The BasicHeader class implements the Header interface. */ class BasicHeader implements Header { private final String algorithm; private final String type; private final String contentType; private final String keyId; private final Map tree; BasicHeader(String algorithm, String type, String contentType, String keyId, Map tree) { this.algorithm = algorithm; this.type = type; this.contentType = contentType; this.keyId = keyId; this.tree = Collections.unmodifiableMap(tree == null ? new HashMap() : tree); } Map getTree() { return tree; } @Override public String getAlgorithm() { return algorithm; } @Override public String getType() { return type; } @Override public String getContentType() { return contentType; } @Override public String getKeyId() { return keyId; } @Override public Claim getHeaderClaim(String name) { return extractClaim(name, tree); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/ClaimsHolder.java000066400000000000000000000007151302130156000255120ustar00rootroot00000000000000package com.auth0.jwt.impl; import java.util.HashMap; import java.util.Map; /** * The ClaimsHolder class is just a wrapper for the Map of Claims used for building a JWT. */ public final class ClaimsHolder { private Map claims; public ClaimsHolder(Map claims) { this.claims = claims == null ? new HashMap() : claims; } Map getClaims() { return claims; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/HeaderDeserializer.java000066400000000000000000000030071302130156000266740ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.deser.std.StdDeserializer; import java.io.IOException; import java.util.Map; class HeaderDeserializer extends StdDeserializer { HeaderDeserializer() { this(null); } private HeaderDeserializer(Class vc) { super(vc); } @Override public BasicHeader deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { Map tree = p.getCodec().readValue(p, new TypeReference>() { }); if (tree == null) { throw new JWTDecodeException("Parsing the Header's JSON resulted on a Null map"); } String algorithm = getString(tree, PublicClaims.ALGORITHM); String type = getString(tree, PublicClaims.TYPE); String contentType = getString(tree, PublicClaims.CONTENT_TYPE); String keyId = getString(tree, PublicClaims.KEY_ID); return new BasicHeader(algorithm, type, contentType, keyId, tree); } String getString(Map tree, String claimName) { JsonNode node = tree.get(claimName); if (node == null || node.isNull()) { return null; } return node.asText(null); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/JWTParser.java000066400000000000000000000040751302130156000247700ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Header; import com.auth0.jwt.interfaces.JWTPartsParser; import com.auth0.jwt.interfaces.Payload; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; import com.fasterxml.jackson.databind.module.SimpleModule; import java.io.IOException; public class JWTParser implements JWTPartsParser { private ObjectMapper mapper; public JWTParser() { this(getDefaultObjectMapper()); } JWTParser(ObjectMapper mapper) { addDeserializers(mapper); this.mapper = mapper; } @Override public Payload parsePayload(String json) throws JWTDecodeException { return convertFromJSON(json, Payload.class); } @Override public Header parseHeader(String json) throws JWTDecodeException { return convertFromJSON(json, Header.class); } private void addDeserializers(ObjectMapper mapper) { SimpleModule module = new SimpleModule(); module.addDeserializer(Payload.class, new PayloadDeserializer()); module.addDeserializer(Header.class, new HeaderDeserializer()); mapper.registerModule(module); } static ObjectMapper getDefaultObjectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS); mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY); return mapper; } @SuppressWarnings("WeakerAccess") T convertFromJSON(String json, Class tClazz) throws JWTDecodeException { JWTDecodeException exception = new JWTDecodeException(String.format("The string '%s' doesn't have a valid JSON format.", json)); if (json == null || !json.startsWith("{") || !json.endsWith("}")) { throw exception; } try { return mapper.readValue(json, tClazz); } catch (IOException e) { throw exception; } } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/JsonNodeClaim.java000066400000000000000000000070071302130156000256320ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Claim; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; /** * The JsonNodeClaim retrieves a claim value from a JsonNode object. */ class JsonNodeClaim implements Claim { private final JsonNode data; private JsonNodeClaim(JsonNode node) { this.data = node; } @Override public Boolean asBoolean() { return !data.isBoolean() ? null : data.asBoolean(); } @Override public Integer asInt() { return !data.isNumber() ? null : data.asInt(); } @Override public Double asDouble() { return !data.isNumber() ? null : data.asDouble(); } @Override public String asString() { return !data.isTextual() ? null : data.asText(); } @Override public Date asDate() { if (!data.canConvertToLong()) { return null; } long seconds = data.asLong(); return new Date(seconds * 1000); } @Override @SuppressWarnings("unchecked") public T[] asArray(Class tClazz) throws JWTDecodeException { if (!data.isArray()) { return null; } ObjectMapper mapper = new ObjectMapper(); T[] arr = (T[]) Array.newInstance(tClazz, data.size()); for (int i = 0; i < data.size(); i++) { try { arr[i] = mapper.treeToValue(data.get(i), tClazz); } catch (JsonProcessingException e) { throw new JWTDecodeException("Couldn't map the Claim's array contents to " + tClazz.getSimpleName(), e); } } return arr; } @Override public List asList(Class tClazz) throws JWTDecodeException { if (!data.isArray()) { return null; } ObjectMapper mapper = new ObjectMapper(); List list = new ArrayList<>(); for (int i = 0; i < data.size(); i++) { try { list.add(mapper.treeToValue(data.get(i), tClazz)); } catch (JsonProcessingException e) { throw new JWTDecodeException("Couldn't map the Claim's array contents to " + tClazz.getSimpleName(), e); } } return list; } @Override public boolean isNull() { return !(data.isArray() || data.canConvertToLong() || data.isTextual() || data.isNumber() || data.isBoolean()); } /** * Helper method to extract a Claim from the given JsonNode tree. * * @param claimName the Claim to search for. * @param tree the JsonNode tree to search the Claim in. * @return a valid non-null Claim. */ static Claim extractClaim(String claimName, Map tree) { JsonNode node = tree.get(claimName); return claimFromNode(node); } /** * Helper method to create a Claim representation from the given JsonNode. * * @param node the JsonNode to convert into a Claim. * @return a valid Claim instance. If the node is null or missing, a NullClaim will be returned. */ static Claim claimFromNode(JsonNode node) { if (node == null || node.isNull() || node.isMissingNode()) { return new NullClaim(); } return new JsonNodeClaim(node); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/NullClaim.java000066400000000000000000000017441302130156000250270ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Claim; import java.util.Date; import java.util.List; /** * The {@link NullClaim} class is a Claim implementation that returns null when any of it's methods it's called. */ public class NullClaim implements Claim { @Override public boolean isNull() { return true; } @Override public Boolean asBoolean() { return null; } @Override public Integer asInt() { return null; } @Override public Double asDouble() { return null; } @Override public String asString() { return null; } @Override public Date asDate() { return null; } @Override public T[] asArray(Class tClazz) throws JWTDecodeException { return null; } @Override public List asList(Class tClazz) throws JWTDecodeException { return null; } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/PayloadDeserializer.java000066400000000000000000000060571302130156000271050ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Payload; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.deser.std.StdDeserializer; import java.io.IOException; import java.util.*; class PayloadDeserializer extends StdDeserializer { PayloadDeserializer() { this(null); } private PayloadDeserializer(Class vc) { super(vc); } @Override public Payload deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { Map tree = p.getCodec().readValue(p, new TypeReference>() { }); if (tree == null) { throw new JWTDecodeException("Parsing the Payload's JSON resulted on a Null map"); } String issuer = getString(tree, PublicClaims.ISSUER); String subject = getString(tree, PublicClaims.SUBJECT); List audience = getStringOrArray(tree, PublicClaims.AUDIENCE); Date expiresAt = getDateFromSeconds(tree, PublicClaims.EXPIRES_AT); Date notBefore = getDateFromSeconds(tree, PublicClaims.NOT_BEFORE); Date issuedAt = getDateFromSeconds(tree, PublicClaims.ISSUED_AT); String jwtId = getString(tree, PublicClaims.JWT_ID); return new PayloadImpl(issuer, subject, audience, expiresAt, notBefore, issuedAt, jwtId, tree); } List getStringOrArray(Map tree, String claimName) throws JWTDecodeException { JsonNode node = tree.get(claimName); if (node == null || node.isNull() || !(node.isArray() || node.isTextual())) { return null; } if (node.isTextual() && !node.asText().isEmpty()) { return Collections.singletonList(node.asText()); } ObjectMapper mapper = new ObjectMapper(); List list = new ArrayList<>(node.size()); for (int i = 0; i < node.size(); i++) { try { list.add(mapper.treeToValue(node.get(i), String.class)); } catch (JsonProcessingException e) { throw new JWTDecodeException("Couldn't map the Claim's array contents to String", e); } } return list; } Date getDateFromSeconds(Map tree, String claimName) { JsonNode node = tree.get(claimName); if (node == null || node.isNull() || !node.canConvertToLong()) { return null; } final long ms = node.asLong() * 1000; return new Date(ms); } String getString(Map tree, String claimName) { JsonNode node = tree.get(claimName); if (node == null || node.isNull()) { return null; } return node.asText(null); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/PayloadImpl.java000066400000000000000000000035011302130156000253530ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.Payload; import com.fasterxml.jackson.databind.JsonNode; import java.util.*; import static com.auth0.jwt.impl.JsonNodeClaim.extractClaim; /** * The PayloadImpl class implements the Payload interface. */ class PayloadImpl implements Payload { private final String issuer; private final String subject; private final List audience; private final Date expiresAt; private final Date notBefore; private final Date issuedAt; private final String jwtId; private final Map tree; PayloadImpl(String issuer, String subject, List audience, Date expiresAt, Date notBefore, Date issuedAt, String jwtId, Map tree) { this.issuer = issuer; this.subject = subject; this.audience = audience; this.expiresAt = expiresAt; this.notBefore = notBefore; this.issuedAt = issuedAt; this.jwtId = jwtId; this.tree = Collections.unmodifiableMap(tree == null ? new HashMap() : tree); } Map getTree() { return tree; } @Override public String getIssuer() { return issuer; } @Override public String getSubject() { return subject; } @Override public List getAudience() { return audience; } @Override public Date getExpiresAt() { return expiresAt; } @Override public Date getNotBefore() { return notBefore; } @Override public Date getIssuedAt() { return issuedAt; } @Override public String getId() { return jwtId; } @Override public Claim getClaim(String name) { return extractClaim(name, tree); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/PayloadSerializer.java000066400000000000000000000040751302130156000265720ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.ser.std.StdSerializer; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; public class PayloadSerializer extends StdSerializer { public PayloadSerializer() { this(null); } private PayloadSerializer(Class t) { super(t); } @Override public void serialize(ClaimsHolder holder, JsonGenerator gen, SerializerProvider provider) throws IOException { HashMap safePayload = new HashMap<>(); for (Map.Entry e : holder.getClaims().entrySet()) { switch (e.getKey()) { case PublicClaims.AUDIENCE: if (e.getValue() instanceof String) { safePayload.put(e.getKey(), e.getValue()); break; } String[] audArray = (String[]) e.getValue(); if (audArray.length == 1) { safePayload.put(e.getKey(), audArray[0]); } else if (audArray.length > 1) { safePayload.put(e.getKey(), audArray); } break; case PublicClaims.EXPIRES_AT: case PublicClaims.ISSUED_AT: case PublicClaims.NOT_BEFORE: safePayload.put(e.getKey(), dateToSeconds((Date) e.getValue())); break; default: if (e.getValue() instanceof Date) { safePayload.put(e.getKey(), dateToSeconds((Date) e.getValue())); } else { safePayload.put(e.getKey(), e.getValue()); } break; } } gen.writeObject(safePayload); } private int dateToSeconds(Date date) { return (int) (date.getTime() / 1000); } } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/impl/PublicClaims.java000066400000000000000000000006341302130156000255130ustar00rootroot00000000000000package com.auth0.jwt.impl; public interface PublicClaims { //Header String ALGORITHM = "alg"; String CONTENT_TYPE = "cty"; String TYPE = "typ"; String KEY_ID = "kid"; //Payload String ISSUER = "iss"; String SUBJECT = "sub"; String EXPIRES_AT = "exp"; String NOT_BEFORE = "nbf"; String ISSUED_AT = "iat"; String JWT_ID = "jti"; String AUDIENCE = "aud"; } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/000077500000000000000000000000001302130156000234605ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/Claim.java000066400000000000000000000041221302130156000253470ustar00rootroot00000000000000package com.auth0.jwt.interfaces; import com.auth0.jwt.exceptions.JWTDecodeException; import java.util.Date; import java.util.List; /** * The Claim class holds the value in a generic way so that it can be recovered in many representations. */ public interface Claim { boolean isNull(); /** * Get this Claim as a Boolean. * If the value isn't of type Boolean or it can't be converted to a Boolean, null will be returned. * * @return the value as a Boolean or null. */ Boolean asBoolean(); /** * Get this Claim as an Integer. * If the value isn't of type Integer or it can't be converted to an Integer, null will be returned. * * @return the value as an Integer or null. */ Integer asInt(); /** * Get this Claim as a Double. * If the value isn't of type Double or it can't be converted to a Double, null will be returned. * * @return the value as a Double or null. */ Double asDouble(); /** * Get this Claim as a String. * If the value isn't of type String or it can't be converted to a String, null will be returned. * * @return the value as a String or null. */ String asString(); /** * Get this Claim as a Date. * If the value can't be converted to a Date, null will be returned. * * @return the value as a Date or null. */ Date asDate(); /** * Get this Claim as an Array of type T. * If the value isn't an Array, an empty Array will be returned. * * @return the value as an Array or an empty Array. * @throws JWTDecodeException if the values inside the Array can't be converted to a class T. */ T[] asArray(Class tClazz) throws JWTDecodeException; /** * Get this Claim as a List of type T. * If the value isn't an Array, an empty List will be returned. * * @return the value as a List or an empty List. * @throws JWTDecodeException if the values inside the List can't be converted to a class T. */ List asList(Class tClazz) throws JWTDecodeException; } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/DecodedJWT.java000066400000000000000000000003411302130156000262350ustar00rootroot00000000000000package com.auth0.jwt.interfaces; /** * Class that represents a Json Web Token that was decoded from it's string representation. */ public interface DecodedJWT extends Payload, Header, Signature { String getToken(); } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/Header.java000066400000000000000000000023131302130156000255120ustar00rootroot00000000000000package com.auth0.jwt.interfaces; /** * The Header class represents the 1st part of the JWT, where the Header value is hold. */ public interface Header { /** * Getter for the Algorithm "alg" claim defined in the JWT's Header. If the claim is missing it will return null. * * @return the Algorithm defined or null. */ String getAlgorithm(); /** * Getter for the Type "typ" claim defined in the JWT's Header. If the claim is missing it will return null. * * @return the Type defined or null. */ String getType(); /** * Getter for the Content Type "cty" claim defined in the JWT's Header. If the claim is missing it will return null. * * @return the Content Type defined or null. */ String getContentType(); /** * Get the value of the "kid" claim, or null if it's not available. * * @return the Key ID value or null. */ String getKeyId(); /** * Get a Private Claim given it's name. If the Claim wasn't specified in the Header, a NullClaim will be returned. * * @param name the name of the Claim to retrieve. * @return a non-null Claim. */ Claim getHeaderClaim(String name); } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/JWTPartsParser.java000066400000000000000000000016071302130156000271620ustar00rootroot00000000000000package com.auth0.jwt.interfaces; import com.auth0.jwt.exceptions.JWTDecodeException; /** * The JWTPartsParser class defines which parts of the JWT should be converted to it's specific Object representation instance. */ public interface JWTPartsParser { /** * Parses the given JSON into a Payload instance. * * @param json the content of the Payload in a JSON representation. * @return the Payload. * @throws JWTDecodeException if the json doesn't have a proper JSON format. */ Payload parsePayload(String json) throws JWTDecodeException; /** * Parses the given JSON into a Header instance. * * @param json the content of the Header in a JSON representation. * @return the Header. * @throws JWTDecodeException if the json doesn't have a proper JSON format. */ Header parseHeader(String json) throws JWTDecodeException; } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/Payload.java000066400000000000000000000031321302130156000257130ustar00rootroot00000000000000package com.auth0.jwt.interfaces; import java.util.Date; import java.util.List; /** * The Payload class represents the 2nd part of the JWT, where the Payload value is hold. */ public interface Payload { /** * Get the value of the "iss" claim, or null if it's not available. * * @return the Issuer value or null. */ String getIssuer(); /** * Get the value of the "sub" claim, or null if it's not available. * * @return the Subject value or null. */ String getSubject(); /** * Get the value of the "aud" claim, or null if it's not available. * * @return the Audience value or null. */ List getAudience(); /** * Get the value of the "exp" claim, or null if it's not available. * * @return the Expiration Time value or null. */ Date getExpiresAt(); /** * Get the value of the "nbf" claim, or null if it's not available. * * @return the Not Before value or null. */ Date getNotBefore(); /** * Get the value of the "iat" claim, or null if it's not available. * * @return the Issued At value or null. */ Date getIssuedAt(); /** * Get the value of the "jti" claim, or null if it's not available. * * @return the JWT ID value or null. */ String getId(); /** * Get a Private Claim given it's name. If the Claim wasn't specified in the Payload, a NullClaim will be returned. * * @param name the name of the Claim to retrieve. * @return a non-null Claim. */ Claim getClaim(String name); } javaOIDCMsg-3.0.0/lib/src/main/java/com/auth0/jwt/interfaces/Signature.java000066400000000000000000000005251302130156000262660ustar00rootroot00000000000000package com.auth0.jwt.interfaces; /** * The Signature class represents the 3rd part of the JWT, where the Signature value is hold. */ public interface Signature { /** * Getter for the Signature contained in the JWT as a Base64 encoded String. * * @return the Signature of the JWT. */ String getSignature(); } javaOIDCMsg-3.0.0/lib/src/test/000077500000000000000000000000001302130156000160445ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/000077500000000000000000000000001302130156000167655ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/000077500000000000000000000000001302130156000175435ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/000077500000000000000000000000001302130156000205645ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/000077500000000000000000000000001302130156000213705ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/ClockTest.java000066400000000000000000000007241302130156000241310ustar00rootroot00000000000000package com.auth0.jwt; import org.junit.Test; import java.util.Date; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.notNullValue; import static org.junit.Assert.*; public class ClockTest { @Test public void shouldGetToday() throws Exception{ Clock clock = new Clock(); Date clockToday = clock.getToday(); assertThat(clockToday, is(notNullValue())); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/ConcurrentVerifyTest.java000066400000000000000000000226571302130156000264160ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.interfaces.DecodedJWT; import net.jodah.concurrentunit.Waiter; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.security.interfaces.ECKey; import java.security.interfaces.RSAKey; import java.util.Collections; import java.util.List; import java.util.concurrent.*; import static com.auth0.jwt.PemUtils.readPublicKeyFromFile; //@Ignore("Skipping concurrency tests") public class ConcurrentVerifyTest { private static final long TIMEOUT = 10 * 1000 * 1000; //1 min private static final int THREAD_COUNT = 100; private static final int REPEAT_COUNT = 1000; private static final String PUBLIC_KEY_FILE = "src/test/resources/rsa-public.pem"; private static final String PUBLIC_KEY_FILE_256 = "src/test/resources/ec256-key-public.pem"; private static final String PUBLIC_KEY_FILE_384 = "src/test/resources/ec384-key-public.pem"; private static final String PUBLIC_KEY_FILE_512 = "src/test/resources/ec512-key-public.pem"; @Rule public ExpectedException exception = ExpectedException.none(); private static ExecutorService executor; @BeforeClass public static void beforeAll() throws Exception { executor = Executors.newFixedThreadPool(THREAD_COUNT); } @AfterClass public static void afterAll() throws Exception { executor.shutdown(); } @SuppressWarnings("Convert2Lambda") private void concurrentVerify(final JWTVerifier verifier, final String token) throws TimeoutException, InterruptedException { final Waiter waiter = new Waiter(); List tasks = Collections.nCopies(REPEAT_COUNT, new VerifyTask(waiter, verifier, token)); executor.invokeAll(tasks, TIMEOUT, TimeUnit.MILLISECONDS); waiter.await(TIMEOUT, REPEAT_COUNT); } private static class VerifyTask implements Callable { private final Waiter waiter; private final JWTVerifier verifier; private final String token; VerifyTask(Waiter waiter, final JWTVerifier verifier, final String token) { this.waiter = waiter; this.verifier = verifier; this.token = token; } @Override public DecodedJWT call() throws Exception { DecodedJWT jwt = null; try { jwt = verifier.verify(token); waiter.assertNotNull(jwt); } catch (Exception e) { waiter.fail(e); } waiter.resume(); return jwt; } } @Test public void shouldPassHMAC256Verification() throws Exception { Algorithm algorithm = Algorithm.HMAC256("secret"); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; concurrentVerify(verifier, token); } @Test public void shouldPassHMAC384Verification() throws Exception { String token = "eyJhbGciOiJIUzM4NCIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.uztpK_wUMYJhrRv8SV-1LU4aPnwl-EM1q-wJnqgyb5DHoDteP6lN_gE1xnZJH5vw"; Algorithm algorithm = Algorithm.HMAC384("secret"); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassHMAC512Verification() throws Exception { String token = "eyJhbGciOiJIUzUxMiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.VUo2Z9SWDV-XcOc_Hr6Lff3vl7L9e5Vb8ThXpmGDFjHxe3Dr1ZBmUChYF-xVA7cAdX1P_D4ZCUcsv3IefpVaJw"; Algorithm algorithm = Algorithm.HMAC512("secret"); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassRSA256Verification() throws Exception { String token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; Algorithm algorithm = Algorithm.RSA256((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassRSA384Verification() throws Exception { String token = "eyJhbGciOiJSUzM4NCIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.TZlWjXObwGSQOiu2oMq8kiKz0_BR7bbBddNL6G8eZ_GoR82BXOZDqNrQr7lb_M-78XGBguWLWNIdYhzgxOUL9EoCJlrqVm9s9vo6G8T1sj1op-4TbjXZ61TwIvrJee9BvPLdKUJ9_fp1Js5kl6yXkst40Th8Auc5as4n49MLkipjpEhKDKaENKHpSubs1ripSz8SCQZSofeTM_EWVwSw7cpiM8Fy8jOPvWG8Xz4-e3ODFowvHVsDcONX_4FTMNbeRqDuHq2ZhCJnEfzcSJdrve_5VD5fM1LperBVslTrOxIgClOJ3RmM7-WnaizJrWP3D6Z9OLxPxLhM6-jx6tcxEw"; Algorithm algorithm = Algorithm.RSA384((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassRSA512Verification() throws Exception { String token = "eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mvL5LoMyIrWYjk5umEXZTmbyIrkbbcVPUkvdGZbu0qFBxGOf0nXP5PZBvPcOu084lvpwVox5n3VaD4iqzW-PsJyvKFgi5TnwmsbKchAp7JexQEsQOnTSGcfRqeUUiBZqRQdYsho71oAB3T4FnalDdFEpM-fztcZY9XqKyayqZLreTeBjqJm4jfOWH7KfGBHgZExQhe96NLq1UA9eUyQwdOA1Z0SgXe4Ja5PxZ6Fm37KnVDtDlNnY4JAAGFo6y74aGNnp_BKgpaVJCGFu1f1S5xCQ1HSvs8ZSdVWs5NgawW3wRd0kRt_GJ_Y3mIwiF4qUyHWGtsSHu_qjVdCTtbFyow"; Algorithm algorithm = Algorithm.RSA512((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA256VerificationWithJOSESignature() throws Exception { String token = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC"); Algorithm algorithm = Algorithm.ECDSA256(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA256VerificationWithDERSignature() throws Exception { String token = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.MEYCIQDiJWTf5jS/hFPj/0hpCWn7x1n/h+xPMjKWCs9MMusS9AIhAMcFPJVLe2A9uvb8hl8sRO2IpGoKDRpDmyH14ixNPAHW"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC"); Algorithm algorithm = Algorithm.ECDSA256(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA384VerificationWithJOSESignature() throws Exception { String token = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9.50UU5VKNdF1wfykY8jQBKpvuHZoe6IZBJm5NvoB8bR-hnRg6ti-CHbmvoRtlLfnHfwITa_8cJMy6TenMC2g63GQHytc8rYoXqbwtS4R0Ko_AXbLFUmfxnGnMC6v4MS_z"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC"); Algorithm algorithm = Algorithm.ECDSA384(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA384VerificationWithDERSignature() throws Exception { String token = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9.MGUCMQDnRRTlUo10XXB/KRjyNAEqm+4dmh7ohkEmbk2+gHxtH6GdGDq2L4Idua+hG2Ut+ccCMH8CE2v/HCTMuk3pzAtoOtxkB8rXPK2KF6m8LUuEdCqPwF2yxVJn8ZxpzAur+DEv8w=="; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC"); Algorithm algorithm = Algorithm.ECDSA384(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA512VerificationWithJOSESignature() throws Exception { String token = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.AeCJPDIsSHhwRSGZCY6rspi8zekOw0K9qYMNridP1Fu9uhrA1QrG-EUxXlE06yvmh2R7Rz0aE7kxBwrnq8L8aOBCAYAsqhzPeUvyp8fXjjgs0Eto5I0mndE2QHlgcMSFASyjHbU8wD2Rq7ZNzGQ5b2MZfpv030WGUajT-aZYWFUJHVg2"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC"); Algorithm algorithm = Algorithm.ECDSA512(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } @Test public void shouldPassECDSA512VerificationWithDERSignature() throws Exception { String token = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.MIGIAkIB4Ik8MixIeHBFIZkJjquymLzN6Q7DQr2pgw2uJ0/UW726GsDVCsb4RTFeUTTrK+aHZHtHPRoTuTEHCuerwvxo4EICQgGALKocz3lL8qfH1444LNBLaOSNJp3RNkB5YHDEhQEsox21PMA9kau2TcxkOW9jGX6b9N9FhlGo0/mmWFhVCR1YNg=="; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC"); Algorithm algorithm = Algorithm.ECDSA512(key); JWTVerifier verifier = JWTVerifier.init(algorithm).withIssuer("auth0").build(); concurrentVerify(verifier, token); } } javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/JWTCreatorTest.java000066400000000000000000000170051302130156000250620ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.util.Date; import java.util.HashMap; import java.util.Map; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.notNullValue; import static org.junit.Assert.assertThat; public class JWTCreatorTest { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void shouldThrowWhenRequestingSignWithoutAlgorithm() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Algorithm cannot be null"); JWTCreator.init() .sign(null); } @SuppressWarnings("Convert2Diamond") @Test public void shouldAddHeader() throws Exception { Map header = new HashMap(); header.put("asd", 123); String signed = JWTCreator.init() .withHeader(header) .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[0], is("eyJhbGciOiJIUzI1NiIsImFzZCI6MTIzfQ")); } @Test public void shouldAddIssuer() throws Exception { String signed = JWTCreator.init() .withIssuer("auth0") .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJpc3MiOiJhdXRoMCJ9")); } @Test public void shouldAddSubject() throws Exception { String signed = JWTCreator.init() .withSubject("1234567890") .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJzdWIiOiIxMjM0NTY3ODkwIn0")); } @Test public void shouldAddAudience() throws Exception { String signed = JWTCreator.init() .withAudience("Mark") .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJhdWQiOiJNYXJrIn0")); String signedArr = JWTCreator.init() .withAudience("Mark", "David") .sign(Algorithm.HMAC256("secret")); assertThat(signedArr, is(notNullValue())); assertThat(TokenUtils.splitToken(signedArr)[1], is("eyJhdWQiOlsiTWFyayIsIkRhdmlkIl19")); } @Test public void shouldAddExpiresAt() throws Exception { String signed = JWTCreator.init() .withExpiresAt(new Date(1477592000)) .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJleHAiOjE0Nzc1OTJ9")); } @Test public void shouldAddNotBefore() throws Exception { String signed = JWTCreator.init() .withNotBefore(new Date(1477592000)) .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJuYmYiOjE0Nzc1OTJ9")); } @Test public void shouldAddIssuedAt() throws Exception { String signed = JWTCreator.init() .withIssuedAt(new Date(1477592000)) .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJpYXQiOjE0Nzc1OTJ9")); } @Test public void shouldAddJWTId() throws Exception { String signed = JWTCreator.init() .withJWTId("jwt_id_123") .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("eyJqdGkiOiJqd3RfaWRfMTIzIn0")); } @Test public void shouldRemoveClaimWhenPassingNull() throws Exception { String signed = JWTCreator.init() .withIssuer("iss") .withIssuer(null) .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[1], is("e30")); } @Test public void shouldSetCorrectAlgorithmInTheHeader() throws Exception { String signed = JWTCreator.init() .sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[0], is("eyJhbGciOiJIUzI1NiJ9")); } @Test public void shouldSetEmptySignatureIfAlgorithmIsNone() throws Exception { String signed = JWTCreator.init() .sign(Algorithm.none()); assertThat(signed, is(notNullValue())); assertThat(TokenUtils.splitToken(signed)[2], is("")); } @Test public void shouldThrowOnNullCustomClaimName() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Custom Claim's name can't be null."); JWTCreator.init() .withClaim(null, "value"); } @Test public void shouldThrowOnIllegalCustomClaimValueClass() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Custom Claim's value class must be an instance of Integer, Double, Boolean, Date or String."); JWTCreator.init() .withClaim("name", new Object()); } @Test public void shouldAcceptCustomClaimOfTypeString() throws Exception { String jwt = JWTCreator.init() .withClaim("name", "value") .sign(Algorithm.HMAC256("secret")); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoidmFsdWUifQ.4qDWJcNQHDVDW1iAcIgZNiu-qqJQ0RIq8X3ETijBx5k"; assertThat(jwt, is(notNullValue())); assertThat(jwt, is(token)); } @Test public void shouldAcceptCustomClaimOfTypeInteger() throws Exception { String jwt = JWTCreator.init() .withClaim("name", 123) .sign(Algorithm.HMAC256("secret")); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoxMjN9.5i6ga8YMteicIeZrFZgJyW4OnI_2jpMaUXcDt-_jme4"; assertThat(jwt, is(notNullValue())); assertThat(jwt, is(token)); } @Test public void shouldAcceptCustomClaimOfTypeDouble() throws Exception { String jwt = JWTCreator.init() .withClaim("name", 23.45) .sign(Algorithm.HMAC256("secret")); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoyMy40NX0.aFNlMk3WiikukJq1jo4Tf8ztR180wjTfSpqec0xKKqU"; assertThat(jwt, is(notNullValue())); assertThat(jwt, is(token)); } @Test public void shouldAcceptCustomClaimOfTypeBoolean() throws Exception { String jwt = JWTCreator.init() .withClaim("name", true) .sign(Algorithm.HMAC256("secret")); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjp0cnVlfQ.jseAYuhVmT1boYrHQfn9wXmomWq_tdGfphLtG_2tj_M"; assertThat(jwt, is(notNullValue())); assertThat(jwt, is(token)); } @Test public void shouldAcceptCustomClaimOfTypeDate() throws Exception { Date date = new Date(1478891521000L); String jwt = JWTCreator.init() .withClaim("name", date) .sign(Algorithm.HMAC256("secret")); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoxNDc4ODkxNTIxfQ.ZU1B1pDLYoJZhWD8h3_QsK5dViolxvL5Q43Yz9QIxL4"; assertThat(jwt, is(notNullValue())); assertThat(jwt, is(token)); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/JWTDecoderTest.java000066400000000000000000000216371302130156000250360ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.impl.NullClaim; import com.auth0.jwt.interfaces.Claim; import com.auth0.jwt.interfaces.DecodedJWT; import org.apache.commons.codec.binary.Base64; import org.hamcrest.collection.IsCollectionWithSize; import org.hamcrest.core.IsCollectionContaining; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.nio.charset.StandardCharsets; import java.util.Date; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; public class JWTDecoderTest { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void getSubject() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ"); assertThat(jwt.getSubject(), is(notNullValue())); assertThat(jwt.getSubject(), is("1234567890")); } // Exceptions @Test public void shouldThrowIfLessThan3Parts() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The token was expected to have 3 parts, but got 2."); JWTDecoder.decode("two.parts"); } @Test public void shouldThrowIfMoreThan3Parts() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The token was expected to have 3 parts, but got 4."); JWTDecoder.decode("this.has.four.parts"); } @Test public void shouldThrowIfPayloadHasInvalidJSONFormat() throws Exception { String validJson = "{}"; String invalidJson = "{}}{"; exception.expect(JWTDecodeException.class); exception.expectMessage(String.format("The string '%s' doesn't have a valid JSON format.", invalidJson)); customJWT(validJson, invalidJson, "signature"); } @Test public void shouldThrowIfHeaderHasInvalidJSONFormat() throws Exception { String validJson = "{}"; String invalidJson = "{}}{"; exception.expect(JWTDecodeException.class); exception.expectMessage(String.format("The string '%s' doesn't have a valid JSON format.", invalidJson)); customJWT(invalidJson, validJson, "signature"); } // getToken @Test public void shouldGetStringToken() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getToken(), is(notNullValue())); assertThat(jwt.getToken(), is("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ")); } // Parts @Test public void shouldGetAlgorithm() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAlgorithm(), is("HS256")); } @Test public void shouldGetSignature() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getSignature(), is("XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ")); } // Public PublicClaims @Test public void shouldGetIssuer() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKb2huIERvZSJ9.SgXosfRR_IwCgHq5lF3tlM-JHtpucWCRSaVuoHTbWbQ"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getIssuer(), is("John Doe")); } @Test public void shouldGetSubject() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJUb2szbnMifQ.RudAxkslimoOY3BLl2Ghny3BrUKu9I1ZrXzCZGDJtNs"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getSubject(), is("Tok3ns")); } @Test public void shouldGetArrayAudience() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOlsiSG9wZSIsIlRyYXZpcyIsIlNvbG9tb24iXX0.Tm4W8WnfPjlmHSmKFakdij0on2rWPETpoM7Sh0u6-S4"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAudience(), is(IsCollectionWithSize.hasSize(3))); assertThat(jwt.getAudience(), is(IsCollectionContaining.hasItems("Hope", "Travis", "Solomon"))); } @Test public void shouldGetStringAudience() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJKYWNrIFJleWVzIn0.a4I9BBhPt1OB1GW67g2P1bEHgi6zgOjGUL4LvhE9Dgc"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAudience(), is(IsCollectionWithSize.hasSize(1))); assertThat(jwt.getAudience(), is(IsCollectionContaining.hasItems("Jack Reyes"))); } @Test public void shouldGetExpirationTime() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0NzY3MjcwODZ9.L9dcPHEDQew2u9MkDCORFkfDGcSOsgoPqNY-LUMLEHg"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getExpiresAt(), is(instanceOf(Date.class))); long ms = 1476727086L * 1000; Date expectedDate = new Date(ms); assertThat(jwt.getExpiresAt(), is(notNullValue())); assertThat(jwt.getExpiresAt(), is(equalTo(expectedDate))); } @Test public void shouldGetNotBefore() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJuYmYiOjE0NzY3MjcwODZ9.tkpD3iCPQPVqjnjpDVp2bJMBAgpVCG9ZjlBuMitass0"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getNotBefore(), is(instanceOf(Date.class))); long ms = 1476727086L * 1000; Date expectedDate = new Date(ms); assertThat(jwt.getNotBefore(), is(notNullValue())); assertThat(jwt.getNotBefore(), is(equalTo(expectedDate))); } @Test public void shouldGetIssuedAt() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE0NzY3MjcwODZ9.KPjGoW665E8V5_27Jugab8qSTxLk2cgquhPCBfAP0_w"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getIssuedAt(), is(instanceOf(Date.class))); long ms = 1476727086L * 1000; Date expectedDate = new Date(ms); assertThat(jwt.getIssuedAt(), is(notNullValue())); assertThat(jwt.getIssuedAt(), is(equalTo(expectedDate))); } @Test public void shouldGetId() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxMjM0NTY3ODkwIn0.m3zgEfVUFOd-CvL3xG5BuOWLzb0zMQZCqiVNQQOPOvA"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getId(), is("1234567890")); } @Test public void shouldGetContentType() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiIsImN0eSI6ImF3ZXNvbWUifQ.e30.AIm-pJDOaAyct9qKMlN-lQieqNDqc3d4erqUZc5SHAs"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getContentType(), is("awesome")); } @Test public void shouldGetType() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.e30.WdFmrzx8b9v_a-r6EHC2PTAaWywgm_8LiP8RBRhYwkI"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getType(), is("JWS")); } //Private PublicClaims @Test public void shouldGetMissingClaimIfClaimDoesNotExist() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.e30.K17vlwhE8FCMShdl1_65jEYqsQqBOVMPUU9IgG-QlTM"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getClaim("notExisting"), is(notNullValue())); assertThat(jwt.getClaim("notExisting"), is(instanceOf(NullClaim.class))); } @Test public void shouldGetValidClaim() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJvYmplY3QiOnsibmFtZSI6ImpvaG4ifX0.lrU1gZlOdlmTTeZwq0VI-pZx2iV46UWYd5-lCjy6-c4"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getClaim("object"), is(notNullValue())); assertThat(jwt.getClaim("object"), is(instanceOf(Claim.class))); } @Test public void shouldGetNullClaimIfClaimValueIsNull() throws Exception { DecodedJWT jwt = JWTDecoder.decode("eyJhbGciOiJIUzI1NiJ9.eyJvYmplY3QiOnt9fQ.d3nUeeL_69QsrHL0ZWij612LHEQxD8EZg1rNoY3a4aI"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getClaim("object"), is(notNullValue())); assertThat(jwt.getClaim("object").isNull(), is(true)); } //Helper Methods private DecodedJWT customJWT(String jsonHeader, String jsonPayload, String signature) { String header = Base64.encodeBase64URLSafeString(jsonHeader.getBytes(StandardCharsets.UTF_8)); String body = Base64.encodeBase64URLSafeString(jsonPayload.getBytes(StandardCharsets.UTF_8)); return JWTDecoder.decode(String.format("%s.%s.%s", header, body, signature)); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/JWTTest.java000066400000000000000000000466221302130156000235510ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.interfaces.DecodedJWT; import org.hamcrest.collection.IsCollectionWithSize; import org.hamcrest.core.IsCollectionContaining; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.security.interfaces.ECKey; import java.security.interfaces.RSAKey; import java.util.Date; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; public class JWTTest { private static final String PUBLIC_KEY_FILE_RSA = "src/test/resources/rsa-public.pem"; private static final String PRIVATE_KEY_FILE_RSA = "src/test/resources/rsa-private.pem"; private static final String PUBLIC_KEY_FILE_EC_256 = "src/test/resources/ec256-key-public.pem"; private static final String PUBLIC_KEY_FILE_EC_384 = "src/test/resources/ec384-key-public.pem"; private static final String PUBLIC_KEY_FILE_EC_512 = "src/test/resources/ec512-key-public.pem"; private static final String PRIVATE_KEY_FILE_EC_256 = "src/test/resources/ec256-key-private.pem"; private static final String PRIVATE_KEY_FILE_EC_384 = "src/test/resources/ec384-key-private.pem"; private static final String PRIVATE_KEY_FILE_EC_512 = "src/test/resources/ec512-key-private.pem"; @Rule public ExpectedException exception = ExpectedException.none(); // Decode @Test public void shouldDecodeAStringToken() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; DecodedJWT jwt = JWT.decode(token); assertThat(jwt, is(notNullValue())); } // getToken @Test public void shouldGetStringToken() throws Exception { DecodedJWT jwt = JWT.decode("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"); assertThat(jwt, is(notNullValue())); assertThat(jwt.getToken(), is(notNullValue())); assertThat(jwt.getToken(), is("eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ")); } // Verify @Test public void shouldAcceptNoneAlgorithm() throws Exception { String token = "eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJpc3MiOiJhdXRoMCJ9."; DecodedJWT jwt = JWT.require(Algorithm.none()) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptHMAC256Algorithm() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptHMAC384Algorithm() throws Exception { String token = "eyJhbGciOiJIUzM4NCIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.uztpK_wUMYJhrRv8SV-1LU4aPnwl-EM1q-wJnqgyb5DHoDteP6lN_gE1xnZJH5vw"; DecodedJWT jwt = JWT.require(Algorithm.HMAC384("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptHMAC512Algorithm() throws Exception { String token = "eyJhbGciOiJIUzUxMiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.VUo2Z9SWDV-XcOc_Hr6Lff3vl7L9e5Vb8ThXpmGDFjHxe3Dr1ZBmUChYF-xVA7cAdX1P_D4ZCUcsv3IefpVaJw"; DecodedJWT jwt = JWT.require(Algorithm.HMAC512("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptRSA256Algorithm() throws Exception { String token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; RSAKey key = (RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"); DecodedJWT jwt = JWT.require(Algorithm.RSA256(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptRSA384Algorithm() throws Exception { String token = "eyJhbGciOiJSUzM4NCIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.TZlWjXObwGSQOiu2oMq8kiKz0_BR7bbBddNL6G8eZ_GoR82BXOZDqNrQr7lb_M-78XGBguWLWNIdYhzgxOUL9EoCJlrqVm9s9vo6G8T1sj1op-4TbjXZ61TwIvrJee9BvPLdKUJ9_fp1Js5kl6yXkst40Th8Auc5as4n49MLkipjpEhKDKaENKHpSubs1ripSz8SCQZSofeTM_EWVwSw7cpiM8Fy8jOPvWG8Xz4-e3ODFowvHVsDcONX_4FTMNbeRqDuHq2ZhCJnEfzcSJdrve_5VD5fM1LperBVslTrOxIgClOJ3RmM7-WnaizJrWP3D6Z9OLxPxLhM6-jx6tcxEw"; RSAKey key = (RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"); DecodedJWT jwt = JWT.require(Algorithm.RSA384(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptRSA512Algorithm() throws Exception { String token = "eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mvL5LoMyIrWYjk5umEXZTmbyIrkbbcVPUkvdGZbu0qFBxGOf0nXP5PZBvPcOu084lvpwVox5n3VaD4iqzW-PsJyvKFgi5TnwmsbKchAp7JexQEsQOnTSGcfRqeUUiBZqRQdYsho71oAB3T4FnalDdFEpM-fztcZY9XqKyayqZLreTeBjqJm4jfOWH7KfGBHgZExQhe96NLq1UA9eUyQwdOA1Z0SgXe4Ja5PxZ6Fm37KnVDtDlNnY4JAAGFo6y74aGNnp_BKgpaVJCGFu1f1S5xCQ1HSvs8ZSdVWs5NgawW3wRd0kRt_GJ_Y3mIwiF4qUyHWGtsSHu_qjVdCTtbFyow"; RSAKey key = (RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"); DecodedJWT jwt = JWT.require(Algorithm.RSA512(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptECDSA256Algorithm() throws Exception { String token = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; ECKey key = (ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_256, "EC"); DecodedJWT jwt = JWT.require(Algorithm.ECDSA256(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptECDSA384Algorithm() throws Exception { String token = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9.50UU5VKNdF1wfykY8jQBKpvuHZoe6IZBJm5NvoB8bR-hnRg6ti-CHbmvoRtlLfnHfwITa_8cJMy6TenMC2g63GQHytc8rYoXqbwtS4R0Ko_AXbLFUmfxnGnMC6v4MS_z"; ECKey key = (ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_384, "EC"); DecodedJWT jwt = JWT.require(Algorithm.ECDSA384(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldAcceptECDSA512Algorithm() throws Exception { String token = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.AeCJPDIsSHhwRSGZCY6rspi8zekOw0K9qYMNridP1Fu9uhrA1QrG-EUxXlE06yvmh2R7Rz0aE7kxBwrnq8L8aOBCAYAsqhzPeUvyp8fXjjgs0Eto5I0mndE2QHlgcMSFASyjHbU8wD2Rq7ZNzGQ5b2MZfpv030WGUajT-aZYWFUJHVg2"; ECKey key = (ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_512, "EC"); DecodedJWT jwt = JWT.require(Algorithm.ECDSA512(key)) .build() .verify(token); assertThat(jwt, is(notNullValue())); } // Public Claims @Test public void shouldGetAlgorithm() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAlgorithm(), is("HS256")); } @Test public void shouldGetSignature() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.e30.XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getSignature(), is("XmNK3GpH3Ys_7wsYBfq4C3M6goz71I7dTgUkuIa5lyQ")); } @Test public void shouldGetIssuer() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKb2huIERvZSJ9.SgXosfRR_IwCgHq5lF3tlM-JHtpucWCRSaVuoHTbWbQ"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getIssuer(), is("John Doe")); } @Test public void shouldGetSubject() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJUb2szbnMifQ.RudAxkslimoOY3BLl2Ghny3BrUKu9I1ZrXzCZGDJtNs"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getSubject(), is("Tok3ns")); } @Test public void shouldGetArrayAudience() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOlsiSG9wZSIsIlRyYXZpcyIsIlNvbG9tb24iXX0.Tm4W8WnfPjlmHSmKFakdij0on2rWPETpoM7Sh0u6-S4"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAudience(), is(IsCollectionWithSize.hasSize(3))); assertThat(jwt.getAudience(), is(IsCollectionContaining.hasItems("Hope", "Travis", "Solomon"))); } @Test public void shouldGetStringAudience() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJKYWNrIFJleWVzIn0.a4I9BBhPt1OB1GW67g2P1bEHgi6zgOjGUL4LvhE9Dgc"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getAudience(), is(IsCollectionWithSize.hasSize(1))); assertThat(jwt.getAudience(), is(IsCollectionContaining.hasItems("Jack Reyes"))); } @Test public void shouldGetExpirationTime() throws Exception { Date expectedDate = new Date(1477592 * 1000); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(expectedDate); String token = "eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE0Nzc1OTJ9.x_ZjkPkKYUV5tdvc0l8go6D_z2kez1MQcOxokXrDc3k"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getExpiresAt(), is(instanceOf(Date.class))); assertThat(jwt.getExpiresAt(), is(notNullValue())); assertThat(jwt.getExpiresAt(), is(equalTo(expectedDate))); } @Test public void shouldGetNotBefore() throws Exception { Date expectedDate = new Date(1477592 * 1000); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(expectedDate); String token = "eyJhbGciOiJIUzI1NiJ9.eyJuYmYiOjE0Nzc1OTJ9.mWYSOPoNXstjKbZkKrqgkwPOQWEx3F3gMm6PMcfuJd8"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getNotBefore(), is(instanceOf(Date.class))); assertThat(jwt.getNotBefore(), is(notNullValue())); assertThat(jwt.getNotBefore(), is(equalTo(expectedDate))); } @Test public void shouldGetIssuedAt() throws Exception { Date expectedDate = new Date(1477592 * 1000); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(expectedDate); String token = "eyJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE0Nzc1OTJ9.5o1CKlLFjKKcddZzoarQ37pq7qZqNPav3sdZ_bsZaD4"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getIssuedAt(), is(instanceOf(Date.class))); assertThat(jwt.getIssuedAt(), is(notNullValue())); assertThat(jwt.getIssuedAt(), is(equalTo(expectedDate))); } @Test public void shouldGetId() throws Exception { String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxMjM0NTY3ODkwIn0.m3zgEfVUFOd-CvL3xG5BuOWLzb0zMQZCqiVNQQOPOvA"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getId(), is("1234567890")); } @Test public void shouldGetContentType() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6ImF3ZXNvbWUifQ.e30.AIm-pJDOaAyct9qKMlN-lQieqNDqc3d4erqUZc5SHAs"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getContentType(), is("awesome")); } @Test public void shouldGetType() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.e30.WdFmrzx8b9v_a-r6EHC2PTAaWywgm_8LiP8RBRhYwkI"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getType(), is("JWS")); } @Test public void shouldGetKeyId() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImtpZCI6ImtleSJ9.e30.von1Vt9tq9cn5ZYdX1f4cf2EE7fUvb5BCBlKOTm9YWs"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getKeyId(), is("key")); } @Test public void shouldGetCustomClaims() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImlzQWRtaW4iOnRydWV9.eyJpc0FkbWluIjoibm9wZSJ9.YDKBAgUDbh0PkhioDcLNzdQ8c2Gdf_yS6zdEtJQS3F0"; DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); assertThat(jwt.getHeaderClaim("isAdmin"), notNullValue()); assertThat(jwt.getHeaderClaim("isAdmin").asBoolean(), is(true)); assertThat(jwt.getClaim("isAdmin"), notNullValue()); assertThat(jwt.getClaim("isAdmin").asString(), is("nope")); } // Sign @Test public void shouldCreateAnEmptyHMAC256SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJIUzI1NiJ9.e30."; String signed = JWT.create().sign(Algorithm.HMAC256("secret")); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.HMAC256("secret")) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyHMAC384SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJIUzM4NCJ9.e30."; String signed = JWT.create().sign(Algorithm.HMAC384("secret")); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.HMAC384("secret")) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyHMAC512SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJIUzUxMiJ9.e30."; String signed = JWT.create().sign(Algorithm.HMAC512("secret")); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.HMAC512("secret")) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyRSA256SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJSUzI1NiJ9.e30."; String signed = JWT.create().sign(Algorithm.RSA256((RSAKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_RSA, "RSA"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.RSA256((RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"))) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyRSA384SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJSUzM4NCJ9.e30."; String signed = JWT.create().sign(Algorithm.RSA384((RSAKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_RSA, "RSA"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.RSA384((RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"))) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyRSA512SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJSUzUxMiJ9.e30."; String signed = JWT.create().sign(Algorithm.RSA512((RSAKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_RSA, "RSA"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.RSA512((RSAKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_RSA, "RSA"))) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyECDSA256SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJFUzI1NiJ9.e30."; String signed = JWT.create().sign(Algorithm.ECDSA256((ECKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_EC_256, "EC"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.ECDSA256((ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_256, "EC"))) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyECDSA384SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJFUzM4NCJ9.e30."; String signed = JWT.create().sign(Algorithm.ECDSA384((ECKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_EC_384, "EC"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.ECDSA384((ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_384, "EC"))) .build(); assertThat(verified, is(notNullValue())); } @Test public void shouldCreateAnEmptyECDSA512SignedToken() throws Exception { String headerAndPayload = "eyJhbGciOiJFUzUxMiJ9.e30."; String signed = JWT.create().sign(Algorithm.ECDSA512((ECKey) PemUtils.readPrivateKeyFromFile(PRIVATE_KEY_FILE_EC_512, "EC"))); assertThat(signed, is(notNullValue())); assertThat(signed, startsWith(headerAndPayload)); JWTVerifier verified = JWT.require(Algorithm.ECDSA512((ECKey) PemUtils.readPublicKeyFromFile(PUBLIC_KEY_FILE_EC_512, "EC"))) .build(); assertThat(verified, is(notNullValue())); } } javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/JWTVerifierTest.java000066400000000000000000000536331302130156000252450ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.exceptions.AlgorithmMismatchException; import com.auth0.jwt.exceptions.InvalidClaimException; import com.auth0.jwt.interfaces.DecodedJWT; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.util.Date; import java.util.HashMap; import java.util.Map; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; public class JWTVerifierTest { private static final long DATE_TOKEN_MS_VALUE = 1477592 * 1000; @Rule public ExpectedException exception = ExpectedException.none(); @Test public void shouldThrowWhenInitializedWithoutAlgorithm() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Algorithm cannot be null"); JWTVerifier.init(null); } @Test public void shouldThrowWhenAlgorithmDoesntMatchTheTokensAlgorithm() throws Exception { exception.expect(AlgorithmMismatchException.class); exception.expectMessage("The provided Algorithm doesn't match the one defined in the JWT's Header."); JWTVerifier verifier = JWTVerifier.init(Algorithm.HMAC512("secret")).build(); verifier.verify("eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.s69x7Mmu4JqwmdxiK6sesALO7tcedbFsKEEITUxw9ho"); } @Test public void shouldValidateIssuer() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withIssuer("auth0") .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidIssuer() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'iss' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withIssuer("invalid") .build() .verify(token); } @Test public void shouldValidateSubject() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.Rq8IxqeX7eA6GgYxlcHdPFVRNFFZc5rEI3MQTZZbK3I"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withSubject("1234567890") .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidSubject() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'sub' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.Rq8IxqeX7eA6GgYxlcHdPFVRNFFZc5rEI3MQTZZbK3I"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withSubject("invalid") .build() .verify(token); } @Test public void shouldValidateAudience() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJNYXJrIn0.xWB6czYI0XObbVhLAxe55TwChWZg7zO08RxONWU2iY4"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withAudience("Mark") .build() .verify(token); assertThat(jwt, is(notNullValue())); String tokenArr = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiTWFyayIsIkRhdmlkIl19.6WfbIt8m61f9WlCYIQn5CThvw4UNyC66qrPaoinfssw"; DecodedJWT jwtArr = JWTVerifier.init(Algorithm.HMAC256("secret")) .withAudience("Mark", "David") .build() .verify(tokenArr); assertThat(jwtArr, is(notNullValue())); } @Test public void shouldAcceptPartialAudience() throws Exception { //Token 'aud' = ["Mark", "David", "John"] String tokenArr = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiTWFyayIsIkRhdmlkIiwiSm9obiJdfQ.DX5xXiCaYvr54x_iL0LZsJhK7O6HhAdHeDYkgDeb0Rw"; DecodedJWT jwtArr = JWTVerifier.init(Algorithm.HMAC256("secret")) .withAudience("John") .build() .verify(tokenArr); assertThat(jwtArr, is(notNullValue())); } @Test public void shouldThrowOnInvalidAudience() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'aud' value doesn't contain the required audience."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.Rq8IxqeX7eA6GgYxlcHdPFVRNFFZc5rEI3MQTZZbK3I"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withAudience("nope") .build() .verify(token); } @Test public void shouldThrowOnNullCustomClaimName() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Custom Claim's name can't be null."); JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim(null, "value"); } @Test public void shouldThrowOnIllegalCustomClaimValueClass() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Custom Claim's value class must be an instance of Integer, Double, Boolean, Date or String."); JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", new Object()); } @Test public void shouldThrowOnInvalidCustomClaimValueOfTypeString() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", "value") .build() .verify(token); } @Test public void shouldThrowOnInvalidCustomClaimValueOfTypeInteger() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", 123) .build() .verify(token); } @Test public void shouldThrowOnInvalidCustomClaimValueOfTypeDouble() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", 23.45) .build() .verify(token); } @Test public void shouldThrowOnInvalidCustomClaimValueOfTypeBoolean() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", true) .build() .verify(token); } @Test public void shouldThrowOnInvalidCustomClaimValueOfTypeDate() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", new Date()) .build() .verify(token); } @Test public void shouldThrowOnInvalidCustomClaimValue() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'name' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjpbInNvbWV0aGluZyJdfQ.3ENLez6tU_fG0SVFrGmISltZPiXLSHaz_dyn-XFTEGQ"; Map map = new HashMap<>(); map.put("name", new Object()); JWTVerifier verifier = new JWTVerifier(Algorithm.HMAC256("secret"), map, new Clock()); verifier.verify(token); } @Test public void shouldValidateCustomClaimOfTypeString() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoidmFsdWUifQ.Jki8pvw6KGbxpMinufrgo6RDL1cu7AtNMJYVh6t-_cE"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", "value") .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldValidateCustomClaimOfTypeInteger() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoxMjN9.XZAudnA7h3_Al5kJydzLjw6RzZC3Q6OvnLEYlhNW7HA"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", 123) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldValidateCustomClaimOfTypeDouble() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoyMy40NX0.7pyX2OmEGaU9q15T8bGFqRm-d3RVTYnqmZNZtxMKSlA"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", 23.45) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldValidateCustomClaimOfTypeBoolean() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjp0cnVlfQ.FwQ8VfsZNRqBa9PXMinSIQplfLU4-rkCLfIlTLg_MV0"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", true) .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldValidateCustomClaimOfTypeDate() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoxNDc4ODkxNTIxfQ.mhioumeok8fghQEhTKF3QtQAksSvZ_9wIhJmgZLhJ6c"; Date date = new Date(1478891521000L); DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withClaim("name", date) .build() .verify(token); assertThat(jwt, is(notNullValue())); } // Generic Delta @SuppressWarnings("RedundantCast") @Test public void shouldAddDefaultLeewayToDateClaims() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, hasEntry("iat", (Object) 0L)); assertThat(verifier.claims, hasEntry("exp", (Object) 0L)); assertThat(verifier.claims, hasEntry("nbf", (Object) 0L)); } @SuppressWarnings("RedundantCast") @Test public void shouldAddCustomLeewayToDateClaims() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .acceptLeeway(1234L) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, hasEntry("iat", (Object) 1234L)); assertThat(verifier.claims, hasEntry("exp", (Object) 1234L)); assertThat(verifier.claims, hasEntry("nbf", (Object) 1234L)); } @SuppressWarnings("RedundantCast") @Test public void shouldOverrideDefaultIssuedAtLeeway() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .acceptLeeway(1234L) .acceptIssuedAt(9999L) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, hasEntry("iat", (Object) 9999L)); assertThat(verifier.claims, hasEntry("exp", (Object) 1234L)); assertThat(verifier.claims, hasEntry("nbf", (Object) 1234L)); } @SuppressWarnings("RedundantCast") @Test public void shouldOverrideDefaultExpiresAtLeeway() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .acceptLeeway(1234L) .acceptExpiresAt(9999L) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, hasEntry("iat", (Object) 1234L)); assertThat(verifier.claims, hasEntry("exp", (Object) 9999L)); assertThat(verifier.claims, hasEntry("nbf", (Object) 1234L)); } @SuppressWarnings("RedundantCast") @Test public void shouldOverrideDefaultNotBeforeLeeway() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .acceptLeeway(1234L) .acceptNotBefore(9999L) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, hasEntry("iat", (Object) 1234L)); assertThat(verifier.claims, hasEntry("exp", (Object) 1234L)); assertThat(verifier.claims, hasEntry("nbf", (Object) 9999L)); } @Test public void shouldThrowOnNegativeCustomLeeway() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("Leeway value can't be negative."); Algorithm algorithm = mock(Algorithm.class); JWTVerifier.init(algorithm) .acceptLeeway(-1); } // Expires At @Test public void shouldValidateExpiresAtWithLeeway() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE + 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE0Nzc1OTJ9.isvT0Pqx0yjnZk53mUFSeYFJLDs-Ls9IsNAm86gIdZo"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .acceptExpiresAt(2) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldValidateExpiresAtIfPresent() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE0Nzc1OTJ9.isvT0Pqx0yjnZk53mUFSeYFJLDs-Ls9IsNAm86gIdZo"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidExpiresAtIfPresent() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage(startsWith("The Token has expired on")); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE + 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE0Nzc1OTJ9.isvT0Pqx0yjnZk53mUFSeYFJLDs-Ls9IsNAm86gIdZo"; JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); } @Test public void shouldThrowOnNegativeExpiresAtLeeway() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("Leeway value can't be negative."); Algorithm algorithm = mock(Algorithm.class); JWTVerifier.init(algorithm) .acceptExpiresAt(-1); } // Not before @Test public void shouldValidateNotBeforeWithLeeway() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE - 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOjE0Nzc1OTJ9.wq4ZmnSF2VOxcQBxPLfeh1J2Ozy1Tj5iUaERm3FKaw8"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .acceptNotBefore(2) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidNotBeforeIfPresent() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage(startsWith("The Token can't be used before")); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE - 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYmYiOjE0Nzc1OTJ9.wq4ZmnSF2VOxcQBxPLfeh1J2Ozy1Tj5iUaERm3FKaw8"; JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); } @Test public void shouldValidateNotBeforeIfPresent() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE0Nzc1OTJ9.isvT0Pqx0yjnZk53mUFSeYFJLDs-Ls9IsNAm86gIdZo"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnNegativeNotBeforeLeeway() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("Leeway value can't be negative."); Algorithm algorithm = mock(Algorithm.class); JWTVerifier.init(algorithm) .acceptNotBefore(-1); } // Issued At @Test public void shouldValidateIssuedAtWithLeeway() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE - 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE0Nzc1OTJ9.0WJky9eLN7kuxLyZlmbcXRL3Wy8hLoNCEk5CCl2M4lo"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .acceptIssuedAt(2) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidIssuedAtIfPresent() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage(startsWith("The Token can't be used before")); Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE - 1000)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE0Nzc1OTJ9.0WJky9eLN7kuxLyZlmbcXRL3Wy8hLoNCEk5CCl2M4lo"; JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); } @Test public void shouldValidateIssuedAtIfPresent() throws Exception { Clock clock = mock(Clock.class); when(clock.getToday()).thenReturn(new Date(DATE_TOKEN_MS_VALUE)); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXQiOjE0Nzc1OTJ9.0WJky9eLN7kuxLyZlmbcXRL3Wy8hLoNCEk5CCl2M4lo"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .build(clock) .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnNegativeIssuedAtLeeway() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("Leeway value can't be negative."); Algorithm algorithm = mock(Algorithm.class); JWTVerifier.init(algorithm) .acceptIssuedAt(-1); } @Test public void shouldValidateJWTId() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJqd3RfaWRfMTIzIn0.0kegfXUvwOYioP8PDaLMY1IlV8HOAzSVz3EGL7-jWF4"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .withJWTId("jwt_id_123") .build() .verify(token); assertThat(jwt, is(notNullValue())); } @Test public void shouldThrowOnInvalidJWTId() throws Exception { exception.expect(InvalidClaimException.class); exception.expectMessage("The Claim 'jti' value doesn't match the required one."); String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJqd3RfaWRfMTIzIn0.0kegfXUvwOYioP8PDaLMY1IlV8HOAzSVz3EGL7-jWF4"; JWTVerifier.init(Algorithm.HMAC256("secret")) .withJWTId("invalid") .build() .verify(token); } @Test public void shouldRemoveClaimWhenPassingNull() throws Exception { Algorithm algorithm = mock(Algorithm.class); JWTVerifier verifier = JWTVerifier.init(algorithm) .withIssuer("iss") .withIssuer(null) .build(); assertThat(verifier.claims, is(notNullValue())); assertThat(verifier.claims, not(hasKey("iss"))); } @Test public void shouldSkipClaimValidationsIfNoClaimsRequired() throws Exception { String token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.e30.t-IDcSemACt8x4iTMCda8Yhe3iZaWbvV5XKSTbuAn0M"; DecodedJWT jwt = JWTVerifier.init(Algorithm.HMAC256("secret")) .build() .verify(token); assertThat(jwt, is(notNullValue())); } } javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/PemUtils.java000066400000000000000000000052421302130156000240000ustar00rootroot00000000000000package com.auth0.jwt; import org.bouncycastle.util.io.pem.PemObject; import org.bouncycastle.util.io.pem.PemReader; import java.io.*; import java.security.KeyFactory; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.interfaces.ECPublicKey; import java.security.spec.EncodedKeySpec; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; public class PemUtils { private static byte[] parsePEMFile(File pemFile) throws IOException { if (!pemFile.isFile() || !pemFile.exists()) { throw new FileNotFoundException(String.format("The file '%s' doesn't exist.", pemFile.getAbsolutePath())); } PemReader reader = new PemReader(new FileReader(pemFile)); PemObject pemObject = reader.readPemObject(); return pemObject.getContent(); } private static PublicKey getPublicKey(byte[] keyBytes, String algorithm) { PublicKey publicKey = null; try { KeyFactory kf = KeyFactory.getInstance(algorithm); EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes); publicKey = kf.generatePublic(keySpec); } catch (NoSuchAlgorithmException e) { System.out.println("Could not reconstruct the public key, the given algorithm could not be found."); } catch (InvalidKeySpecException e) { System.out.println("Could not reconstruct the public key"); } return publicKey; } private static PrivateKey getPrivateKey(byte[] keyBytes, String algorithm) { PrivateKey privateKey = null; try { KeyFactory kf = KeyFactory.getInstance(algorithm); EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes); privateKey = kf.generatePrivate(keySpec); } catch (NoSuchAlgorithmException e) { System.out.println("Could not reconstruct the private key, the given algorithm could not be found."); } catch (InvalidKeySpecException e) { System.out.println("Could not reconstruct the private key"); } return privateKey; } public static PublicKey readPublicKeyFromFile(String filepath, String algorithm) throws IOException { byte[] bytes = PemUtils.parsePEMFile(new File(filepath)); return PemUtils.getPublicKey(bytes, algorithm); } public static PrivateKey readPrivateKeyFromFile(String filepath, String algorithm) throws IOException { byte[] bytes = PemUtils.parsePEMFile(new File(filepath)); return PemUtils.getPrivateKey(bytes, algorithm); } } javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/TokenUtilsTest.java000066400000000000000000000040061302130156000251740ustar00rootroot00000000000000package com.auth0.jwt; import com.auth0.jwt.exceptions.JWTDecodeException; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; public class TokenUtilsTest { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void shouldSplitToken() throws Exception { String token = "eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJpc3MiOiJhdXRoMCJ9.W1mx_Y0hbAMbPmfW9whT605AAcxB7REFuJiDAHk2Sdc"; String[] parts = TokenUtils.splitToken(token); assertThat(parts, is(notNullValue())); assertThat(parts, is(arrayWithSize(3))); assertThat(parts[0], is("eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0")); assertThat(parts[1], is("eyJpc3MiOiJhdXRoMCJ9")); assertThat(parts[2], is("W1mx_Y0hbAMbPmfW9whT605AAcxB7REFuJiDAHk2Sdc")); } @Test public void shouldSplitTokenWithEmptySignature() throws Exception { String token = "eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJpc3MiOiJhdXRoMCJ9."; String[] parts = TokenUtils.splitToken(token); assertThat(parts, is(notNullValue())); assertThat(parts, is(arrayWithSize(3))); assertThat(parts[0], is("eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0")); assertThat(parts[1], is("eyJpc3MiOiJhdXRoMCJ9")); assertThat(parts[2], is(isEmptyString())); } @Test public void shouldThrowOnSplitTokenWithMoreThan3Parts() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The token was expected to have 3 parts, but got 4."); String token = "this.has.four.parts"; TokenUtils.splitToken(token); } @Test public void shouldThrowOnSplitTokenWithLessThan3Parts() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The token was expected to have 3 parts, but got 2."); String token = "two.parts"; TokenUtils.splitToken(token); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/UserPojo.java000066400000000000000000000015151302130156000240030ustar00rootroot00000000000000package com.auth0.jwt; public class UserPojo { private String name; private int id; @SuppressWarnings("unused") public UserPojo() { //Required Empty Constructor } public UserPojo(String name, int id) { this.name = name; this.id = id; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; UserPojo userPojo = (UserPojo) o; return id == userPojo.id && (name != null ? name.equals(userPojo.name) : userPojo.name == null); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/000077500000000000000000000000001302130156000235415ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/AlgorithmTest.java000066400000000000000000000235761302130156000272070ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.nio.charset.StandardCharsets; import java.security.interfaces.ECKey; import java.security.interfaces.RSAKey; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.mockito.Mockito.mock; public class AlgorithmTest { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void shouldThrowHMAC256VerificationWithNullSecretBytes() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); byte[] secret = null; Algorithm.HMAC256(secret); } @Test public void shouldThrowHMAC384VerificationWithNullSecretBytes() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); byte[] secret = null; Algorithm.HMAC384(secret); } @Test public void shouldThrowHMAC512VerificationWithNullSecretBytes() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); byte[] secret = null; Algorithm.HMAC512(secret); } @Test public void shouldThrowHMAC256VerificationWithNullSecret() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); String secret = null; Algorithm.HMAC256(secret); } @Test public void shouldThrowHMAC384VerificationWithNullSecret() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); String secret = null; Algorithm.HMAC384(secret); } @Test public void shouldThrowHMAC512VerificationWithNullSecret() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The Secret cannot be null"); String secret = null; Algorithm.HMAC512(secret); } @Test public void shouldThrowRSA256VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The RSAKey cannot be null"); Algorithm.RSA256(null); } @Test public void shouldThrowRSA384VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The RSAKey cannot be null"); Algorithm.RSA384(null); } @Test public void shouldThrowRSA512VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The RSAKey cannot be null"); Algorithm.RSA512(null); } @Test public void shouldThrowECDSA256VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The ECKey cannot be null"); Algorithm.ECDSA256(null); } @Test public void shouldThrowECDSA384VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The ECKey cannot be null"); Algorithm.ECDSA384(null); } @Test public void shouldThrowECDSA512VerificationWithNullPublicKey() throws Exception { exception.expect(IllegalArgumentException.class); exception.expectMessage("The ECKey cannot be null"); Algorithm.ECDSA512(null); } @Test public void shouldCreateHMAC256AlgorithmWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC256("secret".getBytes(StandardCharsets.UTF_8)); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA256")); assertThat(algorithm.getName(), is("HS256")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateHMAC384AlgorithmWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC384("secret".getBytes(StandardCharsets.UTF_8)); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA384")); assertThat(algorithm.getName(), is("HS384")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateHMAC512AlgorithmWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC512("secret".getBytes(StandardCharsets.UTF_8)); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA512")); assertThat(algorithm.getName(), is("HS512")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateHMAC256AlgorithmWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC256("secret"); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA256")); assertThat(algorithm.getName(), is("HS256")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateHMAC384AlgorithmWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC384("secret"); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA384")); assertThat(algorithm.getName(), is("HS384")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateHMAC512AlgorithmWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC512("secret"); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(HMACAlgorithm.class))); assertThat(algorithm.getDescription(), is("HmacSHA512")); assertThat(algorithm.getName(), is("HS512")); assertThat(((HMACAlgorithm) algorithm).getSecret(), is("secret".getBytes(StandardCharsets.UTF_8))); } @Test public void shouldCreateRSA256Algorithm() throws Exception { RSAKey key = mock(RSAKey.class); Algorithm algorithm = Algorithm.RSA256(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(RSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA256withRSA")); assertThat(algorithm.getName(), is("RS256")); assertThat(((RSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateRSA384Algorithm() throws Exception { RSAKey key = mock(RSAKey.class); Algorithm algorithm = Algorithm.RSA384(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(RSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA384withRSA")); assertThat(algorithm.getName(), is("RS384")); assertThat(((RSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateRSA512Algorithm() throws Exception { RSAKey key = mock(RSAKey.class); Algorithm algorithm = Algorithm.RSA512(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(RSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA512withRSA")); assertThat(algorithm.getName(), is("RS512")); assertThat(((RSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateECDSA256Algorithm() throws Exception { ECKey key = mock(ECKey.class); Algorithm algorithm = Algorithm.ECDSA256(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(ECDSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA256withECDSA")); assertThat(algorithm.getName(), is("ES256")); assertThat(((ECDSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateECDSA384Algorithm() throws Exception { ECKey key = mock(ECKey.class); Algorithm algorithm = Algorithm.ECDSA384(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(ECDSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA384withECDSA")); assertThat(algorithm.getName(), is("ES384")); assertThat(((ECDSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateECDSA512Algorithm() throws Exception { ECKey key = mock(ECKey.class); Algorithm algorithm = Algorithm.ECDSA512(key); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(ECDSAAlgorithm.class))); assertThat(algorithm.getDescription(), is("SHA512withECDSA")); assertThat(algorithm.getName(), is("ES512")); assertThat(((ECDSAAlgorithm) algorithm).getKey(), is(key)); } @Test public void shouldCreateNoneAlgorithm() throws Exception { Algorithm algorithm = Algorithm.none(); assertThat(algorithm, is(notNullValue())); assertThat(algorithm, is(instanceOf(NoneAlgorithm.class))); assertThat(algorithm.getDescription(), is("none")); assertThat(algorithm.getName(), is("none")); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/AlgorithmUtils.java000066400000000000000000000010571302130156000273560ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import org.apache.commons.codec.binary.Base64; import java.nio.charset.StandardCharsets; public class AlgorithmUtils { public static void verify(Algorithm algorithm, String jwt) { String[] parts = jwt.split("\\."); byte[] content = String.format("%s.%s", parts[0], parts[1]).getBytes(StandardCharsets.UTF_8); byte[] signature = new byte[0]; if (parts.length == 3) { signature = Base64.decodeBase64(parts[2]); } algorithm.verify(content, signature); } } javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/ECDSAAlgorithmTest.java000066400000000000000000000654051302130156000277440ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import org.apache.commons.codec.binary.Base64; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.ECKey; import java.security.interfaces.ECPrivateKey; import java.security.interfaces.ECPublicKey; import static com.auth0.jwt.PemUtils.readPrivateKeyFromFile; import static com.auth0.jwt.PemUtils.readPublicKeyFromFile; import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.isA; import static org.junit.Assert.assertThat; import static org.junit.internal.matchers.ThrowableMessageMatcher.hasMessage; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.*; public class ECDSAAlgorithmTest { private static final String PRIVATE_KEY_FILE_256 = "src/test/resources/ec256-key-private.pem"; private static final String PUBLIC_KEY_FILE_256 = "src/test/resources/ec256-key-public.pem"; private static final String INVALID_PUBLIC_KEY_FILE_256 = "src/test/resources/ec256-key-public-invalid.pem"; private static final String PRIVATE_KEY_FILE_384 = "src/test/resources/ec384-key-private.pem"; private static final String PUBLIC_KEY_FILE_384 = "src/test/resources/ec384-key-public.pem"; private static final String INVALID_PUBLIC_KEY_FILE_384 = "src/test/resources/ec384-key-public-invalid.pem"; private static final String PRIVATE_KEY_FILE_512 = "src/test/resources/ec512-key-private.pem"; private static final String PUBLIC_KEY_FILE_512 = "src/test/resources/ec512-key-public.pem"; private static final String INVALID_PUBLIC_KEY_FILE_512 = "src/test/resources/ec512-key-public-invalid.pem"; @Rule public ExpectedException exception = ExpectedException.none(); //JOSE Signatures obtained using Node 'jwa' lib: https://github.com/brianloveswords/node-jwa //DER Signatures obtained from source JOSE signature using 'ecdsa-sig-formatter' lib: https://github.com/Brightspace/node-ecdsa-sig-formatter // Verify @Test public void shouldPassECDSA256VerificationWithJOSESignature() throws Exception { String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC"); Algorithm algorithm = Algorithm.ECDSA256(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassECDSA256VerificationWithDERSignature() throws Exception { String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.MEYCIQDiJWTf5jS/hFPj/0hpCWn7x1n/h+xPMjKWCs9MMusS9AIhAMcFPJVLe2A9uvb8hl8sRO2IpGoKDRpDmyH14ixNPAHW"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC"); Algorithm algorithm = Algorithm.ECDSA256(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA256VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.W9qfN1b80B9hnMo49WL8THrOsf1vEjOhapeFemPMGySzxTcgfyudS5esgeBTO908X5SLdAr5jMwPUPBs9b6nNg"; Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA256VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not an ECPublicKey."))); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.W9qfN1b80B9hnMo49WL8THrOsf1vEjOhapeFemPMGySzxTcgfyudS5esgeBTO908X5SLdAr5jMwPUPBs9b6nNg"; Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA256VerificationOnInvalidSignatureLength() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); exception.expectCause(isA(SignatureException.class)); exception.expectCause(hasMessage(is("The signature length was invalid. Expected 64 bytes but received 63"))); byte[] bytes = new byte[63]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA256VerificationOnInvalidJOSESignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); byte[] bytes = new byte[64]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA256VerificationOnInvalidDERSignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); byte[] bytes = new byte[64]; bytes[0] = 0x30; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassECDSA384VerificationWithJOSESignature() throws Exception { String jwt = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9.50UU5VKNdF1wfykY8jQBKpvuHZoe6IZBJm5NvoB8bR-hnRg6ti-CHbmvoRtlLfnHfwITa_8cJMy6TenMC2g63GQHytc8rYoXqbwtS4R0Ko_AXbLFUmfxnGnMC6v4MS_z"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC"); Algorithm algorithm = Algorithm.ECDSA384(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassECDSA384VerificationWithDERSignature() throws Exception { String jwt = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9.MGUCMQDnRRTlUo10XXB/KRjyNAEqm+4dmh7ohkEmbk2+gHxtH6GdGDq2L4Idua+hG2Ut+ccCMH8CE2v/HCTMuk3pzAtoOtxkB8rXPK2KF6m8LUuEdCqPwF2yxVJn8ZxpzAur+DEv8w=="; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC"); Algorithm algorithm = Algorithm.ECDSA384(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA384VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withECDSA"); String jwt = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9._k5h1KyO-NE0R2_HAw0-XEc0bGT5atv29SxHhOGC9JDqUHeUdptfCK_ljQ01nLVt2OQWT2SwGs-TuyHDFmhPmPGFZ9wboxvq_ieopmYqhQilNAu-WF-frioiRz9733fU"; Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_384, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA384VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not an ECPublicKey."))); String jwt = "eyJhbGciOiJFUzM4NCJ9.eyJpc3MiOiJhdXRoMCJ9._k5h1KyO-NE0R2_HAw0-XEc0bGT5atv29SxHhOGC9JDqUHeUdptfCK_ljQ01nLVt2OQWT2SwGs-TuyHDFmhPmPGFZ9wboxvq_ieopmYqhQilNAu-WF-frioiRz9733fU"; Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_384, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA384VerificationOnInvalidSignatureLength() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withECDSA"); exception.expectCause(isA(SignatureException.class)); exception.expectCause(hasMessage(is("The signature length was invalid. Expected 96 bytes but received 95"))); byte[] bytes = new byte[95]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_384, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA384VerificationOnInvalidJOSESignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withECDSA"); byte[] bytes = new byte[96]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_384, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA384VerificationOnInvalidDERSignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withECDSA"); byte[] bytes = new byte[96]; new SecureRandom().nextBytes(bytes); bytes[0] = 0x30; String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_384, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassECDSA512VerificationWithJOSESignature() throws Exception { String jwt = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.AeCJPDIsSHhwRSGZCY6rspi8zekOw0K9qYMNridP1Fu9uhrA1QrG-EUxXlE06yvmh2R7Rz0aE7kxBwrnq8L8aOBCAYAsqhzPeUvyp8fXjjgs0Eto5I0mndE2QHlgcMSFASyjHbU8wD2Rq7ZNzGQ5b2MZfpv030WGUajT-aZYWFUJHVg2"; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC"); Algorithm algorithm = Algorithm.ECDSA512(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassECDSA512VerificationWithDERSignature() throws Exception { String jwt = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.MIGIAkIB4Ik8MixIeHBFIZkJjquymLzN6Q7DQr2pgw2uJ0/UW726GsDVCsb4RTFeUTTrK+aHZHtHPRoTuTEHCuerwvxo4EICQgGALKocz3lL8qfH1444LNBLaOSNJp3RNkB5YHDEhQEsox21PMA9kau2TcxkOW9jGX6b9N9FhlGo0/mmWFhVCR1YNg=="; ECKey key = (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC"); Algorithm algorithm = Algorithm.ECDSA512(key); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA512VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withECDSA"); String jwt = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.AZgdopFFsN0amCSs2kOucXdpylD31DEm5ChK1PG0_gq5Mf47MrvVph8zHSVuvcrXzcE1U3VxeCg89mYW1H33Y-8iAF0QFkdfTUQIWKNObH543WNMYYssv3OtOj0znPv8atDbaF8DMYAtcT1qdmaSJRhx-egRE9HGZkinPh9CfLLLt58X"; Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_512, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA512VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not an ECPublicKey."))); String jwt = "eyJhbGciOiJFUzUxMiJ9.eyJpc3MiOiJhdXRoMCJ9.AZgdopFFsN0amCSs2kOucXdpylD31DEm5ChK1PG0_gq5Mf47MrvVph8zHSVuvcrXzcE1U3VxeCg89mYW1H33Y-8iAF0QFkdfTUQIWKNObH543WNMYYssv3OtOj0znPv8atDbaF8DMYAtcT1qdmaSJRhx-egRE9HGZkinPh9CfLLLt58X"; Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_512, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA512VerificationOnInvalidSignatureLength() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withECDSA"); exception.expectCause(isA(SignatureException.class)); exception.expectCause(hasMessage(is("The signature length was invalid. Expected 132 bytes but received 131"))); byte[] bytes = new byte[131]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_512, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA512VerificationOnInvalidJOSESignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withECDSA"); byte[] bytes = new byte[132]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_512, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailECDSA512VerificationOnInvalidDERSignature() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withECDSA"); byte[] bytes = new byte[132]; new SecureRandom().nextBytes(bytes); bytes[0] = 0x30; String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE_512, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailJOSEToDERConversionOnInvalidJOSESignatureLength() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withECDSA"); exception.expectCause(isA(SignatureException.class)); exception.expectCause(hasMessage(is("Invalid ECDSA signature format"))); byte[] bytes = new byte[256]; new SecureRandom().nextBytes(bytes); String signature = Base64.encodeBase64URLSafeString(bytes); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9." + signature; Algorithm algorithm = new ECDSAAlgorithm("ES256", "SHA256withECDSA", 128, (ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowOnVerifyWhenSignatureAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPublicKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowOnVerifyWhenThePublicKeyIsInvalid() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(InvalidKeyException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPublicKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowOnVerifyWhenTheSignatureIsNotPrepared() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(SignatureException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(SignatureException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPublicKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); String jwt = "eyJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJhdXRoMCJ9.4iVk3-Y0v4RT4_9IaQlp-8dZ_4fsTzIylgrPTDLrEvTHBTyVS3tgPbr2_IZfLETtiKRqCg0aQ5sh9eIsTTwB1g"; AlgorithmUtils.verify(algorithm, jwt); } //Sign private static final String ES256Header = "eyJhbGciOiJFUzI1NiJ9"; private static final String ES384Header = "eyJhbGciOiJFUzM4NCJ9"; private static final String ES512Header = "eyJhbGciOiJFUzUxMiJ9"; private static final String auth0IssPayload = "eyJpc3MiOiJhdXRoMCJ9"; @Test public void shouldDoECDSA256Signing() throws Exception { Algorithm algorithmSign = Algorithm.ECDSA256((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_256, "EC")); Algorithm algorithmVerify = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC")); byte[] contentBytes = String.format("%s.%s", ES256Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); assertThat(signatureBytes, is(notNullValue())); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnECDSA256SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA256withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not a ECPrivateKey."))); Algorithm algorithm = Algorithm.ECDSA256((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_256, "EC")); algorithm.sign(new byte[0]); } @Test public void shouldDoECDSA384Signing() throws Exception { Algorithm algorithmSign = Algorithm.ECDSA384((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_384, "EC")); Algorithm algorithmVerify = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC")); byte[] contentBytes = String.format("%s.%s", ES384Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); assertThat(signatureBytes, is(notNullValue())); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnECDSA384SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA384withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not a ECPrivateKey."))); Algorithm algorithm = Algorithm.ECDSA384((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_384, "EC")); algorithm.sign(new byte[0]); } @Test public void shouldDoECDSA512Signing() throws Exception { Algorithm algorithmSign = Algorithm.ECDSA512((ECKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE_512, "EC")); Algorithm algorithmVerify = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC")); byte[] contentBytes = String.format("%s.%s", ES512Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); assertThat(signatureBytes, is(notNullValue())); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnECDSA512SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA512withECDSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not a ECPrivateKey."))); Algorithm algorithm = Algorithm.ECDSA512((ECKey) readPublicKeyFromFile(PUBLIC_KEY_FILE_512, "EC")); algorithm.sign(new byte[0]); } @Test public void shouldThrowOnSignWhenSignatureAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPrivateKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); algorithm.sign(ES256Header.getBytes()); } @Test public void shouldThrowOnSignWhenThePrivateKeyIsInvalid() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(InvalidKeyException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPrivateKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); algorithm.sign(ES256Header.getBytes(StandardCharsets.UTF_8)); } @Test public void shouldThrowOnSignWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given ECKey is not a ECPrivateKey."))); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(InvalidKeyException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPublicKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); algorithm.sign(ES256Header.getBytes(StandardCharsets.UTF_8)); } @Test public void shouldThrowOnSignWhenTheSignatureIsNotPrepared() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(SignatureException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(SignatureException.class); ECKey key = mock(ECKey.class, withSettings().extraInterfaces(ECPrivateKey.class)); Algorithm algorithm = new ECDSAAlgorithm(crypto, "some-alg", "some-algorithm", 32, key); algorithm.sign(ES256Header.getBytes(StandardCharsets.UTF_8)); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/HMACAlgorithmTest.java000066400000000000000000000323431302130156000276300ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import org.apache.commons.codec.binary.Base64; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.nio.charset.StandardCharsets; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.util.Arrays; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; public class HMACAlgorithmTest { @Rule public ExpectedException exception = ExpectedException.none(); // Verify @Test public void shouldGetStringBytes() throws Exception { String text = "abcdef123456!@#$%^"; byte[] expectedBytes = text.getBytes("UTF-8"); assertTrue(Arrays.equals(expectedBytes, HMACAlgorithm.getSecretBytes(text))); } @Test public void shouldPassHMAC256Verification() throws Exception { String jwt = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; Algorithm algorithmString = Algorithm.HMAC256("secret"); Algorithm algorithmBytes = Algorithm.HMAC256("secret".getBytes()); AlgorithmUtils.verify(algorithmString, jwt); AlgorithmUtils.verify(algorithmBytes, jwt); } @Test public void shouldFailHMAC256VerificationWithInvalidSecretString() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA256"); String jwt = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; Algorithm algorithm = Algorithm.HMAC256("not_real_secret"); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailHMAC256VerificationWithInvalidSecretBytes() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA256"); String jwt = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; Algorithm algorithm = Algorithm.HMAC256("not_real_secret".getBytes()); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassHMAC384Verification() throws Exception { String jwt = "eyJhbGciOiJIUzM4NCIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.uztpK_wUMYJhrRv8SV-1LU4aPnwl-EM1q-wJnqgyb5DHoDteP6lN_gE1xnZJH5vw"; Algorithm algorithmString = Algorithm.HMAC384("secret"); Algorithm algorithmBytes = Algorithm.HMAC384("secret".getBytes()); AlgorithmUtils.verify(algorithmString, jwt); AlgorithmUtils.verify(algorithmBytes, jwt); } @Test public void shouldFailHMAC384VerificationWithInvalidSecretString() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA384"); String jwt = "eyJhbGciOiJIUzM4NCIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.uztpK_wUMYJhrRv8SV-1LU4aPnwl-EM1q-wJnqgyb5DHoDteP6lN_gE1xnZJH5vw"; Algorithm algorithm = Algorithm.HMAC384("not_real_secret"); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailHMAC384VerificationWithInvalidSecretBytes() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA384"); String jwt = "eyJhbGciOiJIUzM4NCIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.uztpK_wUMYJhrRv8SV-1LU4aPnwl-EM1q-wJnqgyb5DHoDteP6lN_gE1xnZJH5vw"; Algorithm algorithm = Algorithm.HMAC384("not_real_secret".getBytes()); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassHMAC512Verification() throws Exception { String jwt = "eyJhbGciOiJIUzUxMiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.VUo2Z9SWDV-XcOc_Hr6Lff3vl7L9e5Vb8ThXpmGDFjHxe3Dr1ZBmUChYF-xVA7cAdX1P_D4ZCUcsv3IefpVaJw"; Algorithm algorithmString = Algorithm.HMAC512("secret"); Algorithm algorithmBytes = Algorithm.HMAC512("secret".getBytes()); AlgorithmUtils.verify(algorithmString, jwt); AlgorithmUtils.verify(algorithmBytes, jwt); } @Test public void shouldFailHMAC512VerificationWithInvalidSecretString() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA512"); String jwt = "eyJhbGciOiJIUzUxMiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.VUo2Z9SWDV-XcOc_Hr6Lff3vl7L9e5Vb8ThXpmGDFjHxe3Dr1ZBmUChYF-xVA7cAdX1P_D4ZCUcsv3IefpVaJw"; Algorithm algorithm = Algorithm.HMAC512("not_real_secret"); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailHMAC512VerificationWithInvalidSecretBytes() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: HmacSHA512"); String jwt = "eyJhbGciOiJIUzUxMiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.VUo2Z9SWDV-XcOc_Hr6Lff3vl7L9e5Vb8ThXpmGDFjHxe3Dr1ZBmUChYF-xVA7cAdX1P_D4ZCUcsv3IefpVaJw"; Algorithm algorithm = Algorithm.HMAC512("not_real_secret".getBytes()); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowOnVerifyWhenSignatureAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(byte[].class), any(byte[].class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); Algorithm algorithm = new HMACAlgorithm(crypto, "some-alg", "some-algorithm", "secret".getBytes()); String jwt = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowOnVerifyWhenTheSecretIsInvalid() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(byte[].class), any(byte[].class), any(byte[].class))) .thenThrow(InvalidKeyException.class); Algorithm algorithm = new HMACAlgorithm(crypto, "some-alg", "some-algorithm", "secret".getBytes()); String jwt = "eyJhbGciOiJIUzI1NiIsImN0eSI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mZ0m_N1J4PgeqWmi903JuUoDRZDBPB7HwkS4nVyWH1M"; AlgorithmUtils.verify(algorithm, jwt); } // Sign private static final String HS256Header = "eyJhbGciOiJIUzI1NiJ9"; private static final String HS384Header = "eyJhbGciOiJIUzM4NCJ9"; private static final String HS512Header = "eyJhbGciOiJIUzUxMiJ9"; private static final String auth0IssPayload = "eyJpc3MiOiJhdXRoMCJ9"; @Test public void shouldDoHMAC256SigningWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC256("secret".getBytes(StandardCharsets.UTF_8)); byte[] contentBytes = String.format("%s.%s", HS256Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "s69x7Mmu4JqwmdxiK6sesALO7tcedbFsKEEITUxw9ho"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldDoHMAC384SigningWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC384("secret".getBytes(StandardCharsets.UTF_8)); byte[] contentBytes = String.format("%s.%s", HS384Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "4-y2Gxz_foN0jAOFimmBPF7DWxf4AsjM20zxNkHg8Zah5Q64G42P9GfjmUp4Hldt"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldDoHMAC512SigningWithBytes() throws Exception { Algorithm algorithm = Algorithm.HMAC512("secret".getBytes(StandardCharsets.UTF_8)); byte[] contentBytes = String.format("%s.%s", HS512Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "OXWyxmf-VcVo8viOiTFfLaEy6mrQqLEos5R82Xsx8mtFxQadJAQ1aVniIWN8qT2GNE_pMQPcdzk4x7Cqxsp1dw"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldDoHMAC256SigningWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC256("secret"); byte[] contentBytes = String.format("%s.%s", HS256Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "s69x7Mmu4JqwmdxiK6sesALO7tcedbFsKEEITUxw9ho"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldDoHMAC384SigningWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC384("secret"); byte[] contentBytes = String.format("%s.%s", HS384Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "4-y2Gxz_foN0jAOFimmBPF7DWxf4AsjM20zxNkHg8Zah5Q64G42P9GfjmUp4Hldt"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldDoHMAC512SigningWithString() throws Exception { Algorithm algorithm = Algorithm.HMAC512("secret"); byte[] contentBytes = String.format("%s.%s", HS512Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithm.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "OXWyxmf-VcVo8viOiTFfLaEy6mrQqLEos5R82Xsx8mtFxQadJAQ1aVniIWN8qT2GNE_pMQPcdzk4x7Cqxsp1dw"; assertThat(signatureBytes, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithm.verify(contentBytes, signatureBytes); } @Test public void shouldThrowOnSignWhenSignatureAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(byte[].class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); Algorithm algorithm = new HMACAlgorithm(crypto, "some-alg", "some-algorithm", "secret".getBytes(StandardCharsets.UTF_8)); algorithm.sign(new byte[0]); } @Test public void shouldThrowOnSignWhenTheSecretIsInvalid() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(byte[].class), any(byte[].class))) .thenThrow(InvalidKeyException.class); Algorithm algorithm = new HMACAlgorithm(crypto, "some-alg", "some-algorithm", "secret".getBytes(StandardCharsets.UTF_8)); algorithm.sign(new byte[0]); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/NoneAlgorithmTest.java000066400000000000000000000020441302130156000300120ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureVerificationException; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; public class NoneAlgorithmTest { @Rule public ExpectedException exception = ExpectedException.none(); @Test public void shouldPassNoneVerification() throws Exception { Algorithm algorithm = Algorithm.none(); String jwt = "eyJhbGciOiJub25lIiwiY3R5IjoiSldUIn0.eyJpc3MiOiJhdXRoMCJ9"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailNoneVerificationWhenSignatureIsPresent() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: none"); String jwt = "eyJhbGciOiJub25lIiwiY3R5IjoiSldUIn0.eyJpc3MiOiJhdXRoMCJ9.Ox-WRXRaGAuWt2KfPvWiGcCrPqZtbp_4OnQzZXaTfss"; Algorithm algorithm = Algorithm.none(); AlgorithmUtils.verify(algorithm, jwt); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/algorithms/RSAAlgorithmTest.java000066400000000000000000000517321302130156000275500ustar00rootroot00000000000000package com.auth0.jwt.algorithms; import com.auth0.jwt.exceptions.SignatureGenerationException; import com.auth0.jwt.exceptions.SignatureVerificationException; import org.apache.commons.codec.binary.Base64; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.nio.charset.StandardCharsets; import java.security.*; import java.security.interfaces.RSAKey; import java.security.interfaces.RSAPrivateKey; import java.security.interfaces.RSAPublicKey; import static com.auth0.jwt.PemUtils.readPrivateKeyFromFile; import static com.auth0.jwt.PemUtils.readPublicKeyFromFile; import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.isA; import static org.junit.Assert.assertThat; import static org.junit.internal.matchers.ThrowableMessageMatcher.hasMessage; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.*; public class RSAAlgorithmTest { private static final String PRIVATE_KEY_FILE = "src/test/resources/rsa-private.pem"; private static final String PUBLIC_KEY_FILE = "src/test/resources/rsa-public.pem"; private static final String INVALID_PUBLIC_KEY_FILE = "src/test/resources/rsa-public_invalid.pem"; @Rule public ExpectedException exception = ExpectedException.none(); //Verify @Test public void shouldPassRSA256Verification() throws Exception { String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; Algorithm algorithm = Algorithm.RSA256((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA256VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withRSA"); String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; Algorithm algorithm = Algorithm.RSA256((RSAKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA256VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA256withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPublicKey."))); String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; Algorithm algorithm = Algorithm.RSA256((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassRSA384Verification() throws Exception { String jwt = "eyJhbGciOiJSUzM4NCIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.TZlWjXObwGSQOiu2oMq8kiKz0_BR7bbBddNL6G8eZ_GoR82BXOZDqNrQr7lb_M-78XGBguWLWNIdYhzgxOUL9EoCJlrqVm9s9vo6G8T1sj1op-4TbjXZ61TwIvrJee9BvPLdKUJ9_fp1Js5kl6yXkst40Th8Auc5as4n49MLkipjpEhKDKaENKHpSubs1ripSz8SCQZSofeTM_EWVwSw7cpiM8Fy8jOPvWG8Xz4-e3ODFowvHVsDcONX_4FTMNbeRqDuHq2ZhCJnEfzcSJdrve_5VD5fM1LperBVslTrOxIgClOJ3RmM7-WnaizJrWP3D6Z9OLxPxLhM6-jx6tcxEw"; Algorithm algorithm = Algorithm.RSA384((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA384VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withRSA"); String jwt = "eyJhbGciOiJSUzM4NCIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.TZlWjXObwGSQOiu2oMq8kiKz0_BR7bbBddNL6G8eZ_GoR82BXOZDqNrQr7lb_M-78XGBguWLWNIdYhzgxOUL9EoCJlrqVm9s9vo6G8T1sj1op-4TbjXZ61TwIvrJee9BvPLdKUJ9_fp1Js5kl6yXkst40Th8Auc5as4n49MLkipjpEhKDKaENKHpSubs1ripSz8SCQZSofeTM_EWVwSw7cpiM8Fy8jOPvWG8Xz4-e3ODFowvHVsDcONX_4FTMNbeRqDuHq2ZhCJnEfzcSJdrve_5VD5fM1LperBVslTrOxIgClOJ3RmM7-WnaizJrWP3D6Z9OLxPxLhM6-jx6tcxEw"; Algorithm algorithm = Algorithm.RSA384((RSAKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA384VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA384withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPublicKey."))); String jwt = "eyJhbGciOiJSUzM4NCIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.TZlWjXObwGSQOiu2oMq8kiKz0_BR7bbBddNL6G8eZ_GoR82BXOZDqNrQr7lb_M-78XGBguWLWNIdYhzgxOUL9EoCJlrqVm9s9vo6G8T1sj1op-4TbjXZ61TwIvrJee9BvPLdKUJ9_fp1Js5kl6yXkst40Th8Auc5as4n49MLkipjpEhKDKaENKHpSubs1ripSz8SCQZSofeTM_EWVwSw7cpiM8Fy8jOPvWG8Xz4-e3ODFowvHVsDcONX_4FTMNbeRqDuHq2ZhCJnEfzcSJdrve_5VD5fM1LperBVslTrOxIgClOJ3RmM7-WnaizJrWP3D6Z9OLxPxLhM6-jx6tcxEw"; Algorithm algorithm = Algorithm.RSA384((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldPassRSA512Verification() throws Exception { String jwt = "eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mvL5LoMyIrWYjk5umEXZTmbyIrkbbcVPUkvdGZbu0qFBxGOf0nXP5PZBvPcOu084lvpwVox5n3VaD4iqzW-PsJyvKFgi5TnwmsbKchAp7JexQEsQOnTSGcfRqeUUiBZqRQdYsho71oAB3T4FnalDdFEpM-fztcZY9XqKyayqZLreTeBjqJm4jfOWH7KfGBHgZExQhe96NLq1UA9eUyQwdOA1Z0SgXe4Ja5PxZ6Fm37KnVDtDlNnY4JAAGFo6y74aGNnp_BKgpaVJCGFu1f1S5xCQ1HSvs8ZSdVWs5NgawW3wRd0kRt_GJ_Y3mIwiF4qUyHWGtsSHu_qjVdCTtbFyow"; Algorithm algorithm = Algorithm.RSA512((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA512VerificationWithInvalidPublicKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withRSA"); String jwt = "eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mvL5LoMyIrWYjk5umEXZTmbyIrkbbcVPUkvdGZbu0qFBxGOf0nXP5PZBvPcOu084lvpwVox5n3VaD4iqzW-PsJyvKFgi5TnwmsbKchAp7JexQEsQOnTSGcfRqeUUiBZqRQdYsho71oAB3T4FnalDdFEpM-fztcZY9XqKyayqZLreTeBjqJm4jfOWH7KfGBHgZExQhe96NLq1UA9eUyQwdOA1Z0SgXe4Ja5PxZ6Fm37KnVDtDlNnY4JAAGFo6y74aGNnp_BKgpaVJCGFu1f1S5xCQ1HSvs8ZSdVWs5NgawW3wRd0kRt_GJ_Y3mIwiF4qUyHWGtsSHu_qjVdCTtbFyow"; Algorithm algorithm = Algorithm.RSA512((RSAKey) readPublicKeyFromFile(INVALID_PUBLIC_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldFailRSA512VerificationWhenUsingPrivateKey() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: SHA512withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPublicKey."))); String jwt = "eyJhbGciOiJSUzUxMiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.mvL5LoMyIrWYjk5umEXZTmbyIrkbbcVPUkvdGZbu0qFBxGOf0nXP5PZBvPcOu084lvpwVox5n3VaD4iqzW-PsJyvKFgi5TnwmsbKchAp7JexQEsQOnTSGcfRqeUUiBZqRQdYsho71oAB3T4FnalDdFEpM-fztcZY9XqKyayqZLreTeBjqJm4jfOWH7KfGBHgZExQhe96NLq1UA9eUyQwdOA1Z0SgXe4Ja5PxZ6Fm37KnVDtDlNnY4JAAGFo6y74aGNnp_BKgpaVJCGFu1f1S5xCQ1HSvs8ZSdVWs5NgawW3wRd0kRt_GJ_Y3mIwiF4qUyHWGtsSHu_qjVdCTtbFyow"; Algorithm algorithm = Algorithm.RSA512((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowWhenMacAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPublicKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowWhenThePublicKeyIsInvalid() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(InvalidKeyException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPublicKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; AlgorithmUtils.verify(algorithm, jwt); } @Test public void shouldThrowWhenTheSignatureIsNotPrepared() throws Exception { exception.expect(SignatureVerificationException.class); exception.expectMessage("The Token's Signature resulted invalid when verified using the Algorithm: some-alg"); exception.expectCause(isA(SignatureException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.verifySignatureFor(anyString(), any(PublicKey.class), any(byte[].class), any(byte[].class))) .thenThrow(SignatureException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPublicKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoMCJ9.dxXF3MdsyW-AuvwJpaQtrZ33fAde9xWxpLIg9cO2tMLH2GSRNuLAe61KsJusZhqZB9Iy7DvflcmRz-9OZndm6cj_ThGeJH2LLc90K83UEvvRPo8l85RrQb8PcanxCgIs2RcZOLygERizB3pr5icGkzR7R2y6zgNCjKJ5_NJ6EiZsGN6_nc2PRK_DbyY-Wn0QDxIxKoA5YgQJ9qafe7IN980pXvQv2Z62c3XR8dYuaXBqhthBj-AbaFHEpZapN-V-TmuLNzR2MCB6Xr7BYMuCaqWf_XU8og4XNe8f_8w9Wv5vvgqMM1KhqVpG5VdMJv4o_L4NoCROHhtUQSLRh2M9cA"; AlgorithmUtils.verify(algorithm, jwt); } //Sign private static final String RS256Header = "eyJhbGciOiJSUzI1NiJ9"; private static final String RS384Header = "eyJhbGciOiJSUzM4NCJ9"; private static final String RS512Header = "eyJhbGciOiJSUzUxMiJ9"; private static final String auth0IssPayload = "eyJpc3MiOiJhdXRoMCJ9"; @Test public void shouldDoRSA256Signing() throws Exception { Algorithm algorithmSign = Algorithm.RSA256((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); Algorithm algorithmVerify = Algorithm.RSA256((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); byte[] contentBytes = String.format("%s.%s", RS256Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "ZB-Tr0vLtnf8I9fhSdSjU6HZei5xLYZQ6nZqM5O6Va0W9PgAqgRT7ShI9CjeYulRXPHvVmSl5EQuYuXdBzM0-H_3p_Nsl6tSMy4EyX2kkhEm6T0HhvarTh8CG0PCjn5p6FP5ZxWwhLcmRN70ItP6Z5MMO4CcJh1JrNxR4Fi4xQgt-CK2aVDMFXd-Br5yQiLVx1CX83w28OD9wssW3Rdltl5e66vCef0Ql6Q5I5e5F0nqGYT989a9fkNgLIx2F8k_az5x07BY59FV2SZg59nSiY7TZNjP8ot11Ew7HKRfPXOdh9eKRUVdhcxzqDePhyzKabU8TG5FP0SiWH5qVPfAgw"; assertThat(signature, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnRSA256SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA256withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPrivateKey."))); Algorithm algorithm = Algorithm.RSA256((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); algorithm.sign(new byte[0]); } @Test public void shouldDoRSA384Signing() throws Exception { Algorithm algorithmSign = Algorithm.RSA384((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); Algorithm algorithmVerify = Algorithm.RSA384((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); byte[] contentBytes = String.format("%s.%s", RS384Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "Jx1PaTBnjd_U56MNjifFcY7w9ImDbseg0y8Ijr2pSiA1_wzQb_wy9undaWfzR5YqdIAXvjS8AGuZUAzIoTG4KMgOgdVyYDz3l2jzj6wI-lgqfR5hTy1w1ruMUQ4_wobpdxAiJ4fEbg8Mi_GljOiCO-P1HilxKnpiOJZidR8MQGwTInsf71tOUkK4x5UsdmUueuZbaU-CL5kPnRfXmJj9CcdxZbD9oMlbo23dwkP5BNMrS2LwGGzc9C_-ypxrBIOVilG3WZxcSmuG86LjcZbnL6LBEfph5NmKBgQav147uipb_7umBEr1m2dYiB_9u606n3bcoo3rnsYYK_Xfi1GAEQ"; assertThat(signature, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnRSA384SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA384withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPrivateKey."))); Algorithm algorithm = Algorithm.RSA384((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); algorithm.sign(new byte[0]); } @Test public void shouldDoRSA512Signing() throws Exception { Algorithm algorithmSign = Algorithm.RSA512((RSAKey) readPrivateKeyFromFile(PRIVATE_KEY_FILE, "RSA")); Algorithm algorithmVerify = Algorithm.RSA512((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); byte[] contentBytes = String.format("%s.%s", RS512Header, auth0IssPayload).getBytes(StandardCharsets.UTF_8); byte[] signatureBytes = algorithmSign.sign(contentBytes); String signature = Base64.encodeBase64URLSafeString(signatureBytes); String expectedSignature = "THIPVYzNZ1Yo_dm0k1UELqV0txs3SzyMopCyHcLXOOdgYXF4MlGvBqu0CFvgSga72Sp5LpuC1Oesj40v_QDsp2GTGDeWnvvcv_eo-b0LPSpmT2h1Ibrmu-z70u2rKf28pkN-AJiMFqi8sit2kMIp1bwIVOovPvMTQKGFmova4Xwb3G526y_PeLlflW1h69hQTIVcI67ACEkAC-byjDnnYIklA-B4GWcggEoFwQRTdRjAUpifA6HOlvnBbZZlUd6KXwEydxVS-eh1odwPjB2_sfbyy5HnLsvNdaniiZQwX7QbwLNT4F72LctYdHHM1QCrID6bgfgYp9Ij9CRX__XDEA"; assertThat(signature, is(notNullValue())); assertThat(signature, is(expectedSignature)); algorithmVerify.verify(contentBytes, signatureBytes); } @Test public void shouldFailOnRSA512SigningWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: SHA512withRSA"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPrivateKey."))); Algorithm algorithm = Algorithm.RSA512((RSAKey) readPublicKeyFromFile(PUBLIC_KEY_FILE, "RSA")); algorithm.sign(new byte[0]); } @Test public void shouldThrowOnSignWhenSignatureAlgorithmDoesNotExists() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(NoSuchAlgorithmException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(NoSuchAlgorithmException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPrivateKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); algorithm.sign(RS256Header.getBytes(StandardCharsets.UTF_8)); } @Test public void shouldThrowOnSignWhenThePrivateKeyIsInvalid() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(InvalidKeyException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(InvalidKeyException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPrivateKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); algorithm.sign(RS256Header.getBytes(StandardCharsets.UTF_8)); } @Test public void shouldThrowOnSignWhenUsingPublicKey() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(IllegalArgumentException.class)); exception.expectCause(hasMessage(is("The given RSAKey is not a RSAPrivateKey."))); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(InvalidKeyException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPublicKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); algorithm.sign(RS256Header.getBytes(StandardCharsets.UTF_8)); } @Test public void shouldThrowOnSignWhenTheSignatureIsNotPrepared() throws Exception { exception.expect(SignatureGenerationException.class); exception.expectMessage("The Token's Signature couldn't be generated when signing using the Algorithm: some-algorithm"); exception.expectCause(isA(SignatureException.class)); CryptoHelper crypto = mock(CryptoHelper.class); when(crypto.createSignatureFor(anyString(), any(PrivateKey.class), any(byte[].class))) .thenThrow(SignatureException.class); RSAKey key = mock(RSAKey.class, withSettings().extraInterfaces(RSAPrivateKey.class)); Algorithm algorithm = new RSAAlgorithm(crypto, "some-alg", "some-algorithm", key); algorithm.sign(RS256Header.getBytes(StandardCharsets.UTF_8)); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/000077500000000000000000000000001302130156000223315ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/BaseClaimTest.java000066400000000000000000000025751302130156000256650ustar00rootroot00000000000000package com.auth0.jwt.impl; import org.junit.Before; import org.junit.Test; import org.omg.CORBA.Object; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.nullValue; import static org.junit.Assert.assertThat; public class BaseClaimTest { private NullClaim claim; @Before public void setUp() throws Exception { claim = new NullClaim(); } @Test public void shouldBeNull() throws Exception { assertThat(claim.isNull(), is(true)); } @Test public void shouldGetAsBoolean() throws Exception { assertThat(claim.asBoolean(), is(nullValue())); } @Test public void shouldGetAsInt() throws Exception { assertThat(claim.asInt(), is(nullValue())); } @Test public void shouldGetAsDouble() throws Exception { assertThat(claim.asDouble(), is(nullValue())); } @Test public void shouldGetAsString() throws Exception { assertThat(claim.asString(), is(nullValue())); } @Test public void shouldGetAsDate() throws Exception { assertThat(claim.asDate(), is(nullValue())); } @Test public void shouldGetAsArray() throws Exception { assertThat(claim.asArray(Object.class), is(nullValue())); } @Test public void shouldGetAsList() throws Exception { assertThat(claim.asList(Object.class), is(nullValue())); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/ClaimImplTest.java000066400000000000000000000212361302130156000257070ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.UserPojo; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Claim; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.MissingNode; import com.fasterxml.jackson.databind.node.NullNode; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.util.Arrays; import java.util.Date; import static com.auth0.jwt.impl.JsonNodeClaim.claimFromNode; import static com.auth0.jwt.impl.JWTParser.getDefaultObjectMapper; import static org.hamcrest.Matchers.*; import static org.hamcrest.core.IsNull.notNullValue; import static org.hamcrest.core.IsNull.nullValue; import static org.junit.Assert.assertThat; public class ClaimImplTest { private ObjectMapper mapper; @Rule public ExpectedException exception = ExpectedException.none(); @Before public void setUp() throws Exception { mapper = getDefaultObjectMapper(); } @Test public void shouldGetBooleanValue() throws Exception { JsonNode value = mapper.valueToTree(true); Claim claim = claimFromNode(value); assertThat(claim.asBoolean(), is(notNullValue())); assertThat(claim.asBoolean(), is(true)); } @Test public void shouldGetNullBooleanIfNotBooleanValue() throws Exception { JsonNode objectValue = mapper.valueToTree(new Object()); assertThat(claimFromNode(objectValue).asBoolean(), is(nullValue())); JsonNode stringValue = mapper.valueToTree("boolean"); assertThat(claimFromNode(stringValue).asBoolean(), is(nullValue())); } @Test public void shouldGetIntValue() throws Exception { JsonNode value = mapper.valueToTree(123); Claim claim = claimFromNode(value); assertThat(claim.asInt(), is(notNullValue())); assertThat(claim.asInt(), is(123)); } @Test public void shouldGetNullIntIfNotIntValue() throws Exception { JsonNode objectValue = mapper.valueToTree(new Object()); assertThat(claimFromNode(objectValue).asInt(), is(nullValue())); JsonNode stringValue = mapper.valueToTree("123"); assertThat(claimFromNode(stringValue).asInt(), is(nullValue())); } @Test public void shouldGetDoubleValue() throws Exception { JsonNode value = mapper.valueToTree(1.5); Claim claim = claimFromNode(value); assertThat(claim.asDouble(), is(notNullValue())); assertThat(claim.asDouble(), is(1.5)); } @Test public void shouldGetNullDoubleIfNotDoubleValue() throws Exception { JsonNode objectValue = mapper.valueToTree(new Object()); assertThat(claimFromNode(objectValue).asDouble(), is(nullValue())); JsonNode stringValue = mapper.valueToTree("123.23"); assertThat(claimFromNode(stringValue).asDouble(), is(nullValue())); } @Test public void shouldGetDateValue() throws Exception { JsonNode value = mapper.valueToTree(1476824844L); Claim claim = claimFromNode(value); assertThat(claim.asDate(), is(notNullValue())); assertThat(claim.asDate(), is(new Date(1476824844L * 1000))); } @Test public void shouldGetNullDateIfNotDateValue() throws Exception { JsonNode objectValue = mapper.valueToTree(new Object()); assertThat(claimFromNode(objectValue).asDate(), is(nullValue())); JsonNode stringValue = mapper.valueToTree("1476824844"); assertThat(claimFromNode(stringValue).asDate(), is(nullValue())); } @Test public void shouldGetStringValue() throws Exception { JsonNode value = mapper.valueToTree("string"); Claim claim = claimFromNode(value); assertThat(claim.asString(), is(notNullValue())); assertThat(claim.asString(), is("string")); } @Test public void shouldGetNullStringIfNotStringValue() throws Exception { JsonNode objectValue = mapper.valueToTree(new Object()); assertThat(claimFromNode(objectValue).asString(), is(nullValue())); JsonNode intValue = mapper.valueToTree(12345); assertThat(claimFromNode(intValue).asString(), is(nullValue())); } @Test public void shouldGetArrayValueOfCustomClass() throws Exception { JsonNode value = mapper.valueToTree(new UserPojo[]{new UserPojo("George", 1), new UserPojo("Mark", 2)}); Claim claim = claimFromNode(value); assertThat(claim.asArray(UserPojo.class), is(notNullValue())); assertThat(claim.asArray(UserPojo.class), is(arrayContaining(new UserPojo("George", 1), new UserPojo("Mark", 2)))); } @Test public void shouldGetArrayValue() throws Exception { JsonNode value = mapper.valueToTree(new String[]{"string1", "string2"}); Claim claim = claimFromNode(value); assertThat(claim.asArray(String.class), is(notNullValue())); assertThat(claim.asArray(String.class), is(arrayContaining("string1", "string2"))); } @Test public void shouldGetNullArrayIfNullValue() throws Exception { JsonNode value = mapper.valueToTree(null); Claim claim = claimFromNode(value); assertThat(claim.asArray(String.class), is(nullValue())); } @Test public void shouldGetNullArrayIfNonArrayValue() throws Exception { JsonNode value = mapper.valueToTree(1); Claim claim = claimFromNode(value); assertThat(claim.asArray(String.class), is(nullValue())); } @Test public void shouldThrowIfArrayClassMismatch() throws Exception { JsonNode value = mapper.valueToTree(new String[]{"keys", "values"}); Claim claim = claimFromNode(value); exception.expect(JWTDecodeException.class); claim.asArray(UserPojo.class); } @Test public void shouldGetListValueOfCustomClass() throws Exception { JsonNode value = mapper.valueToTree(Arrays.asList(new UserPojo("George", 1), new UserPojo("Mark", 2))); Claim claim = claimFromNode(value); assertThat(claim.asList(UserPojo.class), is(notNullValue())); assertThat(claim.asList(UserPojo.class), is(hasItems(new UserPojo("George", 1), new UserPojo("Mark", 2)))); } @Test public void shouldGetListValue() throws Exception { JsonNode value = mapper.valueToTree(Arrays.asList("string1", "string2")); Claim claim = claimFromNode(value); assertThat(claim.asList(String.class), is(notNullValue())); assertThat(claim.asList(String.class), is(hasItems("string1", "string2"))); } @Test public void shouldGetNullListIfNullValue() throws Exception { JsonNode value = mapper.valueToTree(null); Claim claim = claimFromNode(value); assertThat(claim.asList(String.class), is(nullValue())); } @Test public void shouldGetNullListIfNonArrayValue() throws Exception { JsonNode value = mapper.valueToTree(1); Claim claim = claimFromNode(value); assertThat(claim.asList(String.class), is(nullValue())); } @Test public void shouldThrowIfListClassMismatch() throws Exception { JsonNode value = mapper.valueToTree(new String[]{"keys", "values"}); Claim claim = claimFromNode(value); exception.expect(JWTDecodeException.class); claim.asList(UserPojo.class); } @Test public void shouldReturnBaseClaimWhenParsingMissingNode() throws Exception { JsonNode value = MissingNode.getInstance(); Claim claim = claimFromNode(value); assertThat(claim, is(notNullValue())); assertThat(claim, is(instanceOf(NullClaim.class))); assertThat(claim.isNull(), is(true)); } @Test public void shouldReturnBaseClaimWhenParsingNullNode() throws Exception { JsonNode value = NullNode.getInstance(); Claim claim = claimFromNode(value); assertThat(claim, is(notNullValue())); assertThat(claim, is(instanceOf(NullClaim.class))); assertThat(claim.isNull(), is(true)); } @Test public void shouldReturnBaseClaimWhenParsingNullValue() throws Exception { JsonNode value = mapper.valueToTree(null); Claim claim = claimFromNode(value); assertThat(claim, is(notNullValue())); assertThat(claim, is(instanceOf(NullClaim.class))); assertThat(claim.isNull(), is(true)); } @Test public void shouldReturnValidButNullClaimIfTreeIsEmpty() throws Exception { JsonNode value = mapper.valueToTree(new Object()); Claim claim = claimFromNode(value); assertThat(claim, is(notNullValue())); assertThat(claim, is(instanceOf(JsonNodeClaim.class))); assertThat(claim.isNull(), is(true)); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/ClaimsHolderTest.java000066400000000000000000000021151302130156000264010ustar00rootroot00000000000000package com.auth0.jwt.impl; import org.hamcrest.collection.IsMapContaining; import org.junit.Test; import java.util.HashMap; import java.util.Map; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; public class ClaimsHolderTest { @SuppressWarnings("RedundantCast") @Test public void shouldGetClaims() throws Exception { HashMap claims = new HashMap<>(); claims.put("iss", "auth0"); ClaimsHolder holder = new ClaimsHolder(claims); assertThat(holder, is(notNullValue())); assertThat(holder.getClaims(), is(notNullValue())); assertThat(holder.getClaims(), is(instanceOf(Map.class))); assertThat(holder.getClaims(), is(IsMapContaining.hasEntry("iss", (Object) "auth0"))); } @Test public void shouldGetNotNullClaims() throws Exception { ClaimsHolder holder = new ClaimsHolder(null); assertThat(holder, is(notNullValue())); assertThat(holder.getClaims(), is(notNullValue())); assertThat(holder.getClaims(), is(instanceOf(Map.class))); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/HeaderDeserializerTest.java000066400000000000000000000103521302130156000275700ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Header; import com.fasterxml.jackson.core.JsonFactory; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.ObjectCodec; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonDeserializer; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.NullNode; import com.fasterxml.jackson.databind.node.TextNode; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.io.StringReader; import java.util.HashMap; import java.util.Map; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; public class HeaderDeserializerTest { @Rule public ExpectedException exception = ExpectedException.none(); private HeaderDeserializer deserializer; @Before public void setUp() throws Exception { deserializer = new HeaderDeserializer(); } @Test public void shouldThrowOnNullTree() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("Parsing the Header's JSON resulted on a Null map"); JsonDeserializer deserializer = new HeaderDeserializer(); JsonParser parser = mock(JsonParser.class); ObjectCodec codec = mock(ObjectCodec.class); DeserializationContext context = mock(DeserializationContext.class); when(codec.readValue(eq(parser), any(TypeReference.class))).thenReturn(null); when(parser.getCodec()).thenReturn(codec); deserializer.deserialize(parser, context); } @Test public void shouldNotRemoveKnownPublicClaimsFromTree() throws Exception { String headerJSON = "{\n" + " \"alg\": \"HS256\",\n" + " \"typ\": \"jws\",\n" + " \"cty\": \"content\",\n" + " \"kid\": \"key\",\n" + " \"roles\": \"admin\"\n" + "}"; StringReader reader = new StringReader(headerJSON); JsonParser jsonParser = new JsonFactory().createParser(reader); ObjectMapper mapper = new ObjectMapper(); jsonParser.setCodec(mapper); Header header = deserializer.deserialize(jsonParser, mapper.getDeserializationContext()); assertThat(header, is(notNullValue())); assertThat(header.getAlgorithm(), is("HS256")); assertThat(header.getType(), is("jws")); assertThat(header.getContentType(), is("content")); assertThat(header.getKeyId(), is("key")); assertThat(header.getHeaderClaim("roles").asString(), is("admin")); assertThat(header.getHeaderClaim("alg").asString(), is("HS256")); assertThat(header.getHeaderClaim("typ").asString(), is("jws")); assertThat(header.getHeaderClaim("cty").asString(), is("content")); assertThat(header.getHeaderClaim("kid").asString(), is("key")); } @Test public void shouldGetNullStringWhenParsingNullNode() throws Exception { Map tree = new HashMap<>(); NullNode node = NullNode.getInstance(); tree.put("key", node); String text = deserializer.getString(tree, "key"); assertThat(text, is(nullValue())); } @Test public void shouldGetNullStringWhenParsingNull() throws Exception { Map tree = new HashMap<>(); tree.put("key", null); String text = deserializer.getString(tree, "key"); assertThat(text, is(nullValue())); } @Test public void shouldGetStringWhenParsingTextNode() throws Exception { Map tree = new HashMap<>(); TextNode node = new TextNode("something here"); tree.put("key", node); String text = deserializer.getString(tree, "key"); assertThat(text, is(notNullValue())); assertThat(text, is("something here")); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/HeaderImplTest.java000066400000000000000000000114471302130156000260550ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.NullNode; import com.fasterxml.jackson.databind.node.TextNode; import org.hamcrest.collection.IsMapContaining; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.util.HashMap; import java.util.Map; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; public class HeaderImplTest { @Rule public ExpectedException exception = ExpectedException.none(); @SuppressWarnings("Convert2Diamond") @Test public void shouldHaveUnmodifiableTreeWhenInstantiatedWithNonNullTree() throws Exception { exception.expect(UnsupportedOperationException.class); BasicHeader header = new BasicHeader(null, null, null, null, new HashMap()); header.getTree().put("something", null); } @Test public void shouldHaveUnmodifiableTreeWhenInstantiatedWithNullTree() throws Exception { exception.expect(UnsupportedOperationException.class); BasicHeader header = new BasicHeader(null, null, null, null, null); header.getTree().put("something", null); } @Test public void shouldHaveTree() throws Exception { HashMap map = new HashMap<>(); JsonNode node = NullNode.getInstance(); map.put("key", node); BasicHeader header = new BasicHeader(null, null, null, null, map); assertThat(header.getTree(), is(notNullValue())); assertThat(header.getTree(), is(IsMapContaining.hasEntry("key", node))); } @Test public void shouldGetAlgorithm() throws Exception { BasicHeader header = new BasicHeader("HS256", null, null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getAlgorithm(), is(notNullValue())); assertThat(header.getAlgorithm(), is("HS256")); } @Test public void shouldGetNullAlgorithmIfMissing() throws Exception { BasicHeader header = new BasicHeader(null, null, null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getAlgorithm(), is(nullValue())); } @Test public void shouldGetType() throws Exception { BasicHeader header = new BasicHeader(null, "jwt", null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getType(), is(notNullValue())); assertThat(header.getType(), is("jwt")); } @Test public void shouldGetNullTypeIfMissing() throws Exception { BasicHeader header = new BasicHeader(null, null, null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getType(), is(nullValue())); } @Test public void shouldGetContentType() throws Exception { BasicHeader header = new BasicHeader(null, null, "content", null, null); assertThat(header, is(notNullValue())); assertThat(header.getContentType(), is(notNullValue())); assertThat(header.getContentType(), is("content")); } @Test public void shouldGetNullContentTypeIfMissing() throws Exception { BasicHeader header = new BasicHeader(null, null, null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getContentType(), is(nullValue())); } @Test public void shouldGetKeyId() throws Exception { BasicHeader header = new BasicHeader(null, null, null, "key", null); assertThat(header, is(notNullValue())); assertThat(header.getKeyId(), is(notNullValue())); assertThat(header.getKeyId(), is("key")); } @Test public void shouldGetNullKeyIdIfMissing() throws Exception { BasicHeader header = new BasicHeader(null, null, null, null, null); assertThat(header, is(notNullValue())); assertThat(header.getKeyId(), is(nullValue())); } @Test public void shouldGetExtraClaim() throws Exception { Map tree = new HashMap<>(); tree.put("extraClaim", new TextNode("extraValue")); BasicHeader header = new BasicHeader(null, null, null, null, tree); assertThat(header, is(notNullValue())); assertThat(header.getHeaderClaim("extraClaim"), is(instanceOf(JsonNodeClaim.class))); assertThat(header.getHeaderClaim("extraClaim").asString(), is("extraValue")); } @Test public void shouldGetNotNullExtraClaimIfMissing() throws Exception { Map tree = new HashMap<>(); BasicHeader header = new BasicHeader(null, null, null, null, tree); assertThat(header, is(notNullValue())); assertThat(header.getHeaderClaim("missing"), is(notNullValue())); assertThat(header.getHeaderClaim("missing"), is(instanceOf(NullClaim.class))); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/JWTParserTest.java000066400000000000000000000103551302130156000256610ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Header; import com.auth0.jwt.interfaces.Payload; import com.fasterxml.jackson.databind.Module; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.io.IOException; import static com.auth0.jwt.impl.JWTParser.getDefaultObjectMapper; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; public class JWTParserTest { @Rule public ExpectedException exception = ExpectedException.none(); private JWTParser parser; @Before public void setUp() throws Exception { parser = new JWTParser(); } @Test public void shouldGetDefaultObjectMapper() throws Exception { ObjectMapper mapper = getDefaultObjectMapper(); assertThat(mapper, is(notNullValue())); assertThat(mapper, is(instanceOf(ObjectMapper.class))); assertThat(mapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS), is(false)); } @Test public void shouldAddDeserializers() throws Exception { ObjectMapper mapper = mock(ObjectMapper.class); new JWTParser(mapper); verify(mapper).registerModule(any(Module.class)); } @Test public void shouldThrowOnReadValueException() throws Exception { String jsonPayload = "{}"; exception.expect(JWTDecodeException.class); exception.expectMessage(String.format("The string '%s' doesn't have a valid JSON format.", jsonPayload)); ObjectMapper mapper = mock(ObjectMapper.class); when(mapper.readValue(eq(jsonPayload), eq(Object.class))).thenThrow(IOException.class); JWTParser parser = new JWTParser(mapper); parser.convertFromJSON(jsonPayload, Object.class); } @Test public void shouldParsePayload() throws Exception { ObjectMapper mapper = mock(ObjectMapper.class); JWTParser parser = new JWTParser(mapper); parser.parsePayload("{}"); verify(mapper).readValue("{}", Payload.class); } @Test public void shouldThrowOnInvalidPayload() throws Exception { String jsonPayload = "{{"; exception.expect(JWTDecodeException.class); exception.expectMessage(String.format("The string '%s' doesn't have a valid JSON format.", jsonPayload)); Payload payload = parser.parsePayload(jsonPayload); assertThat(payload, is(nullValue())); } @Test public void shouldParseHeader() throws Exception { ObjectMapper mapper = mock(ObjectMapper.class); JWTParser parser = new JWTParser(mapper); parser.parseHeader("{}"); verify(mapper).readValue("{}", Header.class); } @Test public void shouldThrowOnInvalidHeader() throws Exception { String jsonHeader = "}}"; exception.expect(JWTDecodeException.class); exception.expectMessage(String.format("The string '%s' doesn't have a valid JSON format.", jsonHeader)); Header header = parser.parseHeader(jsonHeader); assertThat(header, is(nullValue())); } @Test public void shouldConvertFromValidJSON() throws Exception { String json = "{}"; Object object = parser.convertFromJSON(json, Object.class); assertThat(object, is(notNullValue())); } @Test public void shouldThrowWhenConvertingIfNullJson() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The string 'null' doesn't have a valid JSON format."); String json = null; Object object = parser.convertFromJSON(json, Object.class); assertThat(object, is(nullValue())); } @Test public void shouldThrowWhenConvertingFromInvalidJson() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("The string '}{' doesn't have a valid JSON format."); String json = "}{"; Object object = parser.convertFromJSON(json, Object.class); assertThat(object, is(nullValue())); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/PayloadDeserializerTest.java000066400000000000000000000226211302130156000277730ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.exceptions.JWTDecodeException; import com.auth0.jwt.interfaces.Payload; import com.fasterxml.jackson.core.JsonFactory; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.ObjectCodec; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.*; import org.hamcrest.collection.IsCollectionWithSize; import org.hamcrest.collection.IsEmptyCollection; import org.hamcrest.core.IsCollectionContaining; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.io.StringReader; import java.util.*; import static org.hamcrest.Matchers.*; import static org.junit.Assert.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; public class PayloadDeserializerTest { @Rule public ExpectedException exception = ExpectedException.none(); private PayloadDeserializer deserializer; @Before public void setUp() throws Exception { deserializer = new PayloadDeserializer(); } @Test public void shouldThrowOnNullTree() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("Parsing the Payload's JSON resulted on a Null map"); JsonParser parser = mock(JsonParser.class); ObjectCodec codec = mock(ObjectCodec.class); DeserializationContext context = mock(DeserializationContext.class); when(codec.readValue(eq(parser), any(TypeReference.class))).thenReturn(null); when(parser.getCodec()).thenReturn(codec); deserializer.deserialize(parser, context); } @Test public void shouldThrowWhenParsingArrayWithObjectValue() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("Couldn't map the Claim's array contents to String"); ObjectMapper mapper = new ObjectMapper(); JsonNode jsonNode = mapper.readTree("{\"some\" : \"random\", \"properties\" : \"inside\"}"); Map tree = new HashMap<>(); List subNodes = new ArrayList<>(); subNodes.add(jsonNode); ArrayNode arrNode = new ArrayNode(JsonNodeFactory.instance, subNodes); tree.put("key", arrNode); deserializer.getStringOrArray(tree, "key"); } @Test public void shouldNotRemoveKnownPublicClaimsFromTree() throws Exception { String payloadJSON = "{\n" + " \"iss\": \"auth0\",\n" + " \"sub\": \"emails\",\n" + " \"aud\": \"users\",\n" + " \"iat\": 10101010,\n" + " \"exp\": 11111111,\n" + " \"nbf\": 10101011,\n" + " \"jti\": \"idid\",\n" + " \"roles\":\"admin\" \n" + "}"; StringReader reader = new StringReader(payloadJSON); JsonParser jsonParser = new JsonFactory().createParser(reader); ObjectMapper mapper = new ObjectMapper(); jsonParser.setCodec(mapper); Payload payload = deserializer.deserialize(jsonParser, mapper.getDeserializationContext()); assertThat(payload, is(notNullValue())); assertThat(payload.getIssuer(), is("auth0")); assertThat(payload.getSubject(), is("emails")); assertThat(payload.getAudience(), is(IsCollectionContaining.hasItem("users"))); assertThat(payload.getIssuedAt().getTime(), is(10101010L * 1000)); assertThat(payload.getExpiresAt().getTime(), is(11111111L * 1000)); assertThat(payload.getNotBefore().getTime(), is(10101011L * 1000)); assertThat(payload.getId(), is("idid")); assertThat(payload.getClaim("roles").asString(), is("admin")); assertThat(payload.getClaim("iss").asString(), is("auth0")); assertThat(payload.getClaim("sub").asString(), is("emails")); assertThat(payload.getClaim("aud").asString(), is("users")); assertThat(payload.getClaim("iat").asDouble(), is(10101010D)); assertThat(payload.getClaim("exp").asDouble(), is(11111111D)); assertThat(payload.getClaim("nbf").asDouble(), is(10101011D)); assertThat(payload.getClaim("jti").asString(), is("idid")); } @Test public void shouldGetStringArrayWhenParsingArrayNode() throws Exception { Map tree = new HashMap<>(); List subNodes = new ArrayList<>(); TextNode textNode1 = new TextNode("one"); TextNode textNode2 = new TextNode("two"); subNodes.add(textNode1); subNodes.add(textNode2); ArrayNode arrNode = new ArrayNode(JsonNodeFactory.instance, subNodes); tree.put("key", arrNode); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(notNullValue())); assertThat(values, is(IsCollectionWithSize.hasSize(2))); assertThat(values, is(IsCollectionContaining.hasItems("one", "two"))); } @Test public void shouldGetStringArrayWhenParsingTextNode() throws Exception { Map tree = new HashMap<>(); TextNode textNode = new TextNode("something"); tree.put("key", textNode); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(notNullValue())); assertThat(values, is(IsCollectionWithSize.hasSize(1))); assertThat(values, is(IsCollectionContaining.hasItems("something"))); } @Test public void shouldGetEmptyStringArrayWhenParsingEmptyTextNode() throws Exception { Map tree = new HashMap<>(); TextNode textNode = new TextNode(""); tree.put("key", textNode); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(notNullValue())); assertThat(values, is(IsEmptyCollection.empty())); } @Test public void shouldGetNullArrayWhenParsingNullNode() throws Exception { Map tree = new HashMap<>(); NullNode node = NullNode.getInstance(); tree.put("key", node); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(nullValue())); } @Test public void shouldGetNullArrayWhenParsingNullNodeValue() throws Exception { Map tree = new HashMap<>(); tree.put("key", null); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(nullValue())); } @Test public void shouldGetNullArrayWhenParsingNonArrayOrTextNode() throws Exception { Map tree = new HashMap<>(); IntNode node = new IntNode(456789); tree.put("key", node); List values = deserializer.getStringOrArray(tree, "key"); assertThat(values, is(nullValue())); } @Test public void shouldGetNullDateWhenParsingNullNode() throws Exception { Map tree = new HashMap<>(); NullNode node = NullNode.getInstance(); tree.put("key", node); Date date = deserializer.getDateFromSeconds(tree, "key"); assertThat(date, is(nullValue())); } @Test public void shouldGetNullDateWhenParsingNull() throws Exception { Map tree = new HashMap<>(); tree.put("key", null); Date date = deserializer.getDateFromSeconds(tree, "key"); assertThat(date, is(nullValue())); } @Test public void shouldGetNullDateWhenParsingNonNumericNode() throws Exception { Map tree = new HashMap<>(); TextNode node = new TextNode("123456789"); tree.put("key", node); Date date = deserializer.getDateFromSeconds(tree, "key"); assertThat(date, is(nullValue())); } @Test public void shouldGetDateWhenParsingNumericNode() throws Exception { Map tree = new HashMap<>(); long seconds = 1478627949 / 1000; LongNode node = new LongNode(seconds); tree.put("key", node); Date date = deserializer.getDateFromSeconds(tree, "key"); assertThat(date, is(notNullValue())); assertThat(date.getTime(), is(seconds * 1000)); } @Test public void shouldGetNullStringWhenParsingNullNode() throws Exception { Map tree = new HashMap<>(); NullNode node = NullNode.getInstance(); tree.put("key", node); String text = deserializer.getString(tree, "key"); assertThat(text, is(nullValue())); } @Test public void shouldGetNullStringWhenParsingNull() throws Exception { Map tree = new HashMap<>(); tree.put("key", null); String text = deserializer.getString(tree, "key"); assertThat(text, is(nullValue())); } @Test public void shouldGetStringWhenParsingTextNode() throws Exception { Map tree = new HashMap<>(); TextNode node = new TextNode("something here"); tree.put("key", node); String text = deserializer.getString(tree, "key"); assertThat(text, is(notNullValue())); assertThat(text, is("something here")); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/PayloadImplTest.java000066400000000000000000000130231302130156000262460ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.TextNode; import org.hamcrest.collection.IsCollectionWithSize; import org.hamcrest.core.IsCollectionContaining; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import org.mockito.Mockito; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.Map; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; public class PayloadImplTest { @Rule public ExpectedException exception = ExpectedException.none(); private PayloadImpl payload; private Date expiresAt; private Date notBefore; private Date issuedAt; @Before public void setUp() throws Exception { expiresAt = Mockito.mock(Date.class); notBefore = Mockito.mock(Date.class); issuedAt = Mockito.mock(Date.class); Map tree = new HashMap<>(); tree.put("extraClaim", new TextNode("extraValue")); payload = new PayloadImpl("issuer", "subject", Collections.singletonList("audience"), expiresAt, notBefore, issuedAt, "jwtId", tree); } @SuppressWarnings("Convert2Diamond") @Test public void shouldHaveUnmodifiableTree() throws Exception { exception.expect(UnsupportedOperationException.class); PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, new HashMap()); payload.getTree().put("something", null); } @Test public void shouldGetIssuer() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getIssuer(), is("issuer")); } @Test public void shouldGetNullIssuerIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getIssuer(), is(nullValue())); } @Test public void shouldGetSubject() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getSubject(), is("subject")); } @Test public void shouldGetNullSubjectIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getSubject(), is(nullValue())); } @Test public void shouldGetAudience() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getAudience(), is(IsCollectionWithSize.hasSize(1))); assertThat(payload.getAudience(), is(IsCollectionContaining.hasItems("audience"))); } @Test public void shouldGetNullAudienceIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getAudience(), is(nullValue())); } @Test public void shouldGetExpiresAt() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getExpiresAt(), is(expiresAt)); } @Test public void shouldGetNullExpiresAtIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getExpiresAt(), is(nullValue())); } @Test public void shouldGetNotBefore() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getNotBefore(), is(notBefore)); } @Test public void shouldGetNullNotBeforeIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getNotBefore(), is(nullValue())); } @Test public void shouldGetIssuedAt() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getIssuedAt(), is(issuedAt)); } @Test public void shouldGetNullIssuedAtIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getIssuedAt(), is(nullValue())); } @Test public void shouldGetJWTId() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getId(), is("jwtId")); } @Test public void shouldGetNullJWTIdIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getId(), is(nullValue())); } @Test public void shouldGetExtraClaim() throws Exception { assertThat(payload, is(notNullValue())); assertThat(payload.getClaim("extraClaim"), is(instanceOf(JsonNodeClaim.class))); assertThat(payload.getClaim("extraClaim").asString(), is("extraValue")); } @Test public void shouldGetNotNullExtraClaimIfMissing() throws Exception { PayloadImpl payload = new PayloadImpl(null, null, null, null, null, null, null, null); assertThat(payload, is(notNullValue())); assertThat(payload.getClaim("missing"), is(notNullValue())); assertThat(payload.getClaim("missing"), is(instanceOf(NullClaim.class))); } }javaOIDCMsg-3.0.0/lib/src/test/java/com/auth0/jwt/impl/PayloadSerializerTest.java000066400000000000000000000164361302130156000274710ustar00rootroot00000000000000package com.auth0.jwt.impl; import com.auth0.jwt.UserPojo; import com.fasterxml.jackson.core.JsonFactory; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializerProvider; import org.junit.Before; import org.junit.Test; import java.io.StringWriter; import java.util.Arrays; import java.util.Date; import java.util.HashMap; import java.util.Map; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.is; import static org.junit.Assert.assertThat; public class PayloadSerializerTest { private StringWriter writer; private PayloadSerializer serializer; private JsonGenerator jsonGenerator; private SerializerProvider serializerProvider; @Before public void setUp() throws Exception { writer = new StringWriter(); serializer = new PayloadSerializer(); jsonGenerator = new JsonFactory().createGenerator(writer); ObjectMapper mapper = new ObjectMapper(); jsonGenerator.setCodec(mapper); serializerProvider = mapper.getSerializerProvider(); } @SuppressWarnings("Convert2Diamond") @Test public void shouldSerializeEmptyMap() throws Exception { ClaimsHolder holder = new ClaimsHolder(new HashMap()); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{}"))); } @Test public void shouldSerializeStringAudienceAsString() throws Exception { ClaimsHolder holder = holderFor("aud", "auth0"); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"aud\":\"auth0\"}"))); } @Test public void shouldSerializeSingleItemAudienceAsArray() throws Exception { ClaimsHolder holder = holderFor("aud", new String[]{"auth0"}); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"aud\":\"auth0\"}"))); } @Test public void shouldSerializeMultipleItemsAudienceAsArray() throws Exception { ClaimsHolder holder = holderFor("aud", new String[]{"auth0", "auth10"}); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"aud\":[\"auth0\",\"auth10\"]}"))); } @Test public void shouldSkipSerializationOnEmptyAudience() throws Exception { ClaimsHolder holder = holderFor("aud", new String[0]); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{}"))); } @Test public void shouldSerializeNotBeforeDateInSeconds() throws Exception { ClaimsHolder holder = holderFor("nbf", new Date(1478874000)); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"nbf\":1478874}"))); } @Test public void shouldSerializeIssuedAtDateInSeconds() throws Exception { ClaimsHolder holder = holderFor("iat", new Date(1478874000)); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"iat\":1478874}"))); } @Test public void shouldSerializeExpiresAtDateInSeconds() throws Exception { ClaimsHolder holder = holderFor("exp", new Date(1478874000)); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"exp\":1478874}"))); } @Test public void shouldSerializeCustomDateInSeconds() throws Exception { ClaimsHolder holder = holderFor("birthdate", new Date(1478874000)); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"birthdate\":1478874}"))); } @Test public void shouldSerializeStrings() throws Exception { ClaimsHolder holder = holderFor("name", "Auth0 Inc"); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"name\":\"Auth0 Inc\"}"))); } @Test public void shouldSerializeIntegers() throws Exception { ClaimsHolder holder = holderFor("number", 12345); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"number\":12345}"))); } @Test public void shouldSerializeDoubles() throws Exception { ClaimsHolder holder = holderFor("fraction", 23.45); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"fraction\":23.45}"))); } @Test public void shouldSerializeBooleans() throws Exception { ClaimsHolder holder = holderFor("pro", true); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"pro\":true}"))); } @Test public void shouldSerializeNulls() throws Exception { ClaimsHolder holder = holderFor("id", null); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"id\":null}"))); } @Test public void shouldSerializeCustomArrayOfObject() throws Exception { UserPojo user1 = new UserPojo("Michael", 1); UserPojo user2 = new UserPojo("Lucas", 2); ClaimsHolder holder = holderFor("users", new UserPojo[]{user1, user2}); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"users\":[{\"name\":\"Michael\",\"id\":1},{\"name\":\"Lucas\",\"id\":2}]}"))); } @Test public void shouldSerializeCustomListOfObject() throws Exception { UserPojo user1 = new UserPojo("Michael", 1); UserPojo user2 = new UserPojo("Lucas", 2); ClaimsHolder holder = holderFor("users", Arrays.asList(user1, user2)); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"users\":[{\"name\":\"Michael\",\"id\":1},{\"name\":\"Lucas\",\"id\":2}]}"))); } @Test public void shouldSerializeCustomObject() throws Exception { UserPojo user = new UserPojo("Michael", 1); ClaimsHolder holder = holderFor("users", user); serializer.serialize(holder, jsonGenerator, serializerProvider); jsonGenerator.flush(); assertThat(writer.toString(), is(equalTo("{\"users\":{\"name\":\"Michael\",\"id\":1}}"))); } @SuppressWarnings("Convert2Diamond") private ClaimsHolder holderFor(String key, Object value) { Map map = new HashMap(); map.put(key, value); return new ClaimsHolder(map); } }javaOIDCMsg-3.0.0/lib/src/test/resources/000077500000000000000000000000001302130156000200565ustar00rootroot00000000000000javaOIDCMsg-3.0.0/lib/src/test/resources/ec256-key-pair.pem000066400000000000000000000003431302130156000231240ustar00rootroot00000000000000-----BEGIN EC PRIVATE KEY----- MHcCAQEEIDxiRgJuF9X7wbgtc0qTv+CM8ej13zTGoimkuUVJBahBoAoGCCqGSM49 AwEHoUQDQgAEQgb5npLHd0Bk61bNnjK632uwmBfrF7I8hoPgaOZjyhh+BrPDO6CL 6D/aW/yPObXXm7SpZogmRwGROcOA3yUleg== -----END EC PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec256-key-private.pem000066400000000000000000000003611302130156000236430ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgPGJGAm4X1fvBuC1z SpO/4Izx6PXfNMaiKaS5RUkFqEGhRANCAARCBvmeksd3QGTrVs2eMrrfa7CYF+sX sjyGg+Bo5mPKGH4Gs8M7oIvoP9pb/I85tdebtKlmiCZHAZE5w4DfJSV6 -----END PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec256-key-public-invalid.pem000066400000000000000000000002621302130156000250730ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoBUyo8CQAFPeYPvv78ylh5MwFZjT CLQeb042TjiMJxG+9DLFmRSMlBQ9T/RsLLc+PmpB1+7yPAR+oR5gZn3kJQ== -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec256-key-public.pem000066400000000000000000000002621302130156000234470ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEQgb5npLHd0Bk61bNnjK632uwmBfr F7I8hoPgaOZjyhh+BrPDO6CL6D/aW/yPObXXm7SpZogmRwGROcOA3yUleg== -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec384-key-pair.pem000066400000000000000000000004401302130156000231240ustar00rootroot00000000000000-----BEGIN EC PRIVATE KEY----- MIGkAgEBBDCVWQsOJHjKD0I4cXOYJm4G8i5c7IMhFbxFq57OUlrTVmND43dvvNW1 oQ6i6NiXEQWgBwYFK4EEACKhZANiAASezSGlAu4wAaJe4676mQM0F/5slI+Ekdpt RJdfsQP9mNxe7RdzHgcSw7j/Wxa45nlnFnFrPPL4viJKOBRxMB1jjVA9my9PixxJ GoB22qDQwFbP8ldmEp6abwdBsXNaePM= -----END EC PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec384-key-private.pem000066400000000000000000000004621302130156000236470ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDCVWQsOJHjKD0I4cXOY Jm4G8i5c7IMhFbxFq57OUlrTVmND43dvvNW1oQ6i6NiXEQWhZANiAASezSGlAu4w AaJe4676mQM0F/5slI+EkdptRJdfsQP9mNxe7RdzHgcSw7j/Wxa45nlnFnFrPPL4 viJKOBRxMB1jjVA9my9PixxJGoB22qDQwFbP8ldmEp6abwdBsXNaePM= -----END PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec384-key-public-invalid.pem000066400000000000000000000003271302130156000250770ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEJ0tamPyAJVUhDO1DlceSYCdA9WKVX6nO K4VYetXvqmMKdyVkaoA4Gl02KoVLujiSSSAE6oK/Hf7x2fagaE9LgJdJxg07Ip+T C6cgFi2HHDeXG7djB5Zl1TKA9/w/8iW5 -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec384-key-public.pem000066400000000000000000000003271302130156000234530ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEns0hpQLuMAGiXuOu+pkDNBf+bJSPhJHa bUSXX7ED/ZjcXu0Xcx4HEsO4/1sWuOZ5ZxZxazzy+L4iSjgUcTAdY41QPZsvT4sc SRqAdtqg0MBWz/JXZhKemm8HQbFzWnjz -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec512-key-pair.pem000066400000000000000000000005511302130156000231200ustar00rootroot00000000000000-----BEGIN EC PRIVATE KEY----- MIHbAgEBBEHzl1DpZSQJ8YhCbN/uvo5SOu0BjDDX9Gub6zsBW6B2TxRzb5sBeQaW VscDUZha4Xr1HEWpVtua9+nEQU/9Aq9Pl6AHBgUrgQQAI6GBiQOBhgAEAJhvCa6S 89ePqlLO6MRV9KQqHvdAITDAf/WRDcvCmfrrNuov+j4gQXO12ohIukPCHM9rYms8 Eqciz3gaxVTxZD4CAA8i2k9H6ew9iSh1qXa1kLxiyzMBqmAmmg4u/SroD6OleG56 SwZVbWx+KIINB6r/PQVciGX8FjwgR/mbLHotVZYD -----END EC PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec512-key-private.pem000066400000000000000000000005731302130156000236430ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIHtAgEAMBAGByqGSM49AgEGBSuBBAAjBIHVMIHSAgEBBEHzl1DpZSQJ8YhCbN/u vo5SOu0BjDDX9Gub6zsBW6B2TxRzb5sBeQaWVscDUZha4Xr1HEWpVtua9+nEQU/9 Aq9Pl6GBiQOBhgAEAJhvCa6S89ePqlLO6MRV9KQqHvdAITDAf/WRDcvCmfrrNuov +j4gQXO12ohIukPCHM9rYms8Eqciz3gaxVTxZD4CAA8i2k9H6ew9iSh1qXa1kLxi yzMBqmAmmg4u/SroD6OleG56SwZVbWx+KIINB6r/PQVciGX8FjwgR/mbLHotVZYD -----END PRIVATE KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec512-key-public-invalid.pem000066400000000000000000000004141302130156000250650ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQBgtBWt9rVtdQPdeoChvCXnXHvkg/F 41AAubIVd+3yTvLFmxuHuaor9CHl7FlT3532mUG+GG0EEw5UuYkFrg/ABBgAfuVf wO1u0V0wJPkmpxcnZoojFaAOKcsBvUvDulbBh0HhAyd+nlfZquvV43uwFVpn2Cjb Lx+/AT1PE6Muqy4JkGU= -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/ec512-key-public.pem000066400000000000000000000004141302130156000234410ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQAmG8JrpLz14+qUs7oxFX0pCoe90Ah MMB/9ZENy8KZ+us26i/6PiBBc7XaiEi6Q8Icz2tiazwSpyLPeBrFVPFkPgIADyLa T0fp7D2JKHWpdrWQvGLLMwGqYCaaDi79KugPo6V4bnpLBlVtbH4ogg0Hqv89BVyI ZfwWPCBH+Zssei1VlgM= -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/rsa-private.pem000066400000000000000000000032531302130156000230210ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC4ZtdaIrd1BPIJ tfnF0TjIK5inQAXZ3XlCrUlJdP+XHwIRxdv1FsN12XyMYO/6ymLmo9ryoQeIrsXB XYqlET3zfAY+diwCb0HEsVvhisthwMU4gZQu6TYW2s9LnXZB5rVtcBK69hcSlA2k ZudMZWxZcj0L7KMfO2rIvaHw/qaVOE9j0T257Z8Kp2CLF9MUgX0ObhIsdumFRLaL DvDUmBPr2zuh/34j2XmWwn1yjN/WvGtdfhXW79Ki1S40HcWnygHgLV8sESFKUxxQ mKvPUTwDOIwLFL5WtE8Mz7N++kgmDcmWMCHc8kcOIu73Ta/3D4imW7VbKgHZo9+K 3ESFE3RjAgMBAAECggEBAJTEIyjMqUT24G2FKiS1TiHvShBkTlQdoR5xvpZMlYbN tVWxUmrAGqCQ/TIjYnfpnzCDMLhdwT48Ab6mQJw69MfiXwc1PvwX1e9hRscGul36 ryGPKIVQEBsQG/zc4/L2tZe8ut+qeaK7XuYrPp8bk/X1e9qK5m7j+JpKosNSLgJj NIbYsBkG2Mlq671irKYj2hVZeaBQmWmZxK4fw0Istz2WfN5nUKUeJhTwpR+JLUg4 ELYYoB7EO0Cej9UBG30hbgu4RyXA+VbptJ+H042K5QJROUbtnLWuuWosZ5ATldwO u03dIXL0SH0ao5NcWBzxU4F2sBXZRGP2x/jiSLHcqoECgYEA4qD7mXQpu1b8XO8U 6abpKloJCatSAHzjgdR2eRDRx5PMvloipfwqA77pnbjTUFajqWQgOXsDTCjcdQui wf5XAaWu+TeAVTytLQbSiTsBhrnoqVrr3RoyDQmdnwHT8aCMouOgcC5thP9vQ8Us rVdjvRRbnJpg3BeSNimH+u9AHgsCgYEA0EzcbOltCWPHRAY7B3Ge/AKBjBQr86Kv TdpTlxePBDVIlH+BM6oct2gaSZZoHbqPjbq5v7yf0fKVcXE4bSVgqfDJ/sZQu9Lp PTeV7wkk0OsAMKk7QukEpPno5q6tOTNnFecpUhVLLlqbfqkB2baYYwLJR3IRzboJ FQbLY93E8gkCgYB+zlC5VlQbbNqcLXJoImqItgQkkuW5PCgYdwcrSov2ve5r/Acz FNt1aRdSlx4176R3nXyibQA1Vw+ztiUFowiP9WLoM3PtPZwwe4bGHmwGNHPIfwVG m+exf9XgKKespYbLhc45tuC08DATnXoYK7O1EnUINSFJRS8cezSI5eHcbQKBgQDC PgqHXZ2aVftqCc1eAaxaIRQhRmY+CgUjumaczRFGwVFveP9I6Gdi+Kca3DE3F9Pq PKgejo0SwP5vDT+rOGHN14bmGJUMsX9i4MTmZUZ5s8s3lXh3ysfT+GAhTd6nKrIE kM3Nh6HWFhROptfc6BNusRh1kX/cspDplK5x8EpJ0QKBgQDWFg6S2je0KtbV5PYe RultUEe2C0jYMDQx+JYxbPmtcopvZQrFEur3WKVuLy5UAy7EBvwMnZwIG7OOohJb vkSpADK6VPn9lbqq7O8cTedEHttm6otmLt8ZyEl3hZMaL3hbuRj6ysjmoFKx6CrX rK0/Ikt5ybqUzKCMJZg2VKGTxg== -----END PRIVATE KEY-----javaOIDCMsg-3.0.0/lib/src/test/resources/rsa-public.pem000066400000000000000000000007031302130156000226220ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuGbXWiK3dQTyCbX5xdE4 yCuYp0AF2d15Qq1JSXT/lx8CEcXb9RbDddl8jGDv+spi5qPa8qEHiK7FwV2KpRE9 83wGPnYsAm9BxLFb4YrLYcDFOIGULuk2FtrPS512Qea1bXASuvYXEpQNpGbnTGVs WXI9C+yjHztqyL2h8P6mlThPY9E9ue2fCqdgixfTFIF9Dm4SLHbphUS2iw7w1JgT 69s7of9+I9l5lsJ9cozf1rxrXX4V1u/SotUuNB3Fp8oB4C1fLBEhSlMcUJirz1E8 AziMCxS+VrRPDM+zfvpIJg3JljAh3PJHDiLu902v9w+Iplu1WyoB2aPfitxEhRN0 YwIDAQAB -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/lib/src/test/resources/rsa-public_invalid.pem000066400000000000000000000007031302130156000243300ustar00rootroot00000000000000-----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxzYuc22QSst/dS7geYYK 5l5kLxU0tayNdixkEQ17ix+CUcUbKIsnyftZxaCYT46rQtXgCaYRdJcbB3hmyrOa vkhTpX79xJZnQmfuamMbZBqitvscxW9zRR9tBUL6vdi/0rpoUwPMEh8+Bw7CgYR0 FK0DhWYBNDfe9HKcyZEv3max8Cdq18htxjEsdYO0iwzhtKRXomBWTdhD5ykd/fAC VTr4+KEY+IeLvubHVmLUhbE5NgWXxrRpGasDqzKhCTmsa2Ysf712rl57SlH0Wz/M r3F7aM9YpErzeYLrl0GhQr9BVJxOvXcVd4kmY+XkiCcrkyS1cnghnllh+LCwQu1s YwIDAQAB -----END PUBLIC KEY----- javaOIDCMsg-3.0.0/local.properties000066400000000000000000000010151302130156000167350ustar00rootroot00000000000000## This file is automatically generated by Android Studio. # Do not modify this file -- YOUR CHANGES WILL BE ERASED! # # This file must *NOT* be checked into Version Control Systems, # as it contains information specific to your local configuration. # # Location of the SDK. This is only used by Gradle. # For customization when using a Version Control System, please read the # header note. #Fri Dec 02 18:18:12 ART 2016 ndk.dir=/Users/hernan/Development/Android.SDK/ndk-bundle sdk.dir=/Users/hernan/Development/Android.SDK javaOIDCMsg-3.0.0/scripts/000077500000000000000000000000001302130156000152175ustar00rootroot00000000000000javaOIDCMsg-3.0.0/scripts/bintray.gradle000066400000000000000000000031601302130156000200470ustar00rootroot00000000000000def credentials = new Bintray(project); if (credentials.valid()) { apply plugin: 'com.jfrog.bintray' bintray { user = credentials.user key = credentials.key publications = ['mavenJava'] dryRun = project.version.endsWith("-SNAPSHOT") publish = false pkg { repo = 'java' name = 'java-jwt' desc = 'Java implementation of JSON Web Token (JWT) ' websiteUrl = 'https://github.com/auth0/java-jwt' vcsUrl = 'scm:git@github.com:auth0/java-jwt.git' licenses = ["MIT"] userOrg = 'auth0' publish = false version { gpg { sign = true passphrase = credentials.passphrasse } vcsTag = project.version name = project.version released = new Date() } } } } class Bintray { String user String key String passphrasse Bintray(project) { this.user = Bintray.value(project, 'BINTRAY_USER', 'bintray.user') this.key = Bintray.value(project, 'BINTRAY_KEY', 'bintray.key') this.passphrasse = Bintray.value(project, 'BINTRAY_PASSPHRASE', 'bintray.gpg.password') } def valid() { return this.user != null && this.key != null && this.passphrasse != null; } private static def value(Project project, String env, String property) { def value = System.getenv(env) if (project.hasProperty(property)) { value = project.getProperty(property); } return value } }javaOIDCMsg-3.0.0/scripts/maven.gradle000066400000000000000000000067241302130156000175160ustar00rootroot00000000000000apply plugin: Auth0OSS class Auth0OSS implements Plugin { void apply(Project target) { target.extensions.create("auth0", Auth0Extension, target) target.configure(target) { apply plugin: 'maven-publish' target.task("sourcesJar", type: Jar, dependsOn: classes) { classifier = 'sources' from sourceSets.main.allSource } target.task("javadocJar", type: Jar, dependsOn: javadoc) { classifier = 'javadoc' from javadoc.getDestinationDir() } artifacts { archives sourcesJar, javadocJar } publishing { publications { mavenJava(MavenPublication) { from components.java artifact sourcesJar artifact javadocJar groupId project.group artifactId project.name version project.version } } } publishing.publications.all { pom.withXml { def lib = project.extensions.auth0 def root = asNode() root.appendNode('packaging', 'jar') root.appendNode('name', lib.name) root.appendNode('description', lib.description) def developersNode = root.appendNode('developers') project.extensions.auth0.developers.each { def node = developersNode.appendNode('developer') node.appendNode('id', it.id) node.appendNode('name', it.name) node.appendNode('email', it.email) } def dependenciesNode = root.appendNode('dependencies') configurations.compile.allDependencies.each { def dependencyNode = dependenciesNode.appendNode('dependency') dependencyNode.appendNode('groupId', it.group) dependencyNode.appendNode('artifactId', it.name) dependencyNode.appendNode('version', it.version) } def licenceNode = root.appendNode('licenses').appendNode('license') licenceNode.appendNode('name', 'The MIT License (MIT)') licenceNode.appendNode('url', "https://raw.githubusercontent.com/auth0/${lib.repo}/master/LICENSE") licenceNode.appendNode('distribution', 'repo') def scmNode = root.appendNode('scm') scmNode.appendNode('connection', "scm:git@github.com:auth0/${lib.repo}.git") scmNode.appendNode('developerConnection', "scm:git@github.com:auth0/${lib.repo}.git") scmNode.appendNode('url', "https://github.com/auth0/${lib.repo}") } } } } } class Auth0Extension { String name String repo String description List developers = [] private Project project Auth0Extension(project) { this.project = project } void developer(Closure developerClosure) { def developer = project.configure(new Developer(), developerClosure) developers.add(developer) } } class Developer { String id String name String email } javaOIDCMsg-3.0.0/scripts/release.gradle000066400000000000000000000124141302130156000200210ustar00rootroot00000000000000import java.text.SimpleDateFormat apply plugin: ReleasePlugin class Semver { String version def snapshot def getStringVersion() { return snapshot ? "$version-SNAPSHOT" : version } def nextPatch() { def parts = version.split("\\.") def patch = Integer.parseInt(parts[2]) + 1 return "${parts[0]}.${parts[1]}.${patch}" } def nextMinor() { def parts = version.split("\\.") def minor = Integer.parseInt(parts[1]) + 1 return "${parts[0]}.${minor}.0" } } class ChangeLogTask extends DefaultTask { def current def next @TaskAction def update() { def repository = project.auth0.repo def file = new File('CHANGELOG.md') def output = new File('CHANGELOG.md.release') output.newWriter().withWriter { writer -> file.eachLine { line, number -> if (number == 0 && !line.startsWith('# Change Log')) { throw new GradleException('Change Log file is not properly formatted') } writer.println(line) if (number == 0 || number > 1) { return } def formatter = new SimpleDateFormat('yyyy-MM-dd') writer.println() writer.println("## [${next}](https://github.com/auth0/${repository}/tree/${next}) (${formatter.format(new Date())})") writer.println("[Full Changelog](https://github.com/auth0/${repository}/compare/${current}...${next})") def command = ["curl", "https://webtask.it.auth0.com/api/run/wt-hernan-auth0_com-0/oss-changelog.js?webtask_no_cache=1&repo=${repository}&milestone=${next}", "-f", "-s", "-H", "Accept: text/markdown"] def content = command.execute() content.consumeProcessOutputStream(writer) if (content.waitFor() != 0) { throw new GradleException("Failed to request changelog for version ${next}") } } } file.delete() output.renameTo('CHANGELOG.md') } } class ReleaseTask extends DefaultTask { def tagName @TaskAction def perform() { def path = project.getRootProject().getProjectDir().path project.exec { commandLine 'git', 'add', 'README.md' workingDir path } project.exec { commandLine 'git', 'add', 'CHANGELOG.md' workingDir path } project.exec { commandLine 'git', 'commit', '-m', "Release ${tagName}" workingDir path } project.exec { commandLine 'git', 'tag', "${tagName}" workingDir path } } } class ReadmeTask extends DefaultTask { def current def next final filename = 'README.md' @TaskAction def update() { def file = new File(filename) def updated = "compile '${project.group}:${project.name}:${next}'" def oldSingleQuote = "compile '${project.group}:${project.name}:${current}'" def oldDoubleQuote = "compile \"${project.group}:${project.name}:${current}\"" def contents = file.getText('UTF-8') contents = contents.replace(oldSingleQuote, updated).replace(oldDoubleQuote, updated) file.write(contents, 'UTF-8') } } class ReleasePlugin implements Plugin { void apply(Project target) { def semver = current() target.version = semver.stringVersion def version = semver.version def nextMinor = semver.nextMinor() def nextPatch = semver.nextPatch() target.task('changelogMinor', type: ChangeLogTask) { current = version next = nextMinor } target.task('changelogPatch', type: ChangeLogTask) { current = version next = nextPatch } target.task('readmeMinor', type: ReadmeTask, dependsOn: 'changelogMinor') { current = version next = nextMinor } target.task('readmePatch', type: ReadmeTask, dependsOn: 'changelogPatch') { current = version next = nextPatch } target.task('releaseMinor', type: ReleaseTask, dependsOn: 'readmeMinor') { tagName = nextMinor } target.task('releasePatch', type: ReleaseTask, dependsOn: 'readmePatch') { tagName = nextPatch } } static def current() { def current = describeGit(false) def snapshot = current == null if (snapshot) { current = describeGit(snapshot, '0.0.1') } return new Semver(snapshot: snapshot, version: current) } static def describeGit(boolean snapshot, String defaultValue = null) { def command = ['git', 'describe', '--tags', (snapshot ? '--abbrev=0' : '--exact-match')].execute() def stdout = new ByteArrayOutputStream() def errout = new ByteArrayOutputStream() command.consumeProcessOutput(stdout, errout) if (command.waitFor() != 0) { Logging.getLogger(ReleasePlugin.class).debug(errout.toString()) return defaultValue } if (stdout.toByteArray().length > 0) { return stdout.toString().replace('\n', "") } return defaultValue } }javaOIDCMsg-3.0.0/settings.gradle000066400000000000000000000001361302130156000165500ustar00rootroot00000000000000include ':java-jwt' project(':java-jwt').projectDir = new File(rootProject.projectDir, '/lib')