【连载】纯鸿蒙应用安全开发指南-Web组件安全

【连载】纯鸿蒙应用安全开发指南-Web组件安全
2023-12-4 21:25:37 Author: mp.weixin.qq.com(查看原文) 阅读量:26 收藏

对于移动端应用来说，web组件的安全问题是比较常见的。本文将从webview应用开发和安全隐患两方面来介绍纯鸿蒙态下的web组件。如有错误或思考不周还请留言或私信指正，感谢:)

一. 初识Webview 二. 软件架构三. Webview应用开发 1. 加载本地页面 2. 加载html数据 3. 加载网络资源 4. 注册JavaScript接口四. Webview开发安全浅析 1. 网络数据明文传输 2. 是否保存密码信息 3. SSL错误处理与证书双向认证 4. 跨域资源访问 5. 禁用JavaScript执行 6. webview白名单校验 Ⅰ. indexOf校验 Ⅱ. startsWith() & endsWith()校验 Ⅲ. 纯鸿蒙模块@ohos.url获取域名 Ⅳ. 纯鸿蒙模块@ohos.uri校验 Ⅴ. 重定向方式绕过与检测 Ⅵ. JsInterface接口安全分级绕过场景 Ⅶ. JavascriptInterface once more 五. 小结

一. 初识Webview

Web组件用于在应用程序中显示Web页面内容，为开发者提供页面加载、页面交互、页面调试等能力

页面加载：Web组件提供基础的前端页面加载的能力，包括加载网络页面、本地页面、Html格式文本数据。
页面交互：Web组件提供丰富的页面交互的方式，包括：设置前端页面深色模式，新窗口中加载页面，位置权限管理，Cookie管理，应用侧使用前端页面JavaScript等能力。
页面调试：Web组件支持使用Devtools工具调试前端页面。

二. 软件架构

图片来自https://gitee.com/openharmony/web_webview

webview组件：OpenHarmony的UI组件。
nweb：基于CEF构建的OpenHarmony web组件的Native引擎。
CEF：CEF全称Chromium Embedded Framework，是一个基于Google Chromium 的开源项目。
Chromium： Chromium是一个由Google主导开发的网页浏览器。以BSD许可证等多重自由版权发行并开放源代码。

三. Webview应用开发

页面加载是Web组件的基本功能。根据页面加载数据来源可以分为三种常用场景，包括加载网络页面、加载本地页面、加载HTML格式的富文本数据。页面加载过程中，若涉及网络资源获取，需要配置 ohos.permission.INTERNET网络访问权限。

加载本地页面

在项目中添加两个本地html页面，内容分别为打印 myhtmlWebpage myhtml2Webpage

编写应用加载web组件，默认加载myhtml.html页面，并且提供一个按钮，点击后web组件将加载myhtml2.html页面。代码如下

import common from '@ohos.app.ability.common'
import web_webview from '@ohos.web.webview'
const TAG: string = '[Example].[entry].[EntryAbility.ets]';
@Entry
@Component
struct Index {
  @State message: string = 'Hi~'
  @State webmsg: string = 'click Open html2'
  webviewController: web_webview.WebviewController = new web_webview.WebviewController();
  build() {
    Row() {
      Column() {
        Text(this.webmsg)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            let context = getContext(this) as common.UIAbilityContext;
            try{
            // 点击按钮时，通过loadUrl，跳转到local1.html
            this.webviewController.loadUrl($rawfile("myhtml2.html"));
             } catch (error) {
            console.error(`ErrorCode: ${error.code},  Message: ${error.message}`);
          }
          })
        // 组件创建时，通过$rawfile加载本地文件local.html
        Web({ src: $rawfile("myhtml.html"), controller: this.webviewController })
      }
      .width('100%')
    }
    .height('100%')
  }
}

加载html数据

Web组件可以通过loadData接口实现加载HTML格式的文本数据。当开发者不需要加载整个页面，只需要显示一些页面片段时，可通过此功能来快速加载页面

import common from '@ohos.app.ability.common'
import web_webview from '@ohos.web.webview'
const TAG: string = '[Example].[entry].[EntryAbility.ets]';
@Entry
@Component
struct Index {
  @State message: string = 'Hi~'
  @State webmsg: string = 'click Open html2'
  webviewController: web_webview.WebviewController = new web_webview.WebviewController();
  build() {
    Row() {
      Column() {
        Text(this.webmsg)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            try {
              // 点击按钮时，通过loadData，加载HTML格式的文本数据
              this.webviewController.loadData(
                '<html><body bgcolor=\"white\">HTML Source:<pre>Hello Source</pre></body></html>',
                'text/html',
                'UTF-8'
              );
            } catch (error) {
              console.error(`ErrorCode: ${error.code},  Message: ${error.message}`);
            }
          })
        // 组件创建时，通过$rawfile加载本地文件local.html
        Web({ src: $rawfile("myhtml.html"), controller: this.webviewController })
      }
      .width('100%')
    }
    .height('100%')
  }
}

加载网络资源

开发者可以在Web组件创建的时候指定默认加载的网络页面。在默认页面加载完成后，如果开发者需要变更此Web组件显示的网络页面，可以通过调用loadUrl()接口加载指定网络网页。加载网络页面，需要在应用程序的 module.json5中配置 ohos.permission.INTERNET网络访问权限，如下

    "requestPermissions": [
      {
        "name": "ohos.permission.INTERNET"
      }
    ]

