@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/dist/typescript/utils/types.d.ts

@@ -0,0 +1,294 @@
+import type { Buffer as CraftzdogBuffer } from '@craftzdog/react-native-buffer';
+import type { Buffer } from 'buffer';
+import type { CipherKey } from 'node:crypto';
+import type { Buffer as SafeBuffer } from 'safe-buffer';
+import type { KeyObjectHandle as KeyObjectHandleType } from '../specs/v1/keyObjectHandle.nitro';
+import type { KeyObject, CryptoKey } from '../keys';
+export type ABV = TypedArray | DataView | ArrayBufferLike | CraftzdogBuffer;
+export type TypedArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
+export type RandomCallback<T> = (err: Error | null, value: T) => void;
+export type BufferLike = ArrayBuffer | ArrayBufferLike | CraftzdogBuffer | SafeBuffer | ArrayBufferView;
+export type BinaryLike = string | Buffer | ArrayBuffer | ArrayBufferLike | ArrayBufferView | CraftzdogBuffer | SafeBuffer | TypedArray | DataView;
+export type BinaryLikeNode = CipherKey | BinaryLike | KeyObject;
+export type DigestAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512' | 'cSHAKE128' | 'cSHAKE256';
+export type HashAlgorithm = DigestAlgorithm | 'SHA-224' | 'RIPEMD-160';
+export type RSAKeyPairAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP';
+export interface RsaHashedKeyGenParams {
+    name: RSAKeyPairAlgorithm;
+    modulusLength: number;
+    publicExponent: Uint8Array;
+    hash: string | {
+        name: string;
+    };
+}
+export interface RsaKeyAlgorithm {
+    name: RSAKeyPairAlgorithm;
+    modulusLength: number;
+    publicExponent: Uint8Array;
+    hash: {
+        name: string;
+    };
+}
+export type ECKeyPairAlgorithm = 'ECDSA' | 'ECDH';
+export type CFRGKeyPairAlgorithm = 'Ed25519' | 'Ed448' | 'X25519' | 'X448';
+export type CFRGKeyPairType = 'ed25519' | 'ed448' | 'x25519' | 'x448';
+export type PQCKeyPairAlgorithm = 'ML-DSA-44' | 'ML-DSA-65' | 'ML-DSA-87' | 'ML-KEM-512' | 'ML-KEM-768' | 'ML-KEM-1024';
+export type PQCKeyPairType = 'ml-dsa-44' | 'ml-dsa-65' | 'ml-dsa-87' | 'ml-kem-512' | 'ml-kem-768' | 'ml-kem-1024';
+export type MlKemAlgorithm = 'ML-KEM-512' | 'ML-KEM-768' | 'ML-KEM-1024';
+export interface EncapsulateResult {
+    sharedKey: ArrayBuffer;
+    ciphertext: ArrayBuffer;
+}
+export type RSAKeyPairType = 'rsa' | 'rsa-pss';
+export type ECKeyPairType = 'ec';
+export type DSAKeyPairType = 'dsa';
+export type DHKeyPairType = 'dh';
+export type KeyPairAlgorithm = RSAKeyPairAlgorithm | ECKeyPairAlgorithm | CFRGKeyPairAlgorithm | PQCKeyPairAlgorithm;
+export type AESAlgorithm = 'AES-CTR' | 'AES-CBC' | 'AES-GCM' | 'AES-KW' | 'AES-OCB';
+export type SecretKeyAlgorithm = 'HMAC' | AESAlgorithm;
+export type SignVerifyAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'ECDSA' | 'HMAC' | 'KMAC128' | 'KMAC256' | 'Ed25519' | 'Ed448' | 'ML-DSA-44' | 'ML-DSA-65' | 'ML-DSA-87';
+export type Argon2Algorithm = 'Argon2d' | 'Argon2i' | 'Argon2id';
+export type DeriveBitsAlgorithm = 'PBKDF2' | 'HKDF' | 'ECDH' | 'X25519' | 'X448' | Argon2Algorithm;
+export type EncryptDecryptAlgorithm = 'RSA-OAEP' | 'AES-CTR' | 'AES-CBC' | 'AES-GCM' | 'AES-KW' | 'AES-OCB' | 'ChaCha20-Poly1305';
+export type RsaOaepParams = {
+    name: 'RSA-OAEP';
+    label?: BufferLike;
+};
+export type AesCbcParams = {
+    name: 'AES-CBC';
+    iv: BufferLike;
+};
+export type AesCtrParams = {
+    name: 'AES-CTR';
+    counter: TypedArray;
+    length: number;
+};
+export type AesGcmParams = {
+    name: 'AES-GCM';
+    iv: BufferLike;
+    tagLength?: TagLength;
+    additionalData?: BufferLike;
+};
+export type ChaCha20Poly1305Params = {
+    name: 'ChaCha20-Poly1305';
+    iv: BufferLike;
+    tagLength?: 128;
+    additionalData?: BufferLike;
+};
+export type AesOcbParams = {
+    name: 'AES-OCB';
+    iv: BufferLike;
+    tagLength?: 64 | 96 | 128;
+    additionalData?: BufferLike;
+};
+export type AesKwParams = {
+    name: 'AES-KW';
+    wrappingKey?: BufferLike;
+};
+export type AesKeyGenParams = {
+    length: AESLength;
+    name?: AESAlgorithm;
+};
+export type TagLength = 32 | 64 | 96 | 104 | 112 | 120 | 128;
+export type AESLength = 128 | 192 | 256;
+export type EncryptDecryptParams = AesCbcParams | AesCtrParams | AesGcmParams | AesOcbParams | AesKwParams | RsaOaepParams | ChaCha20Poly1305Params;
+export type AnyAlgorithm = DigestAlgorithm | HashAlgorithm | KeyPairAlgorithm | SecretKeyAlgorithm | SignVerifyAlgorithm | DeriveBitsAlgorithm | EncryptDecryptAlgorithm | AESAlgorithm | 'PBKDF2' | 'HKDF' | 'unknown';
+export type NamedCurve = 'P-256' | 'P-384' | 'P-521';
+export type SubtleAlgorithm = {
+    name: AnyAlgorithm;
+    salt?: string | BufferLike;
+    iterations?: number;
+    hash?: HashAlgorithm | string | {
+        name: string;
+    };
+    namedCurve?: NamedCurve;
+    length?: number;
+    modulusLength?: number;
+    publicExponent?: number | Uint8Array;
+    saltLength?: number;
+    public?: CryptoKey;
+    info?: BufferLike;
+    nonce?: BufferLike;
+    parallelism?: number;
+    tagLength?: number;
+    memory?: number;
+    passes?: number;
+    secretValue?: BufferLike;
+    associatedData?: BufferLike;
+    version?: number;
+    customization?: BufferLike;
+};
+export type KeyPairType = CFRGKeyPairType | RSAKeyPairType | ECKeyPairType | DSAKeyPairType | DHKeyPairType;
+export type KeyUsage = 'encrypt' | 'decrypt' | 'sign' | 'verify' | 'deriveKey' | 'deriveBits' | 'encapsulateBits' | 'decapsulateBits' | 'encapsulateKey' | 'decapsulateKey' | 'wrapKey' | 'unwrapKey';
+export declare enum KFormatType {
+    DER = 0,
+    PEM = 1,
+    JWK = 2
+}
+export declare enum KeyType {
+    SECRET = 0,
+    PUBLIC = 1,
+    PRIVATE = 2
+}
+export declare enum KeyEncoding {
+    PKCS1 = 0,
+    PKCS8 = 1,
+    SPKI = 2,
+    SEC1 = 3
+}
+export declare enum KeyFormat {
+    RAW = 0,
+    PKCS8 = 1,
+    SPKI = 2,
+    JWK = 3
+}
+export type KeyData = BufferLike | BinaryLike | JWK;
+export declare const kNamedCurveAliases: {
+    readonly 'P-256': "prime256v1";
+    readonly 'P-384': "secp384r1";
+    readonly 'P-521': "secp521r1";
+};
+export type KeyPairGenConfig = {
+    publicFormat?: KFormatType | -1;
+    publicType?: KeyEncoding;
+    privateFormat?: KFormatType | -1;
+    privateType?: KeyEncoding;
+    cipher?: string;
+    passphrase?: ArrayBuffer;
+};
+export type AsymmetricKeyType = 'rsa' | 'rsa-pss' | 'dsa' | 'ec' | 'dh' | CFRGKeyPairType | PQCKeyPairType;
+type JWKkty = 'AES' | 'RSA' | 'EC' | 'oct' | 'OKP';
+type JWKuse = 'sig' | 'enc';
+export interface JWK {
+    kty?: JWKkty;
+    use?: JWKuse;
+    key_ops?: KeyUsage[];
+    alg?: string;
+    crv?: string;
+    kid?: string;
+    x5u?: string;
+    x5c?: string[];
+    x5t?: string;
+    'x5t#256'?: string;
+    n?: string;
+    e?: string;
+    d?: string;
+    p?: string;
+    q?: string;
+    x?: string;
+    y?: string;
+    k?: string;
+    dp?: string;
+    dq?: string;
+    qi?: string;
+    ext?: boolean;
+}
+export type KTypePrivate = 'pkcs1' | 'pkcs8' | 'sec1';
+export type KTypePublic = 'pkcs1' | 'spki';
+export type KType = KTypePrivate | KTypePublic;
+export type KFormat = 'der' | 'pem' | 'jwk';
+export type DSAEncoding = 'der' | 'ieee-p1363';
+export type EncodingOptions = {
+    key?: any;
+    type?: KType;
+    encoding?: string;
+    dsaEncoding?: DSAEncoding;
+    format?: KFormat;
+    padding?: number;
+    cipher?: string;
+    passphrase?: BinaryLike;
+    saltLength?: number;
+    oaepHash?: string;
+    oaepLabel?: BinaryLike;
+};
+export interface KeyDetail {
+    length?: number;
+    publicExponent?: number;
+    modulusLength?: number;
+    hashAlgorithm?: string;
+    mgf1HashAlgorithm?: string;
+    saltLength?: number;
+    namedCurve?: string;
+}
+export type GenerateKeyPairOptions = {
+    modulusLength?: number;
+    publicExponent?: number;
+    hashAlgorithm?: string;
+    mgf1HashAlgorithm?: string;
+    saltLength?: number;
+    divisorLength?: number;
+    namedCurve?: string;
+    prime?: CraftzdogBuffer;
+    primeLength?: number;
+    generator?: number;
+    groupName?: string;
+    publicKeyEncoding?: EncodingOptions;
+    privateKeyEncoding?: EncodingOptions;
+    paramEncoding?: string;
+    hash?: string;
+    mgf1Hash?: string;
+};
+export type KeyPairKey = ArrayBuffer | Buffer | string | KeyObject | KeyObjectHandle | CryptoKey | undefined;
+export type GenerateKeyPairReturn = [
+    error?: Error,
+    privateKey?: KeyPairKey,
+    publicKey?: KeyPairKey
+];
+export type GenerateKeyPairCallback = (error?: Error, publicKey?: KeyPairKey, privateKey?: KeyPairKey) => GenerateKeyPairReturn | void;
+export type KeyPair = {
+    publicKey?: KeyPairKey;
+    privateKey?: KeyPairKey;
+};
+export type GenerateKeyPairPromiseReturn = [error?: Error, keypair?: KeyPair];
+export type CryptoKeyPair = {
+    publicKey: KeyPairKey;
+    privateKey: KeyPairKey;
+};
+export type WebCryptoKeyPair = {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+};
+export declare enum KeyVariant {
+    RSA_SSA_PKCS1_v1_5 = 0,
+    RSA_PSS = 1,
+    RSA_OAEP = 2,
+    DSA = 3,
+    EC = 4,
+    NID = 5,
+    DH = 6
+}
+export type SignCallback = (err: Error | null, signature?: ArrayBuffer) => void;
+export type VerifyCallback = (err: Error | null, valid?: boolean) => void;
+export type BinaryToTextEncoding = 'base64' | 'base64url' | 'hex' | 'binary';
+export type CharacterEncoding = 'utf8' | 'utf-8' | 'utf16le' | 'latin1';
+export type LegacyCharacterEncoding = 'ascii' | 'binary' | 'ucs2' | 'ucs-2';
+export type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding | 'buffer';
+export type CipherCFBType = 'aes-128-cfb' | 'aes-192-cfb' | 'aes-256-cfb' | 'aes-128-cfb1' | 'aes-192-cfb1' | 'aes-256-cfb1' | 'aes-128-cfb8' | 'aes-192-cfb8' | 'aes-256-cfb8';
+export type CipherCTRType = 'aes-128-ctr' | 'aes-192-ctr' | 'aes-256-ctr';
+export type CipherDESType = 'des' | 'des3' | 'des-cbc' | 'des-ecb' | 'des-ede' | 'des-ede-cbc' | 'des-ede3' | 'des-ede3-cbc';
+export type CipherECBType = 'aes-128-ecb' | 'aes-192-ecb' | 'aes-256-ecb';
+export type CipherGCMType = 'aes-128-gcm' | 'aes-192-gcm' | 'aes-256-gcm';
+export type CipherOFBType = 'aes-128-ofb' | 'aes-192-ofb' | 'aes-256-ofb';
+export type KeyObjectHandle = KeyObjectHandleType;
+export type DiffieHellmanOptions = {
+    privateKey: KeyObject;
+    publicKey: KeyObject;
+};
+export type DiffieHellmanCallback = (err: Error | null, secret?: CraftzdogBuffer) => CraftzdogBuffer | void;
+export type Hex = string | Uint8Array;
+export type ImportFormat = 'raw' | 'raw-public' | 'raw-secret' | 'raw-seed' | 'pkcs8' | 'spki' | 'jwk';
+export type Operation = 'encrypt' | 'decrypt' | 'sign' | 'verify' | 'generateKey' | 'importKey' | 'exportKey' | 'deriveBits' | 'wrapKey' | 'unwrapKey' | 'encapsulateBits' | 'decapsulateBits' | 'encapsulateKey' | 'decapsulateKey';
+export interface KeyPairOptions {
+    namedCurve: string;
+    publicKeyEncoding?: {
+        type: 'spki';
+        format: 'pem' | 'der';
+    };
+    privateKeyEncoding?: {
+        type: 'pkcs8';
+        format: 'pem' | 'der';
+        cipher?: string;
+        passphrase?: string;
+    };
+}
+export {};

