鸿蒙系统开发【加解密】安全

于 2024-08-02 16:29:43 发布
阅读量336 收藏 3
点赞数 4
分类专栏： 鸿蒙 文章标签： harmonyos 安全 华为 鸿蒙开发 鸿蒙 openharmony 加解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76813281/article/details/140873941
版权

加解密

介绍

本示例使用cryptoFramework接口的Cipher对象相关方法实现了字符串加解密算法，包括RSA加密算法与AES加密算法。

RSA加密算法：RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，由已知加密密钥推导出解密密钥在计算上是不可行的密码体制。

AES加密算法：AES密码学中的高级加密标准，又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。

效果预览

1

使用说明

1.点击主页面的加密按钮，在加密界面中点击Encryption Algorithm下拉选择加密算法，在输入框中输入待加密的内容，点击加密 按钮，下方文本框中显示加密后内容。

2.点击重置按钮，清除文本框中内容。

3.点击主页面的解密按钮，在解密界面中点击Decrypt Algorithm下拉选择解密算法，在输入框中输入待解密的内容，点击解密 按钮，下方文本框中显示解密后内容。

4.点击重置按钮，清除文本框中内容。

具体实现

  • 本示例分成加密与解密两个模块

    • 加密模块

      • 使用到rsaEncrypt(RSA算法加密)与aesEncrypt(AES算法加密)两种加密方法进行加密操作。
      • 源码：[Encrypt.ets]