// xxx.ets
import web_webview from '@ohos.web.webview';
@Entry
@Component
struct WebComponent {
  webviewController: web_webview.WebviewController = new web_webview.WebviewController();
  build() {
    Column() {
      Button('loadUrl')
        .onClick(() => {
          try {
            // 点击按钮时，通过loadUrl，跳转到www.example1.com
            this.webviewController.loadUrl('www.example1.com');
          } catch (error) {
            console.error(`ErrorCode: ${error.code},  Message: ${error.message}`);
          }
        })
      // 组件创建时，加载www.example.com
      Web({ src: 'https://developer.harmonyos.com/', controller: this.webviewController})
    }
  }
}

注册JavaScript接口

在讲解webview的安全风险之前，我们再来看一下如何注册JavaScript接口。在Openharmony中的webview提供了 registerJavaScriptProxy，原型如下

registerJavaScriptProxy(object: object, name: string, methodList: Array): void

参数名	类型	必填	说明
object	object	是	参与注册的应用侧JavaScript对象。只能声明方法，不能声明属性。其中方法的参数和返回类型只能为string，number，boolean
name	string	是	注册对象的名称，与window中调用的对象名一致。注册后window对象可以通过此名字访问应用侧JavaScript对象。
methodList	Array	是	参与注册的应用侧JavaScript对象的方法。

函数功能注入JavaScript对象到window对象中，并可以在window对象中调用该对象的方法。示例如下

// xxx.ets
import web_webview from '@ohos.web.webview';
@Entry
@Component
struct WebComponent {
  webviewController: web_webview.WebviewController = new web_webview.WebviewController();
  testObj = {
    getData: () => {
      return "Data From JsInterface getData()";
    }
  }
  build() {
    Column() {
      Button('loadUrl')
        .onClick(() => {
          try {
            // 点击按钮时，通过loadUrl，跳转到www.example1.com
            this.webviewController.loadUrl('www.example1.com');
          } catch (error) {
            console.error(`ErrorCode: ${error.code},  Message: ${error.message}`);
          }
        })
      // 组件创建时，加载https://developer.harmonyos.com/
      Web({ src: $rawfile("myhtml.html"), controller: this.webviewController})
      .javaScriptProxy({
        object: this.testObj,
        name: "objName",
        methodList: ["getData"],
        controller: this.webviewController,
      }
    )
    }
  }
}

其中加载的myhtml.html源码

<!-- myhtml.html -->
<!DOCTYPE html>
<html>
    <meta charset="utf-8">
    <body>
      <button type="button" onclick="htmlTest()">Click Me!</button>
      <p id="demo"></p>
    </body>
    <script type="text/javascript">
    function htmlTest() {
      let str=objName.getData();
      document.getElementById("demo").innerHTML=str;
      console.log('objName.getData result:'+ str)
    }
</script>
</html>

四. Webview开发安全浅析

网络数据明文传输

允许加载http的网络资源，这种情况下非常容易受到中间人攻击。通过中间人攻击就可能导致敏感信息泄露，如果在中间人攻击期间获得凭据，则攻击者可以假设该特定网站的受害者身份。在下图中，可以看到应用加载http网页，其中数据可以明文被截获：

在 FA模型(stage模型暂未找到相关配置)中，我们可以通过在config.json中添加如下配置来禁止应用使用明文流量请求

"deviceConfig": {
    "default": {
      "supportBackup": false,
      "network": {
        "cleartextTraffic": false
      }
    }
}

是否保存密码信息

根据业务需求来决定。使用Web组件的 password(password:boolean)接口，设置是否应保存密码。

SSL错误处理与证书双向认证

SSL的错误处理可能也会引入一些安全问题，如开发者没有获得正确签名的证书而选择忽略证书错误的机制，则可能导致应用容易受到中间人攻击。攻击者借助自制的无效证书通过中间人攻击能够拦截和修改流量。在OpenHarmony中是通过Web组件的接口 onSslErrorReceive中调用event.handler.handleConfirm函数来达到忽略ssl证书的效果，示例如下

// xxx.ets
// https://docs.openharmony.cn/pages/v3.2/zh-cn/application-dev/reference/arkui-ts/ts-basic-components-web.md/#onSslErrorEventReceive9
import web_webview from '@ohos.web.webview'
@Entry
@Component
struct WebComponent {
  controller: web_webview.WebviewController = new web_webview.WebviewController()
  build() {
    Column() {
      Web({ src: 'www.example.com', controller: this.controller })
        .onSslErrorEventReceive((event) => {
          AlertDialog.show({
            title: 'onSslErrorEventReceive',
            message: 'text',
            primaryButton: {
              value: 'confirm',
              action: () => {
                event.handler.handleConfirm()
              }
            },
            secondaryButton: {
              value: 'cancel',
              action: () => {
                event.handler.handleCancel()
              }
            },
            cancel: () => {
              event.handler.handleCancel()
            }
          })
          return true
        })
    }
  }
}