package/dist/typescript/utils/validation.d.ts

@@ -0,0 +1,12 @@
+import type { BinaryLike, BufferLike, KeyUsage } from './types';
+export declare function validateFunction(f: unknown): boolean;
+export declare function isStringOrBuffer(val: unknown): val is string | ArrayBuffer;
+export declare function validateObject<T>(value: unknown, name: string, options?: {
+    allowArray: boolean;
+    allowFunction: boolean;
+    nullable: boolean;
+} | null): value is T;
+export declare const validateMaxBufferLength: (data: BinaryLike | BufferLike, name: string) => void;
+export declare const getUsagesUnion: (usageSet: KeyUsage[], ...usages: KeyUsage[]) => KeyUsage[];
+export declare const validateKeyOps: (keyOps: KeyUsage[] | undefined, usagesSet: KeyUsage[]) => void;
+export declare function hasAnyNotIn(set: string[], checks: string[]): boolean;

package/dist/typescript/x509certificate.d.ts

@@ -0,0 +1,63 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { PublicKeyObject, KeyObject } from './keys';
+import type { BinaryLike } from './utils';
+export interface X509LegacyObject {
+    subject: string;
+    issuer: string;
+    subjectaltname: string;
+    infoAccess: string;
+    ca: boolean;
+    modulus: undefined;
+    bits: undefined;
+    exponent: undefined;
+    valid_from: string;
+    valid_to: string;
+    fingerprint: string;
+    fingerprint256: string;
+    fingerprint512: string;
+    ext_key_usage: string[];
+    serialNumber: string;
+    raw: Buffer;
+}
+export interface CheckOptions {
+    subject?: 'default' | 'always' | 'never';
+    wildcards?: boolean;
+    partialWildcards?: boolean;
+    multiLabelWildcards?: boolean;
+    singleLabelSubdomains?: boolean;
+}
+export declare class X509Certificate {
+    private readonly handle;
+    private readonly cache;
+    constructor(buffer: BinaryLike);
+    private cached;
+    get subject(): string;
+    get subjectAltName(): string;
+    get issuer(): string;
+    get infoAccess(): string;
+    get validFrom(): string;
+    get validTo(): string;
+    get validFromDate(): Date;
+    get validToDate(): Date;
+    get fingerprint(): string;
+    get fingerprint256(): string;
+    get fingerprint512(): string;
+    get extKeyUsage(): string[];
+    get keyUsage(): string[];
+    get serialNumber(): string;
+    get signatureAlgorithm(): string;
+    get signatureAlgorithmOid(): string;
+    get ca(): boolean;
+    get raw(): Buffer;
+    get publicKey(): PublicKeyObject;
+    get issuerCertificate(): undefined;
+    checkHost(name: string, options?: CheckOptions): string | undefined;
+    checkEmail(email: string, options?: CheckOptions): string | undefined;
+    checkIP(ip: string): string | undefined;
+    checkIssued(otherCert: X509Certificate): boolean;
+    checkPrivateKey(pkey: KeyObject): boolean;
+    verify(pkey: KeyObject): boolean;
+    toString(): string;
+    toJSON(): string;
+    toLegacyObject(): X509LegacyObject;
+}