/*
 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { promptAction } from '@kit.ArkUI';
import { CipherModel } from '../model/CipherModel';
import Logger from '../model/Logger';

const TAG: string = '[Encrypt]';

@Component
export struct Encrypt {
  @State info: string = '';
  @State message: string = '';
  @State algorithmType: string = 'Encrypt Algorithm';
  private cipherModel: CipherModel = new CipherModel();

  build() {
    Stack({ alignContent: Alignment.Center }) {
      Column() {
        Select([{ value: 'RSA' },
          { value: 'AES' }])
          .id('encryptAlgorithm')
          .margin(4)
          .selected(0)
          .value(this.algorithmType)
          .font({ size: 20, weight: 300, family: 'serif', style: FontStyle.Normal })
          .optionFont({ size: 16, weight: 280, family: 'serif', style: FontStyle.Normal })
          .selectedOptionFont({ size: 16, weight: 280, family: 'serif', style: FontStyle.Normal })
          .onSelect((index: number, value: string) => {
            this.algorithmType = value;
            Logger.info(TAG, `Select: ${index} value: ${value}`);
          })

        TextArea()
          .margin(4)
          .width('60%')
          .id('encryptInput')
          .onChange((value: string) => {
            this.message = value;
          })

        Row() {
          Button($r('app.string.encrypt'))
            .margin(10)
            .fontSize(20)
            .width('30%')
            .height('6%')
            .id('encryptionBtn')
            .onClick(() => {
              if (this.message === '') {
                promptAction.showToast({
                  message: 'This message is null.'
                })
              } else {
                if (this.algorithmType === 'RSA') {
                  this.cipherModel.rsaEncrypt(this.message, (result: string) => {
                    Logger.info(TAG, `this result = ${JSON.stringify(result)}`);
                    this.info = `Encryption result is :  ${result}`;
                  })
                } else {
                  this.cipherModel.aesEncrypt(this.message, (result: string) => {
                    Logger.info(TAG, `this result = ${JSON.stringify(result)}`);
                    this.info = `Encryption result is :  ${result}`;
                  })
                }
              }
            })

          Button($r('app.string.reset'))
            .margin(10)
            .fontSize(20)
            .width('30%')
            .height('6%')
            .id('encryptionResetBtn')
            .onClick(() => {
              this.info = '';
            })
        }
        .margin(10)

        Text(this.info)
          .id('encryptionInfo')
          .fontSize(18)
          .width('85%')
          .height('25%')
          .border({ width: 2, color: Color.Black })
          .margin(10)
          .copyOption(CopyOptions.InApp)
      }
    }
    .width('100%')
    .height('100%')
  }
}
  • 源码[CipherModel.ts]
/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { cryptoFramework } from "@kit.CryptoArchitectureKit";
import { buffer, util } from '@kit.ArkTS';
import Logger from './Logger';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG: string = '[CipherModel]'
const AES_ENCRYPT_KEY: string = '5QXzAbJj0TJN9OQNvxFhhw==';
const RSA_ENCRYPT_KEY: string =
  'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALXJZEloyLbBB6UbUQzUtM3WGTkcd4dn4HgCxL5wHcdICoLbv6EiUjcaQq8c906hqv6/J7Bv9Owj59XMauKweJUCAwEAAQ==';
const RSA_DECRYPT_KEY: string =
  'MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAtclkSWjItsEHpRtRDNS0zdYZORx3h2fgeALEvnAdx0gKgtu/oSJSNxpCrxz3TqGq/r8nsG/07CPn1cxq4rB4lQIDAQABAkA3boG2IM2TbKj4H6xHTVUUrwRh9dw83eAEuFNl/qoV6c4zRUAx+efZ29rDz6CVWuAhxaVBDUOmOHvyxOL8m8IBAiEA3EcTP1jngtiJ8lffvIVbehM6p7437+9UScKMXZSy/PkCIQDTRFj00GbAW9oKqEWTrUCWNxNFCSR82Mlw1sZvQh5LfQIgBApBrh3BUUMLdKhr8Bc6EEkeAEma2Qm4sAmjbWv2xHECIF81ux1BWj0wZ9hLs2d1Odk4ot+G2kHFdSr8L9tuIbcFAiEA2rEXmzyQTxZM1N4QDkaLJiCwSfMTYu48DxfUcevbfhA=';
const RSA512_PRIMES_2: string = 'RSA512|PRIMES_2';
const RSA512_PKCS1: string = 'RSA512|PKCS1';
const AES128: string = 'AES128';
const AES128_PKCS7: string = 'AES128|PKCS7';

export class CipherModel {
  stringToUint8Array(str) {
    return new Uint8Array(buffer.from(str, 'utf-8').buffer);
  }

  uint8ArrayToString(array: Uint8Array) {
    let out: string = '';
    let index: number = 0;
    let len: number = array.length;
    while (index < len) {
      let character = array[index++];
      switch (character >> 4) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
        case 7:
          out += String.fromCharCode(character);
          break;
        case 12:
        case 13:
          out += String.fromCharCode(((character & 0x1F) << 6) | (array[index++] & 0x3F));
          break;
        case 14:
          out += String.fromCharCode(((character & 0x0F) << 12) | ((array[index++] & 0x3F) << 6) |
            ((array[index++] & 0x3F) << 0));
          break;
        default:
          break;
      }
    }
    return out;
  }

  rsaEncrypt(message: string, callback) {
    let rsaGenerator = cryptoFramework.createAsyKeyGenerator(RSA512_PRIMES_2);
    let cipher = cryptoFramework.createCipher(RSA512_PKCS1);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(RSA_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    rsaGenerator.convertKey(pubKeyBlob, null, (err, keyPair) => {
      if (err) {
        Logger.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPair.pubKey, null, (err, data) => {
        let input: cryptoFramework.DataBlob = { data: this.stringToUint8Array(message) };
        cipher.doFinal(input, (err, data) => {
          Logger.info(TAG, "EncryptOutPut is " + data.data);
          let result = that.encodeToStringSync(data.data)
          Logger.info(TAG, "result is " + result);
          callback(result)
        })
      })
    })
  }

  rsaDecrypt(message: string, callback) {
    let rsaGenerator = cryptoFramework.createAsyKeyGenerator(RSA512_PRIMES_2);
    let cipher = cryptoFramework.createCipher(RSA512_PKCS1);
    let that = new util.Base64Helper();
    let priKey = that.decodeSync(RSA_DECRYPT_KEY);
    let priKeyBlob: cryptoFramework.DataBlob = { data: priKey };
    rsaGenerator.convertKey(null, priKeyBlob, (err, keyPair) => {
      if (err) {
        Logger.error(TAG, "convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, keyPair.priKey, null, (err, data) => {
        try {
          let newMessage = that.decodeSync(message);
          let input: cryptoFramework.DataBlob = { data: newMessage };
          cipher.doFinal(input, (err, data) => {
            if (err) {
              Logger.error(TAG, "cipher doFinal." + (err as BusinessError).code);
              return;
            }
            Logger.info(TAG, "DecryptOutPut is " + data.data);
            let result = this.uint8ArrayToString(data.data);
            Logger.info(TAG, "result is " + result);
            callback(result)
          })
        } catch (err) {
          Logger.info(TAG, "cipher init error: " + (err as BusinessError).code);
          return err;
        }
      })
    })
  }

  aesEncrypt(message: string, callback) {
    let aesGenerator = cryptoFramework.createSymKeyGenerator(AES128);
    let cipher = cryptoFramework.createCipher(AES128_PKCS7);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(AES_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    aesGenerator.convertKey(pubKeyBlob, (err, symKey) => {
      if (err) {
        console.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null, (err, data) => {
        let input: cryptoFramework.DataBlob = { data: this.stringToUint8Array(message) };
        cipher.doFinal(input, (err, data) => {
          Logger.info(TAG, "EncryptOutPut is " + data.data);
          let result = that.encodeToStringSync(data.data)
          Logger.info(TAG, "result is " + result);
          callback(result)
        })
      })
    })
  }

  aesDecrypt(message: string, callback) {
    let aesGenerator = cryptoFramework.createSymKeyGenerator(AES128);
    let cipher = cryptoFramework.createCipher(AES128_PKCS7);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(AES_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    aesGenerator.convertKey(pubKeyBlob, (err, symKey) => {
      if (err) {
        console.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null, (err, data) => {
        try {
          let newMessage = that.decodeSync(message);
          let input: cryptoFramework.DataBlob = { data: newMessage };
          cipher.doFinal(input, (err, data) => {
            if (err) {
              Logger.error(TAG, "cipher doFinal." + (err as BusinessError).code);
              return;
            }
            Logger.info(TAG, "DecryptOutPut is " + data?.data);
            let result = this.uint8ArrayToString(data?.data)
            Logger.info(TAG, "result is " + result);
            callback(result)
          })
        } catch (err) {
          Logger.info(TAG, "cipher init error: " + (err as BusinessError).code);
          return err;
        }
      })
    })
  }
}

  • 接口参考：@ohos.security.cryptoFramework，@ohos.promptAction，@ohos.router

  • 解密模块

  • 使用到rsaDecrypt(RSA算法解密)与aesDecrypt(AES算法解密)两种解密方法进行解密操作。

  • 源码：[Decrypt.ets]

/*
 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { promptAction } from '@kit.ArkUI';
import { CipherModel } from '../model/CipherModel';
import Logger from '../model/Logger';

const TAG: string = '[Decrypt]';

@Component
export struct Decrypt {
  @State info: string = '';
  @State message: string = '';
  @State algorithmType: string = 'Decrypt Algorithm';
  private cipherModel: CipherModel = new CipherModel();

  build() {
    Stack({ alignContent: Alignment.Center }) {
      Column() {
        Select([{ value: 'RSA' },
          { value: 'AES' }])
          .id('decryptAlgorithm')
          .margin(4)
          .selected(0)
          .value(this.algorithmType)
          .font({ size: 20, weight: 300, family: 'serif', style: FontStyle.Normal })
          .selectedOptionFont({ size: 16, weight: 280, family: 'serif', style: FontStyle.Normal })
          .optionFont({ size: 16, weight: 280, family: 'serif', style: FontStyle.Normal })
          .onSelect((index: number, value: string) => {
            this.algorithmType = value;
            Logger.info(TAG, `Select: ${index} value: ${value}`);
          })

        TextArea()
          .id('decryptInput')
          .margin(6)
          .width('60%')
          .onChange((value: string) => {
            this.message = value;
          })

        Row() {
          Button($r('app.string.decrypt'))
            .fontSize(20)
            .margin(10)
            .width('30%')
            .height('6%')
            .id('decryptBtn')
            .onClick(() => {
              if (this.message === '') {
                promptAction.showToast({
                  message: 'This message is null.'
                })
              } else {
                if (this.algorithmType === 'RSA') {
                  this.cipherModel.rsaDecrypt(this.message, (result: string) => {
                    Logger.info(TAG, `this result = ${JSON.stringify(result)}`);
                    this.info = `Decrypt result is :  ${result}`;
                  })
                } else {
                  this.cipherModel.aesDecrypt(this.message, (result: string) => {
                    Logger.info(TAG, `this result = ${JSON.stringify(result)}`);
                    this.info = `Decrypt result is :  ${result}`;
                  })
                }
              }
            })

          Button($r('app.string.reset'))
            .fontSize(20)
            .margin(10)
            .width('30%')
            .height('6%')
            .id('decryptResetBtn')
            .onClick(() => {
              this.info = '';
            })
        }
        .margin(10)

        Text(this.info)
          .id('decryptInfo')
          .fontSize(18)
          .width('85%')
          .height('25%')
          .border({ width: 2, color: Color.Black })
          .margin(10)
      }
    }
    .width('100%')
    .height('100%')
  }
}

源码[CipherModel.ts]

/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { cryptoFramework } from "@kit.CryptoArchitectureKit";
import { buffer, util } from '@kit.ArkTS';
import Logger from './Logger';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG: string = '[CipherModel]'
const AES_ENCRYPT_KEY: string = '5QXzAbJj0TJN9OQNvxFhhw==';
const RSA_ENCRYPT_KEY: string =
  'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALXJZEloyLbBB6UbUQzUtM3WGTkcd4dn4HgCxL5wHcdICoLbv6EiUjcaQq8c906hqv6/J7Bv9Owj59XMauKweJUCAwEAAQ==';
const RSA_DECRYPT_KEY: string =
  'MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAtclkSWjItsEHpRtRDNS0zdYZORx3h2fgeALEvnAdx0gKgtu/oSJSNxpCrxz3TqGq/r8nsG/07CPn1cxq4rB4lQIDAQABAkA3boG2IM2TbKj4H6xHTVUUrwRh9dw83eAEuFNl/qoV6c4zRUAx+efZ29rDz6CVWuAhxaVBDUOmOHvyxOL8m8IBAiEA3EcTP1jngtiJ8lffvIVbehM6p7437+9UScKMXZSy/PkCIQDTRFj00GbAW9oKqEWTrUCWNxNFCSR82Mlw1sZvQh5LfQIgBApBrh3BUUMLdKhr8Bc6EEkeAEma2Qm4sAmjbWv2xHECIF81ux1BWj0wZ9hLs2d1Odk4ot+G2kHFdSr8L9tuIbcFAiEA2rEXmzyQTxZM1N4QDkaLJiCwSfMTYu48DxfUcevbfhA=';
const RSA512_PRIMES_2: string = 'RSA512|PRIMES_2';
const RSA512_PKCS1: string = 'RSA512|PKCS1';
const AES128: string = 'AES128';
const AES128_PKCS7: string = 'AES128|PKCS7';

export class CipherModel {
  stringToUint8Array(str) {
    return new Uint8Array(buffer.from(str, 'utf-8').buffer);
  }

  uint8ArrayToString(array: Uint8Array) {
    let out: string = '';
    let index: number = 0;
    let len: number = array.length;
    while (index < len) {
      let character = array[index++];
      switch (character >> 4) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
        case 7:
          out += String.fromCharCode(character);
          break;
        case 12:
        case 13:
          out += String.fromCharCode(((character & 0x1F) << 6) | (array[index++] & 0x3F));
          break;
        case 14:
          out += String.fromCharCode(((character & 0x0F) << 12) | ((array[index++] & 0x3F) << 6) |
            ((array[index++] & 0x3F) << 0));
          break;
        default:
          break;
      }
    }
    return out;
  }

  rsaEncrypt(message: string, callback) {
    let rsaGenerator = cryptoFramework.createAsyKeyGenerator(RSA512_PRIMES_2);
    let cipher = cryptoFramework.createCipher(RSA512_PKCS1);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(RSA_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    rsaGenerator.convertKey(pubKeyBlob, null, (err, keyPair) => {
      if (err) {
        Logger.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, keyPair.pubKey, null, (err, data) => {
        let input: cryptoFramework.DataBlob = { data: this.stringToUint8Array(message) };
        cipher.doFinal(input, (err, data) => {
          Logger.info(TAG, "EncryptOutPut is " + data.data);
          let result = that.encodeToStringSync(data.data)
          Logger.info(TAG, "result is " + result);
          callback(result)
        })
      })
    })
  }

  rsaDecrypt(message: string, callback) {
    let rsaGenerator = cryptoFramework.createAsyKeyGenerator(RSA512_PRIMES_2);
    let cipher = cryptoFramework.createCipher(RSA512_PKCS1);
    let that = new util.Base64Helper();
    let priKey = that.decodeSync(RSA_DECRYPT_KEY);
    let priKeyBlob: cryptoFramework.DataBlob = { data: priKey };
    rsaGenerator.convertKey(null, priKeyBlob, (err, keyPair) => {
      if (err) {
        Logger.error(TAG, "convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, keyPair.priKey, null, (err, data) => {
        try {
          let newMessage = that.decodeSync(message);
          let input: cryptoFramework.DataBlob = { data: newMessage };
          cipher.doFinal(input, (err, data) => {
            if (err) {
              Logger.error(TAG, "cipher doFinal." + (err as BusinessError).code);
              return;
            }
            Logger.info(TAG, "DecryptOutPut is " + data.data);
            let result = this.uint8ArrayToString(data.data);
            Logger.info(TAG, "result is " + result);
            callback(result)
          })
        } catch (err) {
          Logger.info(TAG, "cipher init error: " + (err as BusinessError).code);
          return err;
        }
      })
    })
  }

  aesEncrypt(message: string, callback) {
    let aesGenerator = cryptoFramework.createSymKeyGenerator(AES128);
    let cipher = cryptoFramework.createCipher(AES128_PKCS7);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(AES_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    aesGenerator.convertKey(pubKeyBlob, (err, symKey) => {
      if (err) {
        console.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, symKey, null, (err, data) => {
        let input: cryptoFramework.DataBlob = { data: this.stringToUint8Array(message) };
        cipher.doFinal(input, (err, data) => {
          Logger.info(TAG, "EncryptOutPut is " + data.data);
          let result = that.encodeToStringSync(data.data)
          Logger.info(TAG, "result is " + result);
          callback(result)
        })
      })
    })
  }

  aesDecrypt(message: string, callback) {
    let aesGenerator = cryptoFramework.createSymKeyGenerator(AES128);
    let cipher = cryptoFramework.createCipher(AES128_PKCS7);
    let that = new util.Base64Helper();
    let pubKey = that.decodeSync(AES_ENCRYPT_KEY);
    let pubKeyBlob: cryptoFramework.DataBlob = { data: pubKey };
    aesGenerator.convertKey(pubKeyBlob, (err, symKey) => {
      if (err) {
        console.error("convertKey: error." + (err as BusinessError).code);
        return;
      }
      cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, symKey, null, (err, data) => {
        try {
          let newMessage = that.decodeSync(message);
          let input: cryptoFramework.DataBlob = { data: newMessage };
          cipher.doFinal(input, (err, data) => {
            if (err) {
              Logger.error(TAG, "cipher doFinal." + (err as BusinessError).code);
              return;
            }
            Logger.info(TAG, "DecryptOutPut is " + data?.data);
            let result = this.uint8ArrayToString(data?.data)
            Logger.info(TAG, "result is " + result);
            callback(result)
          })
        } catch (err) {
          Logger.info(TAG, "cipher init error: " + (err as BusinessError).code);
          return err;
        }
      })
    })
  }
}
  • 接口参考：@ohos.security.cryptoFramework，@ohos.promptAction，@ohos.router

以上就是本篇文章所带来的鸿蒙开发中一小部分技术讲解；想要学习完整的鸿蒙全栈技术。可以在结尾找我可全部拿到！
下面是鸿蒙的完整学习路线，展示如下：
1

除此之外，根据这个学习鸿蒙全栈学习路线，也附带一整套完整的学习【文档+视频】，内容包含如下：

内容包含了：（ArkTS、ArkUI、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、鸿蒙南向开发、鸿蒙项目实战）等技术知识点。帮助大家在学习鸿蒙路上快速成长！

鸿蒙【北向应用开发+南向系统层开发】文档

鸿蒙【基础+实战项目】视频

鸿蒙面经

在这里插入图片描述

为了避免大家在学习过程中产生更多的时间成本，对比我把以上内容全部放在了↓↓↓想要的可以自拿喔！谢谢大家观看！

爱桥代码的程序媛
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
鸿蒙系统开发【加解密算法库框架】安全
2301_76813281的博客
08-02 215
本示例使用@ohos.security.cryptoFramework相关接口实现了对文本文件的加解密、签名验签操作。
【鸿蒙开发实战教程】HarmonyOS开发中的对称加密
HarmonyOS_001的博客
06-17 918
HarmonyOS（鸿蒙）SDK API9支持两种对称加密算法：a. AES(Advanced Encryption Standard) b.3DES(也称为 3DESede 或 TripleDES).官方也给出了一些样例使用代码，可供开发者参考。本篇从实践出发，完整的通过代码方式来深入了解HarmonyOS中的对称加密用法。有很多小伙伴不知道该从哪里开始学习鸿蒙开发技术？也不知道鸿蒙开发的知识点重点掌握的又有哪些？自学时频繁踩坑，导致浪费大量时间。结果还是一知半解。所以有一份实用的。
HarmonyOS开发案例：【字符串加解密】
m0_70748845的博客
04-21 681
本Codelab针对用户隐私安全，使用加密算法API对密码进行加密存储，模拟开发一个用户注册登录应用。实现登录、注册、登录成功页面。注册的用户数据保存到关系型数据库。登录时通过查询数据库校验用户是否存在、密码是否正确。密码通过加密算法保存和使用。
【鸿蒙实战开发】HarmonyOS 对称加密
HarmonyOS_002的博客
07-12 745
这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、openHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
【鸿蒙实战开发】HarmonyOS非对称加密-RSA
HarmonyOS_002的博客
07-12 674
这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、openHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
Android与鸿蒙系统安全（三）
求变，从思想开始
10-22 3789
八、鸿蒙安全系统 OpenHarmony操作系统是一个开放的系统，开发者可以通过OpenHarmony开发灵活的服务和应用，为开发者和使用者带来便利和价值。为了达到这一目的，OpenHarmony提供了一个可以有效保护应用和用户数据的执行环境。 在这个执行环境中，芯片的安全能力、系统的安全能力、以及上层的安全服务一起协作，从硬件安全、系统安全、数据安全、设备互联安全、应用安全、安全更新多个维度提供安全保障。鸿蒙采用的微内核+外核的设计，微内核没有被Root的概念，同时外核和内核是分开的，互相隔离，提升了
【鸿蒙实战开发】基于@ohos/crypto-js实现加解密工具箱
HarmonyOSMN的博客
07-10 705
ohos/crypto-js是一个根据crypto-js库移植的鸿蒙三方库，适配源库4.2.0版本，提供了一系列加密算法和安全工具，主要用于执行各种消息摘要计算和对称加解密操作。
Android与鸿蒙系统安全（一）
求变，从思想开始
10-22 5871
Android、鸿蒙系统安全 一、信息安全概念 信息安全涉及信息论、计算机科学和密码学等多方面的知识，它研究计算机系统和通信网络内信息的保护方法，是指在信息的产生、传输、使用、存储过程中，对信息载体(处理载体、存储载体、传输载体)和信息的处理、传输、存储、访问提供安全保护，以防止数据信息内容或能力被非法使用、篡改。 信息安全的基本属性包括机密性、完整性、可用性、可认证性和不可否认性，主要的信息安全威胁包括被动攻击、主动攻击、内部人员攻击和分发攻击，主要的信息安全技术包括密码技术、身份管理技术、权限管理
鸿蒙开发实战-如何开发一个字符串加解密应用程序
2401_82546228的博客
03-27 848
本Codelab针对用户隐私安全，使用加密算法API对密码进行加密存储，模拟开发一个用户注册登录应用。实现如下功能：
华为鸿蒙HarmonyOS开发者资料大全鸿蒙系统开发资料汇总.zip
06-16
鸿蒙HarmonyOS开发者资料大全鸿蒙系统开发资料汇总,包括如下： DevEco Studio 1.0 使用指南.pdf HarmonyOS-NFC开发指南.pdf HarmonyOS应用开发之页面开发.pdf HarmonyOS开发必备基础知识.pdf WLAN开发指南.pdf 图像...
最新鸿蒙HarmonyOS开发文档汇总.zip
08-03
HarmonyOS开发文档（二）； HarmonyOS开发文档（一）； HarmonyOS入门文档； HarmonyOS设备应用开发文档； HarmonyOS应用设计文档； HarmonyOS智慧屏设计文档； HarmonyOS智能穿戴应用设计文档； Huawei DevEco ...
鸿蒙系统开发日常代码.zip
01-20
鸿蒙系统，全称为HarmonyOS，是由华为公司自主研发的操作系统，旨在打造一个跨设备、全场景的智慧生活新体验。作为一个面向未来的操作系统，鸿蒙系统具有分布式架构、微内核设计以及高度可定制的特点，使得它在...
《鸿蒙操作系统开发入门经典》中1
08-04
鸿蒙操作系统开发入门经典 本资源摘要信息涵盖了鸿蒙操作系统开发的基础知识，包括接口说明、开发步骤、事件处理、线程管理和任务分发等方面。 接口说明 在鸿蒙操作系统中，接口说明是指开发者在开发应用程序时...
基于鸿蒙系统开发的记事本.zip
02-07
华为推出的鸿蒙系统（HarmonyOS），是中国首个面向全场景的分布式操作系统，旨在打破设备间的壁垒，实现跨平台无缝协同体验。这个压缩包“基于鸿蒙系统开发的记事本.zip”提供了一个在鸿蒙系统上开发记事本应用的...
鸿蒙 Navigation VS Router 对比
Dev Blog
07-24 1239
鸿蒙关于页面跳转提供了两套解决方案，一套是页面路由 router，一套是组件导航 Navigation。前期我们在基建开发期间，采用的页面路由 router 方案，@zz/router 组件代码已经开发完毕了，但是到了开发 WebView 的 Hybrid 接口时，才意识到一个严重的问题，就是 router 提供的能力，并不能满足我们复杂的页面栈管理，譬如在页面栈中多个 WebView，我们需要关闭指定的 WebView 页面，router 提供的 API 能力是无法做到的。支持，需要先import页面。
HarmonyOS NEXT星河版零基础入门到实战
stc_ljc的博客
07-24 876
放弃安卓框架之后，HarmonyOS NEXT成为真正独立于安卓、iOS的操作系统，堪称是一场史无前例的脱胎换骨。在其众多新特性中，原生智能无疑是最能带给用户直观感受和体验升级的新特性之一。HarmonyOS NEXT首次将AI与OS深度融合，构筑了全新鸿蒙原生智能框架，真正开启了全新的AI时代。
鸿蒙应用框架开发【多HAP】程序框架
最新发布
2301_76813281的博客
07-25 902
本示例展示多HAP开发，简单介绍了多HAP的使用场景，应用包含了一个entry HAP和两个feature HAP，两个feature HAP分别提供了音频和视频播放组件，entry中使用了音频和视频播放组件。 三个模块需要安装三个hap包，最终会在设备上安装一个主entry的hap包。
科普文：Linux系统安全加固指南
为无为，事无事，味无味。
07-25 1406
本指南仅关注安全性和隐私性，而不关注性能，可用性或其他内容。列出的所有命令都将需要root特权。以“$”符号开头的单词表示一个变量，不同终端之间可能会有所不同。选择一个好的Linux发行版有很多因素。避免分发冻结程序包，因为它们在安全更新中通常很落后不使用与Systemd机制的发行版。Systemd包含许多不必要的攻击面；它尝试做的事情远远超出了必要，并且超出了初始化系统应做的事情。使用musl作为默认的C库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值