鸿蒙 APP 开发：安全加固与组件化架构

鸿蒙 APP 开发：安全加固与组件化架构 | 极客日志

import crypto from '@ohos.crypto';

export class EncryptionUtil {
  private static instance: EncryptionUtil | null = null;
  private key: Uint8Array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
  private iv: Uint8Array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);

  static getInstance(): EncryptionUtil {
    if (!EncryptionUtil.instance) {
      EncryptionUtil.instance = new EncryptionUtil();
    }
    return EncryptionUtil.instance;
  }

  async aesEncrypt(data: string): Promise<string> {
    const cipher = crypto.createCipher('aes-128-cbc', this.key, this.iv);
    const encryptedData = cipher.update(data, 'utf8', 'base64') + cipher.final('base64');
    return encryptedData;
  }

  async aesDecrypt(encryptedData: string): Promise<string> {
    const decipher = crypto.createDecipher('aes-128-cbc', this.key, this.iv);
    const decryptedData = decipher.update(encryptedData, 'base64', 'utf8') + decipher.final('utf8');
    return decryptedData;
  }

  async md5Encrypt(data: string): Promise<string> {
    const md5 = crypto.createHash('md5');
    md5.update(data);
    const encryptedData = md5.digest('hex');
    return encryptedData;
  }

  async sha256Encrypt(data: string): Promise<string> {
    const sha256 = crypto.createHash('sha256');
    sha256.update(data);
    const encryptedData = sha256.digest('hex');
    return encryptedData;
  }
}

import { EncryptionUtil } from '../utils/EncryptionUtil';

export class UserService {
  async register(username: string, password: string): Promise<boolean> {
    const encryptedPassword = await EncryptionUtil.getInstance().aesEncrypt(password);
    const user = { id: Date.now(), username, password: encryptedPassword };
    await this.saveUser(user);
    return true;
  }

  async login(username: string, password: string): Promise<boolean> {
    const user = await this.getUserByUsername(username);
    if (!user) return false;
    const decryptedPassword = await EncryptionUtil.getInstance().aesDecrypt(user.password);
    if (decryptedPassword !== password) return false;
    AppStorage.SetOrCreate('isLoggedIn', true);
    AppStorage.SetOrCreate('currentUser', user);
    return true;
  }

  async getCurrentUser(): Promise<UserModel | null> {
    const isLoggedIn = AppStorage.Get('isLoggedIn');
    if (!isLoggedIn) return null;
    return AppStorage.Get('currentUser');
  }

  async logout(): Promise<void> {
    AppStorage.SetOrCreate('isLoggedIn', false);
    AppStorage.SetOrCreate('currentUser', null);
  }
}

{
  "app": {
    "signingConfigs": [],
    "products": [
      {
        "name": "default",
        "signingConfig": "default",
        "compatibleSdkVersion": "3.2.100(5)",
        "runtimeOS": "HarmonyOS",
        "compilerOptions": {
          "obfuscation": true
        }
      }
    ]
  }
}

import abilityAccessCtrl from '@ohos.abilityAccessCtrl';
import { UIAbilityContext } from '@ohos.abilityAccessCtrl';

export class PermissionUtil {
  private static instance: PermissionUtil | null = null;
  private atManager: abilityAccessCtrl.AtManager | null = null;

  static getInstance(): PermissionUtil {
    if (!PermissionUtil.instance) {
      PermissionUtil.instance = new PermissionUtil();
    }
    return PermissionUtil.instance;
  }

  async init(context: UIAbilityContext): Promise<void> {
    if (!this.atManager) {
      this.atManager = abilityAccessCtrl.createAtManager(context);
    }
  }

  async checkPermission(permission: string): Promise<boolean> {
    if (!this.atManager) return false;
    const result = await this.atManager.checkPermission(permission);
    return result === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
  }

  async requestPermission(permission: string): Promise<boolean> {
    if (!this.atManager) return false;
    const result = await this.atManager.requestPermissions([permission]);
    return result[0].grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
  }

  async getAllPermissions(): Promise<Array<string>> {
    if (!this.atManager) return [];
    const result = await this.atManager.getPermissions();
    return result;
  }
}

