搜索

[15653] 2020-07-26_Java代码审计基础之反射

文档创建者：s7ckTeam
浏览次数：2
最后更新：2025-01-18
2020-07-26_Java代码审计基础之反射 J a v a 代 码 审 计 基 础 之 反 射 x i a o p a n 2 3 3   F r e e B u f   2 0 2 0 - 0 7 - 2 6 先 来 一 段 反 射 的 概 念 ： 在 程 序 运 行 的 时 候 动 态 装 载 类 ， 查 看 类 的 信 息 ， 生 成 对 象 ， 或 操 作 生 成 对 象 。 类 在 运 行 的 时 候 ， 可 以 得 到 该 类 的 信 息 ， 并 且 可 以 动 态 的 修 改 这 些 信 息 反 射 类 的 首 要 操 作 反 射 类 的 首 要 操 作   -   获 取 类 获 取 类 获 取 类 有   三 种   方 法 ： 假 设 类 名 为   C a t （ 1 ） 直 接 根 据 类 名 获 取 类 （ 2 ） 通 过 C l a s s . f o r N a m e   获 取 类 ， 需 要 打 全 指 定 类 的 路 径 注 意 ： C l a s s . f o r N a m e   需 要 一 个 异 常 处 理 。 不 然 编 辑 器 无 法 通 过 。 （ 3 ） 通 过 实 例 化 的 方 式 获 取 类 反 射 构 造 方 法 反 射 构 造 方 法 吾 有 一 类 ， 曰 ： C l a s s   a   =   C a t . c l a s s ; C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ; C l a s s   a   =   ( n e w   C a t ( ) ) . g e t C l a s s ( ) ; c l a s s   C a t {         / / 构 造 方 法 ， 形 参 为 空         p u b l i c   C a t ( ) {                 S y s t e m . o u t . p r i n t l n ( " C a t - > n u l l C a t " ) ;         }         / / 构 造 方 法 ， 形 参 为   一 个 S t r i n g 类 型         p u b l i c   C a t ( S t r i n g   a ) {                 S y s t e m . o u t . p r i n t l n ( " C a t - > a C a t , a = "   +   a ) ;         }
无 参 构 造 方 法 调 用 无 参 构 造 方 法 调 用 输 出 ： 注 意 ： g e t C o n s t r u c t o r   需 要 加 一 个 异 常 处 理 。 一 个 参 数 的 构 造 方 法 调 用 一 个 参 数 的 构 造 方 法 调 用         }         / / 私 有 构 造 方 法 ， 形 参 为   一 个 S t r i n g 类 型   和   一 个 I n t e g e r 类 型         p r i v a t e   C a t ( S t r i n g   a , I n t e g e r   b ) {                 S y s t e m . o u t . p r i n t l n ( " C a t - > a b C a t , a = "   +   a   +   " b = "   +   b . t o S t r i n g ( ) ) ;         }         / / 构 造 方 法 ， 形 参 为   一 个 S t r i n g 数 组 类 型   和   一 个 M a p 类 型         p u b l i c   C a t ( S t r i n g [ ]   a a , M a p   b b ) {                 S y s t e m . o u t . p r i n t l n ( " C a t - > a a b b C a t " ) ;                 S y s t e m . o u t . p r i n t l n ( " a a = "   +   A r r a y s . t o S t r i n g ( a a ) ) ;                 S y s t e m . o u t . p r i n t l n ( " b b = "   +   b b ) ;         } } t r y {         / / 获 取 到 类         C l a s s   a   =   C a t . c l a s s ;         / / 通 过 反 射 获 取 到 指 定 类 下 的 构 造 方 法         / / 要 获 取 的 构 造 方 法 为 :         / / p u b l i c   C a t ( )         / / 由 于 该 构 造 方 法 无 参 数 ， 所 以 我 们 传 入 一 个   n u l l   即 可 ， 也 可 以 不 传         C o n s t r u c t o r   c o n s t r u c t o r 1   =   a . g e t C o n s t r u c t o r ( n u l l ) ;         / / 实 例 化 类         c o n s t r u c t o r 1 . n e w I n s t a n c e ( n u l l ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 到 类         C l a s s   a   =   C a t . c l a s s ;         / / 通 过 反 射 获 取 到 指 定 类 下 的 构 造 方 法         / / 要 获 取 的 构 造 方 法 为 :         / / p u b l i c   C a t ( S t r i n g   a )
输 出 ： 多 个 参 数 的 私 有 构 造 方 法 调 用 多 个 参 数 的 私 有 构 造 方 法 调 用 注 意 ， 这 里 调 用 的 构 造 方 法 是 私 有 的 哦 ~ 输 出 ：         / / p u b l i c   C a t ( S t r i n g   a )         / / 由 于 该 构 造 方 法 有 一   S t r i n g 类 型   参 数         / / 在 进 行   g e t C o n s t r u c t o r   反 射 时 ， 就 需 要 指 定 传 参 类 型 为   S t r i n g . c l a s s         C o n s t r u c t o r   c o n s t r u c t o r 1   =   a . g e t C o n s t r u c t o r ( S t r i n g . c l a s s ) ;       / / 在 实 例 化 时 ， 进 行 传 参       c o n s t r u c t o r 1 . n e w I n s t a n c e ( " t e s t v a l u e " ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 到 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 通 过 反 射 获 取 到 指 定 类 下 的 构 造 方 法         / / 要 获 取 的   私 有   构 造 方 法 为 ：         / / p r i v a t e   C a t ( S t r i n g   a , I n t e g e r   b )         / /         / / 由 于 是   私 有   方 法 ， 获 取 私 有 方 法 的 函 数 为   g e t D e c l a r e d C o n s t r u c t o r         / / 由 于 有 两 个 参 数 ， 所 以 需 要 在   g e t D e c l a r e d C o n s t r u c t o r   传 入 对 应 的 参 数 类 型         C o n s t r u c t o r   c   =   a . g e t D e c l a r e d C o n s t r u c t o r ( S t r i n g . c l a s s ,   I n t e g e r . c l a s s ) ;         / / 设 置 强 制 反 射         c . s e t A c c e s s i b l e ( t r u e ) ;         / / 构 造 函 数 实 例 化 ， 并 传 参         / / 这 里 有 个 注 意 点 ， 看 下 文 的 注 意         c . n e w I n s t a n c e ( n e w   O b j e c t [ ] { " a b c d " , 1 2 3 4 5 6 } ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; }
注 意 ： 参 考 了 大 佬 的 文 章 （ 参 考 文 章 在 本 文 末 尾   R e f e r e r   中 ） ， 文 章 说   j d k 1 . 4 和   j d k 1 . 5   处 理 调 用 的 方 法 有 区 别 j d k 1 . 4 中 ， 数 组 每 个 元 素 对 应 一 个 参 数 j d k 1 . 5 中 ， 整 个 数 组 是 一 个 参 数 ， 用 一 个 对 象 包 起 来 所 以 我 们 调 用 的 传 参 的 时 候 ， 需 要 使 用 这 种 格 式 ： 形 参 为 数 组 和 形 参 为 数 组 和 M a p 类 型 的 构 造 方 法 调 用 类 型 的 构 造 方 法 调 用 字 符 串 数 组 创 建 格 式 ： M a p ： j a v a 中 的 m a p ， 可 以 理 解 为 “ 可 自 定 义 键 值 的 数 组 ” 形 参 为 数 组 和 M a p 类 型 的 构 造 方 法 调 用 ： c . n e w I n s t a n c e ( n e w   O b j e c t [ ] { " a b c d " , 1 2 3 4 5 6 } ) ; / / 即 n e w   O b j e c t [ ] { " a b c d " , 1 2 3 4 5 6 }   的 格 式 ， 用 一 个 对 象 包 裹 起 来 S t r i n g [ ]   a   =   { " a b c " ,   " d e f " } ; t r y {         / / 获 取 类
输 出 ： 反 射 方 法 反 射 方 法 简 介 ： 反 射 方 法 和 上 文 的 反 射 构 造 方 法 差 不 多 ， 如 果 是 私 有 的 话 也 是 要 设 置 强 行 调 用 ， 并 且 获 取 方 法 的 函 数 为 g e t D e c l a r e d x x x x 吾 有 一 类 ： 反 射 无 参 数 方 法 反 射 无 参 数 方 法         / / 获 取 类         C l a s s   a   =   ( n e w   C a t ( ) ) . g e t C l a s s ( ) ;         / / 调 用 的 构 造 方 法 为 ：         / / p u b l i c   C a t ( S t r i n g [ ]   a a , M a p   b b )         / / 照 常 打   x x x . c l a s s   即 可 。 j a v a   万 物 皆 对 象         C o n s t r u c t o r   c   =   a . g e t C o n s t r u c t o r ( S t r i n g [ ] . c l a s s ,   M a p . c l a s s ) ;         / / 创 建 一 个 m a p         M a p   m   =   n e w   H a s h M a p ( ) ;         m . p u t ( " a _ k e y " , " a _ v a l u e " ) ;         / / 实 例 化 构 造 函 数 ， 注 意 要 用   O b j e c t 包 裹 的 形 式         / / n e w   S t r i n g [ ] { }   是 当 场 初 始 化 字 符 串 数 组 ， 当 场 赋 值         c . n e w I n s t a n c e ( n e w   O b j e c t [ ] { n e w   S t r i n g [ ] { " a " , " b " , " c " } ,   m } ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } c l a s s   C a t {         p u b l i c   v o i d   a ( ) {                 S y s t e m . o u t . p r i n t l n ( " a   i n v o k e " ) ;         }         p u b l i c   S t r i n g [ ]   b ( S t r i n g [ ]   b ) {                 r e t u r n   b ;         }         p u b l i c   s t a t i c   v o i d   c ( ) {                 S y s t e m . o u t . p r i n t l n ( " c c c c c c " ) ;         } }
输 出 ： 反 射 有 参 数 有 返 回 值 方 法 反 射 有 参 数 有 返 回 值 方 法 t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 先 实 例 化 ， 后 面 调 用 方 法 的 时 候 需 要 使 用 实 例 化 好 的 类         / / 注 意 ， 实 例 化 之 后 返 回 的 类 型 就 是 对 于 的 类 ， 做 好 类 型 转 换         C a t   c a t   = ( C a t )   a . n e w I n s t a n c e ( ) ;         / / 调 用 的 方 法 为 ：         / / p u b l i c   v o i d   a ( )         / /         / / 获 取 方 法 ， 需 要 指 定 要 获 取 的 方 法 名         M e t h o d   m   =   a . g e t M e t h o d ( " a " ,   n u l l ) ;         / / 调 用 方 法 ， 调 用 方 法 时 ， 用   上 一 步 代 码 中 获 取 到 的 方 法 进 行   i n v o k e   调 用 操 作         / / 而 i n v o k e 方 法 中 ， 第 一 个 参 数 是 实 例 化 好 的 类         / / 第 二 个 参 数 就 是 需 要 传 入 的 参 数         m . i n v o k e ( c a t , n u l l ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 先 实 例 化 ， 后 面 调 用 方 法 的 时 候 需 要 使 用 实 例 化 好 的 类         / / 注 意 ， 实 例 化 之 后 返 回 的 类 型 就 是 对 于 的 类 ， 做 好 类 型 转 换         C a t   c a t   = ( C a t )   a . n e w I n s t a n c e ( ) ;         / / 调 用 的 方 法 为 ：         / / p u b l i c   S t r i n g [ ]   b ( S t r i n g [ ]   b )         / /         / / 获 取 方 法 ， 需 要 指 定 要 获 取 的 方 法 名         M e t h o d   m   =   a . g e t M e t h o d ( " b " , S t r i n g [ ] . c l a s s ) ;         / / 调 用 方 法 ， 调 用 方 法 时 ， 用   上 一 步 代 码 中 获 取 到 的 方 法 进 行   i n v o k e   调 用 操 作         / / 调 用 时 ， 如 果 参 数 是 字 符 串 数 组 ， 或 者 两 个 以 上 的 参 数         / / 最 好 使 用   n e w   O b j e c t [ ] { }   的 形 式 传 入         / / 兼 容 性 好         / / 由 于 有 返 回 值 ， 我 们 在 调 用 的 时 候 也 需 要 进 行 接 收         / / 接 受 类 型 就 看 调 用 的 类 返 回 的 类 型 了         S t r i n g [ ]   s t r s   =   ( S t r i n g [ ] )   m . i n v o k e ( c a t ,   n e w   O b j e c t [ ] { n e w   S t r i n g [ ] { " s t r 1 " , " s t r 2 " , " s t r 3 " } } ) ;
输 出 ： 反 射 静 态 方 法 反 射 静 态 方 法 由 于 静 态 方 法 不 需 要 实 例 化 类 ， 所 以 在   g e t M e t h o d   的 时 候 ， 直 接 传 个   n u l l   即 可 。 也 不 需 要   n e w I n s t a n c e   类 了 。 输 出 ：         / / 打 印 数 组 ：         / / f o r   e a c h 打 印 数 组 ， 先 指 定 抽 出 来 的 元 素 类 型         / / 然 后 以 冒 号   :   分 隔 ， 左 边 是 抽 出 元 素 变 量 名 ， 右 边 是 原 数 组         f o r   ( S t r i n g   s t r : s t r s ) {                 S y s t e m . o u t . p r i n t l n ( s t r ) ;         } } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 调 用 的 方 法 为 ：         / / p u b l i c   s t a t i c   v o i d   c ( )         / /         / / 获 取 方 法         M e t h o d   m   =   a . g e t M e t h o d ( " c " ) ;         / / 由 于 是 静 态 方 法 。 直 接 调 用 ， 类 对 象 中 传 入 n u l l 即 可         m . i n v o k e ( n u l l ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; }
反 射 属 性 反 射 属 性 反 射 属 性 也 大 同 小 异 吾 有 一 类 ： 反 射 公 共 属 性 反 射 公 共 属 性 输 出 ： 反 射 公 共 静 态 属 性 反 射 公 共 静 态 属 性 静 态 属 性 也 一 样 ， 不 需 要 实 例 化 即 可 调 用 ： c l a s s   C a t {         p u b l i c   S t r i n g   n a m e   =   " m a o m a o " ;             / / 公 共   S t r i n g 类 型   属 性         p u b l i c   s t a t i c   B o o l e a n   s e x   =   t r u e ;       / / 公 共   静 态   S t r i n g 类 型   属 性         p r i v a t e   I n t e g e r   a g e   =   1 0 ;                       / / 私 有   I n t e g e r 类 型   属 性 } t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 先 实 例 化 ， 后 面 获 取 属 性 的 时 候 需 要 使 用 实 例 化 好 的 类         C a t   c a t   =   ( C a t )   a . n e w I n s t a n c e ( ) ;         / / 属 性 ：         / / p u b l i c   S t r i n g   n a m e   =   " m a o m a o " ;         / /         / / 获 取 属 性         F i e l d   m   =   a . g e t F i e l d ( " n a m e " ) ;         / / 获 取 属 性 值         / / 需 要 传 入 实 例 化 类 作 为 对 象         S t r i n g   n a m e   =   ( S t r i n g )   m . g e t ( c a t ) ;         S y s t e m . o u t . p r i n t l n ( n a m e ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 属 性 ：         / / p u b l i c   s t a t i c   B o o l e a n   s e x   =   t r u e ;         / /
输 出 ： 反 射 私 有 属 性 反 射 私 有 属 性 私 有 属 性 也 一 样 ， 需 要 暴 力 反 射 输 出 ：         / /         / / 获 取 属 性         F i e l d   m   =   a . g e t F i e l d ( " s e x " ) ;         / / 获 取 属 性 值 , 静 态 属 性 不 需 要 实 例 化 类 ， 直 接 传 入 n u l l 作 为 类 对 象 即 可         B o o l e a n   b   =   ( B o o l e a n )   m . g e t ( n u l l ) ;         S y s t e m . o u t . p r i n t l n ( b ) ;         / / 设 置 属 性 值         m . s e t ( n u l l , f a l s e ) ;         b   =   ( B o o l e a n )   m . g e t ( n u l l ) ;         S y s t e m . o u t . p r i n t l n ( b ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; } t r y {         / / 获 取 类         C l a s s   a   =   C l a s s . f o r N a m e ( " o r g . x i a o p a n . t e s t . C a t " ) ;         / / 先 实 例 化 ， 后 面 获 取 属 性 的 时 候 需 要 使 用 实 例 化 好 的 类         C a t   c a t   =   ( C a t )   a . n e w I n s t a n c e ( ) ;         / / 属 性 ：         / / p r i v a t e   I n t e g e r   a g e   =   1 0 ;         / /         / / 获 取 私 有 属 性         F i e l d   m   =   a . g e t D e c l a r e d F i e l d ( " a g e " ) ;         / / 设 置 强 制 反 射         m . s e t A c c e s s i b l e ( t r u e ) ;         / / 获 取 属 性 值         I n t e g e r   a g e   =   ( I n t e g e r )   m . g e t ( c a t ) ;         / / 注 意 输 出 的 时 候 要 将 非 S t r i n g 类 型   t o S t r i n g   哦 ， 规 范 一 点         S y s t e m . o u t . p r i n t l n ( a g e . t o S t r i n g ( ) ) ; } c a t c h   ( E x c e p t i o n   e ) {         S y s t e m . o u t . p r i n t l n ( e ) ; }
引 用 包 错 误 的 报 错 ： 引 用 包 错 误 的 报 错 ： 用 I D E A 写 代 码 的 时 候 ， 可 以 会 遇 到 奇 怪 报 错 ， 如 ： 代 码 本 来 就 没 问 题 ， 但 还 是 报 错 了 ： 这 个 时 候 可 以 看 看 代 码 最 上 面 ， 看 看 I D E A 是 不 是 自 动 引 入 了 错 误 的 包 ： 发 现 有 引 用 错 误 的 包 ， 将 其 删 掉 即 可 ， 然 后 再 重 新 在   M e t h o d 上 进 行 修 复 ： R u n t i m e . g e t R u n t i m e . e x e c   反 射 反 射 了 解 了 解   R u n t i m e . g e t R u n t i m e . e x e c R u n t i m e . g e t R u n t i m e . e x e c   是 J a v a 中 执 行 系 统 命 令 的 方 法 简 单 使 用 如 下 ： 我 们 来 一 一 分 析 下 ， 重 点 就 两 大 块 ： P r o c e s s   和   I n p u t S t r e a m P r o c e s s   c m d   =   R u n t i m e . g e t R u n t i m e ( ) . e x e c ( “ w h o a m i ” ) b y t e [ ]   a   =   n e w   b y t e [ 1 0 2 4 ] ; P r o c e s s   c m d   =   R u n t i m e . g e t R u n t i m e ( ) . e x e c ( " w h o a m i " ) ; I n p u t S t r e a m   i n p u t   =   c m d . g e t I n p u t S t r e a m ( ) ; i n p u t . r e a d ( a ) ; S t r i n g   r e s   =   n e w   S t r i n g ( a ) ; S y s t e m . o u t . p r i n t l n ( r e s ) ;
回复

举报

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

使用Markdown编辑器编辑 使用富文本编辑器编辑

Archiver| 手机版| 小黑屋|
Powered by Discuz! X3.4 Copyright © 2001-2020, Tencent Cloud. 商业源码建议获取授权，如侵犯您的权益，请联系客服处理