SSL证书双向认证。接口onClientAuthenticationRequest，通知用户收到SSL客户端证书请求事件(https://docs.openharmony.cn/pages/v4.0/zh-cn/application-dev/reference/arkui-ts/ts-basic-components-web.md/#onClientAuthenticationRequest9)

// 未对接证书管理的双向认证
// xxx.ets API9
import web_webview from '@ohos.web.webview'
@Entry
@Component
struct WebComponent {
  controller: web_webview.WebviewController = new web_webview.WebviewController()
  build() {
    Column() {
      Web({ src: 'www.example.com', controller: this.controller })
        .onClientAuthenticationRequest((event) => {
          AlertDialog.show({
            title: 'onClientAuthenticationRequest',
            message: 'text',
            primaryButton: {
              value: 'confirm',
              action: () => {
                event.handler.confirm("/system/etc/user.pk8", "/system/etc/chain-user.pem")
              }
            },
            secondaryButton: {
              value: 'cancel',
              action: () => {
                event.handlqq
                er.cancel()
              }
            },
            cancel: () => {
              event.handler.ignore()
            }
          })
        })
    }
  }
}

// 对接证书管理的双向认证
//// 1. 构造单例对象GlobalContext
// GlobalContext.ts
export class GlobalContext {
  private constructor() {}
  private static instance: GlobalContext;
  private _objects = new Map<string, Object>();
  public static getContext(): GlobalContext {
    if (!GlobalContext.instance) {
      GlobalContext.instance = new GlobalContext();
    }
    return GlobalContext.instance;
  }
  getObject(value: string): Object | undefined {
    return this._objects.get(value);
  }
  setObject(key: string, objectClass: Object): void {
    this._objects.set(key, objectClass);
  }
}
//// 2. 实现双向认证
// xxx.ets API10
import common from '@ohos.app.ability.common';
import Want from '@ohos.app.ability.Want';
import web_webview from '@ohos.web.webview'
import { BusinessError } from '@ohos.base';
import bundleManager from '@ohos.bundle.bundleManager'
import { GlobalContext } from '../GlobalContext'
let uri = "";
export default class CertManagerService {
  private static sInstance: CertManagerService;
  private authUri = "";
  private appUid = "";
  public static getInstance(): CertManagerService {
    if (CertManagerService.sInstance == null) {
      CertManagerService.sInstance = new CertManagerService();
    }
    return CertManagerService.sInstance;
  }
  async grantAppPm(callback: (message: string) => void) {
    let message = '';
    let bundleFlags = bundleManager.BundleFlag.GET_BUNDLE_INFO_DEFAULT | bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION;
    //注：com.example.myapplication需要写实际应用名称
    try {
      bundleManager.getBundleInfoForSelf(bundleFlags).then((data) => {
        console.info('getBundleInfoForSelf successfully. Data: %{public}s', JSON.stringify(data));
        this.appUid = data.appInfo.uid.toString();
      }).catch((err: BusinessError) => {
        console.error('getBundleInfoForSelf failed. Cause: %{public}s', err.message);
      });
    } catch (err) {
      let message = (err as BusinessError).message;
      console.error('getBundleInfoForSelf failed: %{public}s', message);
    }
    //注：需要在MainAbility.ts文件的onCreate函数里添加GlobalContext.getContext().setObject("AbilityContext", this.context)
    let abilityContext = GlobalContext.getContext().getObject("AbilityContext") as common.UIAbilityContext
    await abilityContext.startAbilityForResult(
      {
        bundleName: "com.ohos.certmanager",
        abilityName: "MainAbility",
        uri: "requestAuthorize",
        parameters: {
          appUid: this.appUid, //传入申请应用的appUid
        }
      } as Want)
      .then((data: common.AbilityResult) => {
        if (!data.resultCode && data.want) {
          if (data.want.parameters) {
            this.authUri = data.want.parameters.authUri as string; //授权成功后获取返回的authUri
          }
        }
      })
    message += "after grantAppPm authUri: " + this.authUri;
    uri = this.authUri;
    callback(message)
  }
}
@Entry
@Component
struct WebComponent {
  controller: web_webview.WebviewController = new web_webview.WebviewController();
  @State message: string = 'Hello World' //message主要是调试观察使用
  certManager = CertManagerService.getInstance();
  build() {
    Row() {
      Column() {
        Row() {
          //第一步：需要先进行授权，获取到uri
          Button('GrantApp')
            .onClick(() => {
              this.certManager.grantAppPm((data) => {
                this.message = data;
              });
            })
          //第二步：授权后，双向认证会通过onClientAuthenticationRequest回调将uri传给web进行认证
          Button("ClientCertAuth")
            .onClick(() => {
              this.controller.loadUrl('https://www.example2.com'); //支持双向认证的服务器网站
            })
        }
        Web({ src: 'https://www.example1.com', controller: this.controller })
          .fileAccess(true)
          .javaScriptAccess(true)
          .domStorageAccess(true)
          .onlineImageAccess(true)
        .onClientAuthenticationRequest((event) => {
          AlertDialog.show({
            title: 'ClientAuth',
            message: 'Text',
            confirm: {
              value: 'Confirm',
              action: () => {
                event.handler.confirm(uri);
              }
            },
            cancel: () => {
              event.handler.cancel();
            }
          })
        })
      }
    }
    .width('100%')
    .height('100%')
  }
}

跨域资源访问

web组件提供接口 fileAccess(fileAccess:boolean)，设置是否开启应用中文件系统的访问，默认启用。但笔者目前对openharmony的了解，纯鸿蒙webview似乎不支持跨域的访问操作，如果理解有误还请留言指正。 (https://docs.openharmony.cn/pages/v4.0/zh-cn/application-dev/reference/arkui-ts/ts-basic-components-web.md/#%E5%B1%9E%E6%80%A7)

禁用JavaScript执行

WebViews 默认是允许JavaScript 执行，如果不允许JavaScript脚本执行，可以通过接口 javaScriptAccess(javaScriptAccess:boolean)禁用。

白名单校验

webview应用加载网络资源往往是通过本地白名单的限制加载业务相关的预置资源，应用自身也可能会提供一些敏感功能的接口供网页资源调用，那么白名单的校验也是移动端webview的主要战场之一。白名单校验上往往是编码逻辑上的一些缺陷导致了白名单校验失效而加载了攻击者的恶意页面。我们这里以安卓端两篇经典的文章来思考一下纯鸿蒙下的白名单校验应该怎么去做，一篇是rebeyond的一文彻底搞懂安卓Webview白名单校验，另一篇是hearmen1的BH ASIA议题The Tangled WebView - JavascriptInterface once more。在一些逻辑校验上(比如通过 indexOf() startsWith() endsWith()等方法进行字符串匹配的校验)，安卓和纯鸿蒙并无区别，都是上层代码自实现的检测逻辑，不过本文还是记录下来了，因为并不是所有读者都了解上述两篇文章中的内容。希望通过本文的内容可以让读者更全面的认识纯鸿蒙的白名单攻防：）

indexOf校验

通过indexOf校验纯鸿蒙与安卓并无区别，都是上层代码实现的逻辑判断，示例代码(直接摘用rebeyond前辈原文中的代码：)

    private static boolean checkDomain(String inputUrl)
    {
        String[] whiteList=new String[]{"site1.com","site2.com"};
        for (String whiteDomain:whiteList)
        {
            if (inputUrl.indexOf(whiteDomain)>0)
                return true;
        }
        return  false;
    }

绕过方式 http://www.rebeyond.net/poc.htm?site1.com。继续通过如下逻辑取出url中的host来进行匹配

private static boolean checkDomain(String inputUrl)
{
    String[] whiteList=new String[]{"site1.com","site2.com"};
    String tempStr=inputUrl.replace("://","");
    String inputDomain=tempStr.substring(0,tempStr.indexOf("/")); //提取host
    for (String whiteDomain:whiteList)
    {
        if (inputDomain.indexOf(whiteDomain)>0)
            return true;
    }
    return  false;
}

绕过方式 http://[email protected]/poc.html。如此访问的将还是www.rebeyond.net域名

startsWith() & endsWith()校验

因为子域名往往也在白名单之中，所以一般不用startsWith或者equals比较，下面看个endsWith的例子，同样来自rebeyond的文章中

private static boolean checkDomain(String inputUrl) throws MalformedURLException {
    String[] whiteList=new String[]{"site1.com","site2.com"};
    java.net.URL url=new java.net.URL(inputUrl);
    String inputDomain=url.getHost(); //提取host
    for (String whiteDomain:whiteList)
    {
        if (inputDomain.endsWith(whiteDomain)) //www.site1.com      app.site2.com
            return true;
    }
    return  false;
}

这里有个明显的逻辑错误，就是通过如下的域名即可绕过http://rebeyondsite1.com/poc.htm，这种域名直接注册即可。那么只要在endsWith的时候，在白名单前面加个点，如下

private static boolean checkDomain(String inputUrl) throws MalformedURLException {
    String[] whiteList=new String[]{"site1.com","site2.com"};
    java.net.URL url=new java.net.URL(inputUrl);
    String inputDomain=url.getHost(); //提取host
    for (String whiteDomain:whiteList)
    {
        if (inputDomain.endsWith("."+whiteDomain)) //www.site1.com      app.site2.com
            return true;
    }
    return  false;
}

如此看似是没有问题了。

纯鸿蒙模块@ohos.url获取域名

上述a&b的方式均是在安卓下的测试，使用的是java的代码，那么我们知道纯鸿蒙是不支持java的，那么java中对应的接口java.net.URL在纯鸿蒙中可有类似的实现？答案是肯定的，即@ohos.url，我们写个如下的适用于纯鸿蒙的demo

import Url from '@ohos.url';
export function getWantvalue(key: string, inParam: boolean){
    //url: 'http://192.168.3.126\\@www.site1.com/index.html'
    let url = globalThis.webview_want.parameters[key.toString()];
    let ohurl  = Url.URL.parseURL(url);
    let ohostname = ohurl.hostname;
    let ohost =  ohurl.host;
    let origin = ohurl.origin;
    hilog.info(0x0000, "test", "hostname : %{public}s",ohostname.toString());
    hilog.info(0x0000, "test", "host : %{public}s",ohost.toString());
    hilog.info(0x0000, "test", "origin : %{public}s",origin.toString());
}

那么在安卓侧如下代码获取'http://192.168.3.126\@www.site1.com/index.html'中的域名

    java.net.URL url=new java.net.URL(inputUrl);
    String inputDomain=url.getHost(); //提取host

java.net.URL通过getHost获取的是www.site1.com，但实际上访问的是192.168.3.126的服务器，这样的方式也就绕过了上文b中最后的校验。但是在Openharmony中的实现，我们直接看上述纯鸿蒙的代码运行后打印的日志信息

11-02 15:32:07.623 5917-5917/? I A00000/test: hostname : 192.168.3.126
11-02 15:32:07.623 5917-5917/? I A00000/test: host : 192.168.3.126
11-02 15:32:07.623 5917-5917/? I A00000/test: origin : http://192.168.3.126

可以看到，@ohos.url的Url.URL.parseURL方法获取的域名信息是正确的，所以'http://192.168.3.126\@www.site1.com/index.html'这种方式在纯鸿蒙下无法绕过上文中b的校验。同样的https://www.rebeyond.net\.site1.com也无法绕过@ohos.url的检测。（当然目前java和android.net.Uri均已修复这里的逻辑错误）。

纯鸿蒙模块@ohos.uri校验

纯鸿蒙的@ohos.uri同样可以获取域名信息，我们写个测试demo如下

import Url from '@ohos.url';
export function getWantvalue(key: string, inParam: boolean){
  //url: JavaScript://www.site1.com/%0d%0awindow.location.href='http://192.168.3.126/index.html'
  let url = globalThis.webview_want.parameters[key.toString()];
  let ohuri = new Uri.URI(url);
  hilog.info(0x0000, "test", "urihost : %{public}s",ohuri.host);
  hilog.info(0x0000, "test", "uripath : %{public}s",ohuri.path);
}

打印的日志信息

12-01 19:56:04.759 29152-29152/com.example.mywant I A00000/test: urihost : www.site1.com
12-01 19:56:04.761 29152-29152/com.example.mywant I A00000/test: uripath : /

如此我们通过JavaScript://www.site1.com/%0d%0awindow.location.href='http://192.168.3.126/index.html'这种形势的输入，通过@ohos.uri.host得到了site1的域名，实际上也访问了192.168.3.126的域名，实际上是上述输入中的JavaScript代码中的重定向得以执行的结果。

需要注意的是当我们输入如下的畸形数据时'http://192.168.3.126\@www.site1.com/index.html'，将造成@ohos.uri崩溃，崩溃日志如下

Lifetime: 0.000000s
Js-Engine: ark
page: pages/webview.js
Error message: Syntax Error. Invalid Uri string
Error code: 10200002
Stacktrace:
    at BusinessError (/usr1/hmos_for_system/src/increment/sourcecode/out/generic_generic_arm_64only/hisi_higeneric_newphone_standard/obj/commonlibrary/ets_utils/js_api_module/uri/js_uri.js:6:6)
    at URI (/usr1/hmos_for_system/src/increment/sourcecode/out/generic_generic_arm_64only/hisi_higeneric_newphone_standard/obj/commonlibrary/ets_utils/js_api_module/uri/js_uri.js:19:19)
    at getWantvalue (entry/src/main/ets/entryability/WebviewAbility.ts:53:21)
    at webview (entry/src/main/ets/pages/webview.ets:11:21)
    at func_main_0 (entry/src/main/ets/pages/webview.ets:87:14)

重定向方式绕过与检测

在上文 d中，其实已经通过JavaScript的window.location.href重定向来绕过检测并访问恶意网站了。如下的输入"JavaScript://www.site1.com/%0d%0awindow.location.href='http://192.168.3.126/index.html'"，@ohos.url和@ohos.uri获取的host信息均为www.site1.com，但实际WebView最后会加载192.168.3.126的服务器资源

11-02 15:54:23.486 9591-9591/? I A00000/test: ohos.url hostname : www.site1.com
11-02 15:54:23.486 9591-9591/? I A00000/test: ohos.url host : www.site1.com
11-02 15:54:23.486 9591-9591/? I A00000/test: ohos.uri host : www.site1.com
11-02 15:54:23.486 9591-9591/? I A00000/test: window.location.href='http://192.168.3.126/index.html'

对于上述的重定向，通过校验协议名 http/https并限制JavaScript代码的执行是可以防护的。但是对于如下类型的重定向，比如 http://mp.weixinbridge.com/mp/wapredirect?url=http://192.168.3.126/，即在目标白名单中找到一处任意地址重定向的接口，将继续绕过协议名校验，完成重定向至恶意网站。那么对应的解决方案在安卓中通过重写WebView的shouldOverrideUrlLoading方法，在发起请求前得到一次回调处理的机会，可以检测将请求的url的合法性。同样在 ohos中， onUrlLoadIntercept可以在网页加载前拦截 url, 参数 event.data获取将要加载的 url，如果 url不在白名单范围内，即可在 onUrlLoadIntercept中 returntrue拦截网页加载，反之 returnfalse可以完成网页加载，示例如下

  build() {
    Column() {
      Button('loadUrl')
        .onClick(() => {
          hilog.info(0x0000, "test", this.url2);
          //this.controller.loadUrl(this.url2);
        })
      Web({ src: this.url2, controller: this.controller })
        .onUrlLoadIntercept( event => {
          hilog.info(0x0000, "test", "event => %{public}s",event.data);
          let realurl = this.controller.getUrl();
          let realoriginUrl = this.controller.getOriginalUrl();
          hilog.info(0x0000, "test", "UrlIntercept url: %{public}s",realurl);
          hilog.info(0x0000, "test", "UrlIntercept original url: %{public}s",realoriginUrl);
          if( event.data.toString().startsWith("http://192.168.3.126") )
            return false;
          return true;
      })
    }
  }

纯鸿蒙的webview通过类似http://www.whitesite.com/redirect?url=http://192.168.3.126/redirect.html的重定向，加载的html内容如下

<html>
  <script language="javascript" type="text/javascript"> 
    // 以下方式直接跳转
    window.location.href='http://www.baidu.com';
    // 以下方式定时跳转
    //setTimeout("javascript:location.href='http://www.baidu.com'", 5000); 
  </script>
</html>

输出的日志如下

可以看到每一次的重定向请求均被 onUrlLoadIntercept拦截到，那么在 onUrlLoadIntercept的回调中进行二次的白名单校验将使重定向无处遁形。

JsInterface接口安全分级绕过场景

在rebeyond的文章中提到了JsInterface接口安全分级绕过场景，这里我们同样在Openharmony的场景下进行分析。针对上述的通过 onUrlLoadIntercept修补场景继续展开，如果某 hap对接多个三方公司，针对不同的第三方公司某些敏感的js接口将提供不同安全等级的服务。比如在如下的 HAP中注册接口 getToken，对 192.168.3.126不允许调用 getToken， whitesite.com则可以调用

import web_webview from '@ohos.web.webview'
import { getWantvalue } from '../entryability/WebviewAbility'
import { checkDomain } from '../entryability/WebviewAbility'
import Want from '@ohos.app.ability.Want';
import hilog from '@ohos.hilog';
const TAG: string = '[Example].[entry].[EntryAbility.ets]';
@Entry
@Component
struct webview {
  @State message: string = 'webview page';
  want: Want = globalThis.webview_want;
  url: string = (this.want.parameters['url']).toString();
  url2:string = getWantvalue('url', true)
  requrl:string = null;
  controller: web_webview.WebviewController = new web_webview.WebviewController()
  testObj = {
    getToken: () => {
      if( checkDomain(this.url2, "1") ){
        hilog.info(0x0000, "test", "call into getToken");
      }else{
        hilog.info(0x0000, "test", "not allow call getToken");
      }
    }
  }
  build() {
    Column() {
      Button('loadUrl')
        .onClick(() => {
          hilog.info(0x0000, "test", this.url2);
          //this.controller.loadUrl(this.url2);
        })
      Web({ src: this.url2, controller: this.controller })
        .onUrlLoadIntercept( event => {
          hilog.info(0x0000, "test", "event => %{public}s",event.data);
          this.url2 = event.data.toString();
          let realurl = this.controller.getUrl();
          let realoriginUrl = this.controller.getOriginalUrl();
          if( checkDomain(this.url2,"0") )
            return false;
          return true;
      })
      .javaScriptProxy({
        object: this.testObj,
        name: "objName",
        methodList: ["getToken"],
        controller: this.controller,
      })
    }
  }
}

checkdomain的实现如下

export function checkDomain(url: string, level: string){
  if( !url.startsWith("http://") && !url.startsWith("https://")){
    hilog.info(0x0000, "test", "[checkDomain]: startsWith check failed!");
    return false;
  }
  let whitelist = ['whitesite.com','192.168.3.126'];
  if( level == "1" ) {
    // 高安全级别
    whitelist = ['whitesite.com']
  }
  let uri = null;
  try{
    uri = new Uri.URI(url);
  }catch(Exception ){
    hilog.info(0x0000, "test", "[checkDomain]: Uri.URI Exception！");
    return false;
  }
  let host = uri.host;
  for( let i=0; i<whitelist.length; i++ ){
    if( host.endsWith(whitelist[i]) ) {
      hilog.info(0x0000, "test", "[checkDomain]: endsWith check pass! ");
      return true;
    }
  }
}

web前端安全中一个常用的技术 LoadandOverwriteRaceCondition。当测试 http://192.168.3.126/redirect.html如下

<script> 
window.objName.getToken();
</script>

返回失败

11-06 14:41:36.018 26749-26749/com.example.mywant I A00000/test: event => http://192.168.3.126/redirect.html
11-06 14:41:36.111 26749-26749/com.example.mywant I A00000/test: not allow call getToken

修改 poc内容如下

<script> 
var test = function(){alert(window.objName.getToken());};
setTimeout(test,90);
document.location.href='https://www.whitesite.com';
</script>

getToken返回成功

11-06 15:22:30.797 12200-12200/com.example.mywant I A00000/test: event => http://192.168.3.126/redirect.html
11-06 15:22:30.882 12200-12200/com.example.mywant I A00000/test: event => https://www.whitesite.com/
11-06 15:22:30.972 12200-12200/com.example.mywant I A00000/test: [checkDomain]: endsWith check pass!
11-06 15:22:30.972 12200-12200/com.example.mywant I A00000/test: call into getToken

分析：当请求 http://192.168.3.126/redirect.html时本不应该可以访问 getTokent接口，但是当 document.location.href='https://www.whitesite.com';执行时， onUrlLoadIntercept被调用，此时 url2被赋值为 www.whitesite.com， poc中延时执行了 getToken，由于此时 192.168.3.126的DOM还没销毁，所以执行 getToken成功，如果延时的时间较长，那么dom销毁的情况下， setTimeout设置的延时执行函数也不会再执行。如上也在一种环境下绕过了校验。注意上述的代码中，我们首先使用的使用的是参数 event获取当前拦截的 url，在上述代码中我们还可以看到 this.controller获取 url和 OriginalUrl，那么我们通过修改校验代码如下，看一下这两个

      let url = this.controller.getUrl();
      let originUrl = this.controller.getOriginalUrl();
      hilog.info(0x0000, "test", "UrlIntercept url: %{public}s",url);
      hilog.info(0x0000, "test", "UrlIntercept original url: %{public}s",originUrl);

输出日志如下

12-01 20:54:50.062 3347-3347/com.example.mywant I A00000/test: event => http://192.168.3.126/redirect.html
12-01 20:54:50.065 3347-3347/com.example.mywant I A00000/test: UrlIntercept url: http://192.168.3.126/redirect.html
12-01 20:54:50.065 3347-3347/com.example.mywant I A00000/test: UrlIntercept original url:

如上输出的日志信息，我们可以考虑通过 this.controller.getUrl()来做校验，从而防止 LoadandOverwriteRaceCondition的攻击，说做就做，测试代码如下

import web_webview from '@ohos.web.webview'
import { getWantvalue } from '../entryability/WebviewAbility'
import { checkDomain } from '../entryability/WebviewAbility'
import Want from '@ohos.app.ability.Want';
import hilog from '@ohos.hilog';
const TAG: string = '[Example].[entry].[EntryAbility.ets]';
@Entry
@Component
struct webview {
  @State message: string = 'webview page';
  want: Want = globalThis.webview_want;
  url: string = (this.want.parameters['url']).toString();
  url2:string = getWantvalue('url', true)
  requrl:string = null;
  controller: web_webview.WebviewController = new web_webview.WebviewController()
  testObj = {
    getToken: () => {
      if( checkDomain(this.url2, "1") ){
        hilog.info(0x0000, "test", "call into getToken");
      }else{
        hilog.info(0x0000, "test", "not allow call getToken");
      }
    }
  }
  build() {
    Column() {
      Button('loadUrl')
        .onClick(() => {
          hilog.info(0x0000, "test", this.url2);
          //this.controller.loadUrl(this.url2);
        })
      Web({ src: this.url2, controller: this.controller })
        .onUrlLoadIntercept( event => {
          hilog.info(0x0000, "test", "event => %{public}s",event.data);
          //this.url2 = event.data.toString();
          let this.url2 = this.controller.getUrl();
          hilog.info(0x0000, "test", "UrlIntercept url: %{public}s",this.url2);
          if( checkDomain(this.url2,"0") )
            return false;
          return true;
      })
      .javaScriptProxy({
        object: this.testObj,
        name: "objName",
        methodList: ["getToken"],
        controller: this.controller,
      })
    }
  }
}

checkDomain不做修改，再次执行延时执行的POC

<script> 
var test = function(){alert(window.objName.getToken());};
setTimeout(test,90);
document.location.href='https://www.whitesite.com';
</script>

输出日志如下，可以看到“完美”解决了延时攻击！

12-03 21:52:05.808 21621-21621/com.example.mywant I A00000/test: event => http://192.168.3.126/redirect.html
12-03 21:52:05.808 21621-21621/com.example.mywant I A00000/test: UrlIntercept url: http://192.168.3.126/redirect.html
12-03 21:52:05.808 21621-21621/com.example.mywant I A00000/test: in check!!!
12-03 21:52:05.808 21621-21621/com.example.mywant I A00000/test: CheckDomain host: 192.168.3.126
12-03 21:52:05.852 21621-21621/com.example.mywant I A00000/test: event => https://www.whitesite.com/
12-03 21:52:05.852 21621-21621/com.example.mywant I A00000/test: UrlIntercept url: http://192.168.3.126/redirect.html
12-03 21:52:05.852 21621-21621/com.example.mywant I A00000/test: in check!!!
12-03 21:52:05.852 21621-21621/com.example.mywant I A00000/test: CheckDomain host: 192.168.3.126
12-03 21:52:05.897 21621-21621/com.example.mywant I A00000/test: event => https://www.whitesite.com/cn/?ic_medium=direct&ic_source=surlent
12-03 21:52:05.897 21621-21621/com.example.mywant I A00000/test: UrlIntercept url: http://192.168.3.126/redirect.html
12-03 21:52:05.897 21621-21621/com.example.mywant I A00000/test: in check!!!
12-03 21:52:05.897 21621-21621/com.example.mywant I A00000/test: CheckDomain host: 192.168.3.126
12-03 21:52:05.925 21621-21621/com.example.mywant I A00000/test: in check!!!
12-03 21:52:05.925 21621-21621/com.example.mywant I A00000/test: CheckDomain host: 192.168.3.126
12-03 21:52:05.925 21621-21621/com.example.mywant I A00000/test: not allow getToken

如此我们真的可以防住攻击者绕过白名单校验了吗？不一定，且看下一小节JavascriptInterface once more。

JavascriptInterface once more

这部分的详细前置知识需要读者了解The-Tangled-WebView-JavascriptInterface-Once-More，篇幅有限这里就做一些简述。在chromium中存在两种导航的方式，browser-initiated和render-initiated方式，browser-initiated方式通常来自用户交互行为的导航跳转，对于浏览器而言是可信的，浏览器会在跳转页面未完成加载（uncommitted）的情况下设置pendingentry为导航的url。而在安卓下webview.loadUrl即为封装的browser-initiated方式的导航，理论上这种接口不应给js提供可以触发的方式，如果js可以通过一些方式触发webview.loadUrl加载白名单的链接，那么将打破browser-initiated状态下pendingentry的可信度，且安卓接口webview.getUrl是在browser-initiated状态下获取的pending_entry，那么这里获取到的url数据即不可信的。这里所说的js通过一些方式触发webview.loadUrl加载白名单的链接，即为hearmen1在议题中提出的3种攻击模式：

开发者对外注册了webview.loadUrl方法的js接口；
在webview的如shouldOverrideUrlLoading等回调接口中以直接或间接的方式提供webview.loadUrl的调用，包括但不限于业务逻辑为外部传入的数据为非法的情况下，业务容错调用webview.loadUrl加载白名单作为新的跳转；
deeplink可以通过signleTask模式启动Webview组件；

（详细的攻击方式请参考议题原文）。那么在文章开始处，我们介绍了纯鸿蒙的webview的软件架构，其底层使用的是cef封装的chromium，那么纯鸿蒙的接口webwebview.WebviewController.loadUrl是否也是browser-initiated状态的导航操作？那么我们从代码跟踪的角度看一下webwebview.WebviewController.loadUrl的底层实现，调用栈如下

// /base/web/webview/interfaces/kits/napi/webviewcontroller/napi_webview_controller.cpp
201 DECLARE_NAPI_FUNCTION("loadUrl", NapiWebviewController::LoadUrl), in Init()
2221  napi_value NapiWebviewController::LoadUrlWithHttpHeaders(napi_env env, napi_callback_info info, const std::string& url, const napi_value* argv, WebviewController* webviewController)
// /base/web/webview/interfaces/kits/napi/webviewcontroller/webview_controller.cpp
497 ErrCode WebviewController::LoadUrl(std::string url) //in LoadUrl() function in OHOS::NWeb::WebviewController
506 ErrCode WebviewController::LoadUrl(std::string url, std::map<std::string, std::string> httpHeaders) //in LoadUrl() function in OHOS::NWeb::WebviewController
// /root/Huawei/aMaster/third_party/chromium/patch/0003-ohos-1115.patch
63289 +int NWebDelegate::Load(
            // ...
            browser->GetMainFrame()->LoadHeaderUrl(CefString(url), CefString(extra));
// /root/Huawei/aMaster/third_party/chromium/patch/0003-ohos-1115.patch
16433  +void CefFrameHostImpl::LoadHeaderUrl(const CefString& url,
+                                     const CefString& additionalHttpHeaders) {
+  LoadURLWithExtras(url, content::Referrer(), kPageTransitionExplicit,
+                    additionalHttpHeaders);
+}
--> CefFrameHostImpl::LoadURLWithExtras()
--> CefBrowserHostBase::LoadMainFrameURL()
--> CefBrowserHostBase::Navigate()
--> NavigationControllerImpl::LoadURL()
--> NavigationControllerImpl::LoadURLWithParams()
--> NavigationControllerImpl::NavigateWithoutEntry()
// ...

从代码分析我们可以看到web_webview.WebviewController.loadUrl同样是browser-initiated状态下的操作，那么最后的问题在上一小节f中最后给出的校验代码还能否起到防护的作用？我们按照最直接的攻击模式1的思路来写个测试代码，多注册一个loadUrl的接口给外部

  // 其余校验代码不变
    testObj = {
    getToken: () => {
      //hilog.info(0x0000, "dami", "in getToken");
      if( checkDomain(this.url2, "1") ){
        hilog.info(0x0000, "test", "allow getToken");
      }else{
        hilog.info(0x0000, "test", "not allow getToken");
      }
    },
    myloadurl: (myurl: string)=>{
      this.controller.loadUrl(myurl);
    }
  }

修改一下测试的poc

<script> 
var test = function(){window.objName.getToken();};
// 以下方式直接跳转
setTimeout(test, 70); 
window.objName.myloadurl("https://www.whitesite.com");
</script>

日志输出如下，可以看到在上一小节中的校验方式在某些环境下也还是存在被绕过的可能

12-04 16:39:20.963 4401-4401/com.example.mywant I A00000/test: event => http://192.168.3.126/redirect.html
12-04 16:39:20.963 4401-4401/com.example.mywant I A00000/test: UrlIntercept url: http://192.168.3.126/redirect.html
12-04 16:39:20.963 4401-4401/com.example.mywant I A00000/test: in check!!!
12-04 16:39:20.963 4401-4401/com.example.mywant I A00000/test: CheckDomain host: 192.168.3.126
12-04 16:39:21.063 4401-4401/com.example.mywant I A00000/test: event => https://www.whitesite.com/
12-04 16:39:21.063 4401-4401/com.example.mywant I A00000/test: UrlIntercept url: https://www.whitesite.com/
12-04 16:39:21.063 4401-4401/com.example.mywant I A00000/test: in check!!!
12-04 16:39:21.064 4401-4401/com.example.mywant I A00000/test: CheckDomain host: www.whitesite.com
12-04 16:39:21.146 4401-4401/com.example.mywant I A00000/test: in check!!!
12-04 16:39:21.146 4401-4401/com.example.mywant I A00000/test: CheckDomain host: www.whitesite.com
12-04 16:39:21.146 4401-4401/com.example.mywant I A00000/test: allow getToken

这类问题主要原因是开发者对chromium的一些机制和开发的规范理解不到位，导致的可信边界被打破，所以这类问题的修改站在开发者的角度来说，可以根据议题中的3种攻击模式开展防御思路：

不对外暴露webview的loadUrl能力，或者js可触发的路径；
避免在onUrlLoadIntercept等接口中调用webview的loadUrl能力；
关注deeplink中调用了webview的loadUrl，且相应Ability的LaunchType/LaunchMode为SINGLETON；
（以现在纯鸿蒙的迭代速度，说不准下个版本会有规避方案呢；）

五. 小结

在这篇文章中我们介绍了纯鸿蒙相关的webview应用的开发以及安全相关配置与编码，以及在移动端涉及较多的白名单校验的问题。相信通过这篇文章可以让纯鸿蒙应用的开发人员写出更加安全的代码。感谢rebeyond和hearmen1前辈们的研究工作，最后补充一句，作者水平有限，如有错误或者未考虑到的情况请留言或私信指正 ; )

文章来源: https://mp.weixin.qq.com/s?__biz=Mzg2MDY2ODc5MA==&mid=2247483813&idx=1&sn=a233c8c228e5f520124ab056aebf437a&chksm=ce2397bcf9541eaaf652b757834ba3b046cd77798a79c1455626f53af33f264d62536dbd2d55&scene=58&subscene=0#rd
如有侵权请联系:admin#unsafe.sh