import { PermissionUtil } from '../utils/PermissionUtil';

export default class EntryAbility extends UIAbility {
  onWindowStageCreate(windowStage: window.WindowStage): void {
    PermissionUtil.getInstance().init(this.context);
    this.checkAndRequestPermissions();
    windowStage.loadContent('pages/Index', (err, data) => {
      if (err.code) {
        hilog.error(0x0000, 'EntryAbility', 'Failed to load content. Cause: %{public}s', JSON.stringify(err) ?? '');
        return;
      }
      hilog.info(0x0000, 'EntryAbility', 'Succeeded in loading content. Data: %{public}s', JSON.stringify(data) ?? '');
    });
  }

  async checkAndRequestPermissions(): Promise<void> {
    const permissions = [
      'ohos.permission.DISTRIBUTED_DATASYNC',
      'ohos.permission.DISTRIBUTED_COMMUNICATION',
      'ohos.permission.GET_NETWORK_INFO',
      'ohos.permission.READ_EXTERNAL_STORAGE',
      'ohos.permission.WRITE_EXTERNAL_STORAGE'
    ];
    for (const permission of permissions) {
      const isGranted = await PermissionUtil.getInstance().checkPermission(permission);
      if (!isGranted) {
        const result = await PermissionUtil.getInstance().requestPermission(permission);
        if (!result) {
          hilog.error(0x0000, 'EntryAbility', 'Failed to request permission: %{public}s', permission);
        }
      }
    }
  }
}

import { UserService } from '../services/UserService';
import { LoginPage } from '../pages/LoginPage';
import { RegisterPage } from '../pages/RegisterPage';

export class UserModule {
  static LoginPage(): any { return LoginPage; }
  static RegisterPage(): any { return RegisterPage; }
  static UserService(): any { return UserService; }
}

import { ProductService } from '../services/ProductService';
import { ProductListPage } from '../pages/ProductListPage';
import { ProductDetailPage } from '../pages/ProductDetailPage';

export class ProductModule {
  static ProductListPage(): any { return ProductListPage; }
  static ProductDetailPage(): any { return ProductDetailPage; }
  static ProductService(): any { return ProductService; }
}

import { CartService } from '../services/CartService';
import { CartPage } from '../pages/CartPage';

export class CartModule {
  static CartPage(): any { return CartPage; }
  static CartService(): any { return CartService; }
}

@Component
export struct ButtonComponent {
  @Prop text: string = '';
  @Prop onClick: () => void = () => {};
  @Prop disabled: boolean = false;

  build() {
    Button(this.text)
      .width('100%')
      .height(48)
      .fontSize(16)
      .fontWeight(FontWeight.Bold)
      .backgroundColor(this.disabled ? '#CCCCCC' : '#007DFF')
      .onClick(this.onClick)
      .enabled(!this.disabled);
  }
}

@Component
export struct InputComponent {
  @Prop placeholder: string = '';
  @Prop value: string = '';
  @Prop onChange: (value: string) => void = () => {};
  @Prop type: InputType = InputType.Normal;

  build() {
    TextInput({ text: this.value, placeholder: this.placeholder })
      .width('100%')
      .height(48)
      .fontSize(16)
      .backgroundColor('#F5F5F5')
      .borderRadius(8)
      .padding({ left: 16, right: 16 })
      .type(this.type)
      .onChange(this.onChange);
  }
}

@Component
export struct ListComponent {
  @Prop data: Array<any> = [];
  @Prop renderItem: (item: any, index: number) => void = () => {};
  @Prop onItemClick: (item: any, index: number) => void = () => {};

  build() {
    List({ space: 16 }) {
      ForEach(this.data, (item: any, index: number) => {
        ListItem() {
          this.renderItem(item, index);
        }
        .width('100%')
        .height('auto')
        .onClick(() => {
          this.onItemClick(item, index);
        });
      }, (item: any) => item.id);
    }
    .width('100%')
    .height('100%')
    .padding(16);
  }
}