package/harmony/quick_crypto/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/harmony/quick_crypto/NOTICE

@@ -0,0 +1,33 @@
+OPEN SOURCE SOFTWARE NOTICE
+
+Please note we provide an open source software notice for the third party open source software along with this software and/or this software component (in the following just “this SOFTWARE”). The open source software licenses are granted by the respective right holders.
+
+Warranty Disclaimer
+THE OPEN SOURCE SOFTWARE IN THIS PRODUCT IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT WITHOUT ANY WARRANTY, WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
+
+Copyright Notice and License Texts
+
+----------------------------------------------------------------------
+Software: react-native-netinfo V11.1.0
+
+MIT License
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/harmony/quick_crypto/OAT.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+	<oatconfig>
+	<licensefile>LICENSE</licensefile>
+		<filefilterlist>
+			<filefilter name="copyrightPolicyFilter" desc="Filters for compatibility，license header policies">
+				<filteritem type="filename" name="hvigorfile.ts" desc="hvigor构建脚本，DevEco Studio自动生成，不需要添加版权头"/>
+				<filteritem type="filename" name="*.json5" desc="hvigor工程配置文件，DevEco Studio自动生成，不需要添加版权头"/>
+				<filteritem type="filename" name="*.proto" desc="资源文件，不需要添加版权头"/>
+				<filteritem type="filename" name="*.json" desc="资源文件，不需要添加版权头"/>
+				<filteritem type="filepath" name="hvigorw" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+				<filteritem type="filepath" name="hvigorw.bat" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+				<filteritem type="filepath" name="hvigor/hvigor-wrapper.js" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+                <filteritem type="filename" name="LICENSE" desc="工程文件，不修改版权头"/>
+			</filefilter>
+			<filefilter name="defaultPolicyFilter" desc="Filters for compatibility，license header policies">
+				<filteritem type="filename" name="hvigorfile.ts" desc="hvigor构建脚本，DevEco Studio自动生成，不需要添加许可证头"/>
+				<filteritem type="filename" name="*.json5" desc="hvigor工程配置文件，DevEco Studio自动生成，不需要添加许可证头"/>
+				<filteritem type="filename" name="LICENSE" desc="原三方库证书文件无需更改，因此添加过滤"/>
+				<filteritem type="filename" name="*.proto" desc="资源文件，不需要添加许可证头"/>
+				<filteritem type="filename" name="*.json" desc="资源文件，不需要添加许可证头"/>
+				<filteritem type="filepath" name="hvigorw" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+				<filteritem type="filepath" name="hvigorw.bat" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+				<filteritem type="filepath" name="hvigor/hvigor-wrapper.js" desc="工程模板，不修改版权头，以防有修改版权风险"/>
+			</filefilter>
+			<filefilter name="binaryFileTypePolicyFilter" desc="Filters for resources files policies">
+				<filteritem type="filename" name="icon.png" desc="应用图标"/>
+				<filteritem type="filename" name="app_icon.png" desc="应用图标"/>
+				<filteritem type="filename" name="warn.png" desc="页面展示图标"/>
+			</filefilter>
+		</filefilterlist>
+        <policylist>
+            <policy name="projectPolicy" desc="">
+                <policyitem type="license" name="MIT" path="*.*" desc="license under the MIT"/>
+            </policy>
+        </policylist>
+	</oatconfig>
+</configuration>

package/harmony/quick_crypto/build-profile.json5

@@ -0,0 +1,16 @@
+{
+  "apiType": "stageMode",
+  "buildOption": {
+    "externalNativeOptions": {
+      "path": "./src/main/cpp/CMakeLists.txt",
+      "arguments": "",
+      "cppFlags": "-fstack-protector-strong -fPIC -D_FORTIFY_SOURCE=2 -O2 -frtti -fexceptions"
+    },
+  },
+  "targets": [
+    {
+      "name": "default",
+      "runtimeOS": "HarmonyOS"
+    }
+  ]
+}