import { ListComponent } from '../components/ListComponent';
import { CartModule } from '../modules/CartModule/CartModule';

@Entry
@Component
struct ProductDetailPage {
  @State product: ProductModel = {
    id: 1,
    name: 'iPhone 15',
    description: '最新款 iPhone',
    price: 5999,
    imageUrl: 'https://example.com/iphone15.jpg',
    category: '手机',
    stock: 100
  };
  @State cartItems: Array<CartItemModel> = [];

  build() {
    Column({ space: 16 }) {
      Image(this.product.imageUrl)
        .width('100%')
        .height(200)
        .objectFit(ImageFit.Cover)
        .borderRadius(12);
      Text(this.product.name).fontSize(20).fontWeight(FontWeight.Bold).textColor('#000000');
      Text(this.product.description).fontSize(16).textColor('#666666');
      Text(`¥${this.product.price}`).fontSize(24).fontWeight(FontWeight.Bold).textColor('#FF0000');
      
      ListComponent({
        data: this.cartItems,
        renderItem: (item: CartItemModel, index: number) => {
          Row({ space: 16 }) {
            Image(item.imageUrl).width(60).height(60).objectFit(ImageFit.Contain);
            Column({ space: 8 }) {
              Text(item.name).fontSize(14).fontWeight(FontWeight.Bold).textColor('#000000');
              Text(`¥${item.price}`).fontSize(16).fontWeight(FontWeight.Bold).textColor('#FF0000');
            }.layoutWeight(1);
            Text(`${item.count}`).fontSize(14).textColor('#000000');
          }
          .width('100%')
          .height('auto')
          .padding(16)
          .backgroundColor('#FFFFFF')
          .borderRadius(12);
        },
        onItemClick: (item: CartItemModel, index: number) => {
          CartModule.CartService().deleteCartItem(item.id);
        }
      });

      ButtonComponent({
        text: '添加到购物车',
        onClick: async () => {
          await CartModule.CartService().addToCart(this.product.id, 1);
          this.cartItems = await CartModule.CartService().getCartItems();
        },
        disabled: false
      });
    }
    .width('100%')
    .height('100%')
    .padding(16)
    .backgroundColor('#F5F5F5');
  }

  aboutToAppear() {
    this.getCartItems();
  }

  async getCartItems(): Promise<void> {
    this.cartItems = await CartModule.CartService().getCartItems();
  }
}

鸿蒙 APP 开发：安全加固与组件化架构

鸿蒙 APP 开发：安全加固与组件化架构

概述

一、安全加固基础

1.1 安全加固定义

1.2 安全加固架构

二、安全加固实战

2.1 实战目标

2.2 数据加密实现

1. 数据加密工具类

2. 数据加密应用

2.3 代码混淆实现

2.4 权限控制实现

1. 权限控制工具类

2. 权限控制应用

三、组件化架构实战

3.1 实战目标

3.2 项目结构调整

3.3 模块化组件实现

1. 用户模块

2. 商品模块

3. 购物车模块

3.4 通用组件实现

1. 通用按钮组件

2. 通用输入框组件

3. 通用列表组件

3.5 组件通信实现

1. 父子组件通信

四、部署与验证

4.1 配置文件修改

4.2 项目部署

五、总结

更多推荐文章

相关免费在线工具

鸿蒙 APP 开发：安全加固与组件化架构

鸿蒙 APP 开发：安全加固与组件化架构

概述

一、安全加固基础

1.1 安全加固定义

1.2 安全加固架构

二、安全加固实战

2.1 实战目标

2.2 数据加密实现

1. 数据加密工具类

2. 数据加密应用

2.3 代码混淆实现

2.4 权限控制实现

1. 权限控制工具类

2. 权限控制应用

三、组件化架构实战

3.1 实战目标

3.2 项目结构调整

3.3 模块化组件实现

1. 用户模块

2. 商品模块

3. 购物车模块

3.4 通用组件实现

1. 通用按钮组件

2. 通用输入框组件

3. 通用列表组件

3.5 组件通信实现

1. 父子组件通信

四、部署与验证

4.1 配置文件修改

4.2 项目部署

五、总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具