@hpke/hybridkem-x-wing 0.1.0

package/script/mod.js

@@ -0,0 +1,15 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./src/hybridkemXWing.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HybridkemXWing = void 0;
+    var hybridkemXWing_js_1 = require("./src/hybridkemXWing.js");
+    Object.defineProperty(exports, "HybridkemXWing", { enumerable: true, get: function () { return hybridkemXWing_js_1.HybridkemXWing; } });
+});

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/src/hybridkemXWing.d.ts

@@ -0,0 +1,94 @@
+import { MlKem768 } from "mlkem";
+import type { KemInterface, RecipientContextParams, SenderContextParams } from "@hpke/common";
+import { KemId } from "@hpke/common";
+import { X25519 } from "@hpke/dhkem-x25519";
+/**
+ * The Hybrid Post-Quantum KEM (X25519, Kyber768).
+ *
+ * This class is implemented using
+ * {@link https://github.com/Argyle-Software/kyber | pqc-kyber }.
+ *
+ * The instance of this class can be specified to the
+ * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+ *
+ * @example Use with `@hpke/core`:
+ *
+ * ```ts
+ * import { Aes128Gcm, CipherSuite, HkdfSha256 } from "@hpke/core";
+ * import { HybridkemXWing } from "@hpke/hybridkem-x-wing";
+ * const suite = new CipherSuite({
+ *   kem: new HybridkemXWing(),
+ *   kdf: new HkdfSha256(),
+ *   aead: new Aes128Gcm(),
+ * });
+ * ```
+ */
+export declare class HybridkemXWing implements KemInterface {
+    readonly id: KemId;
+    readonly name: string;
+    readonly secretSize: number;
+    readonly encSize: number;
+    readonly publicKeySize: number;
+    readonly privateKeySize: number;
+    readonly auth: boolean;
+    protected _m: MlKem768;
+    protected _x25519: X25519;
+    private _api;
+    constructor();
+    serializePublicKey(key: CryptoKey): Promise<ArrayBuffer>;
+    deserializePublicKey(key: ArrayBuffer): Promise<CryptoKey>;
+    serializePrivateKey(key: CryptoKey): Promise<ArrayBuffer>;
+    deserializePrivateKey(key: ArrayBuffer): Promise<CryptoKey>;
+    /**
+     * Generates a new key pair.
+     *
+     * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+     */
+    generateKeyPair(): Promise<CryptoKeyPair>;
+    /**
+     * Generates a key pair from the secret key.
+     * @param sk The secret key.
+     * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+     * @throws {InvalidParamError} Thrown if the length of the secret key is not 32 bytes.
+     * @throws {DeriveKeyPairError} Thrown if the key pair cannot be derived.
+     */
+    generateKeyPairDerand(sk: Uint8Array): Promise<CryptoKeyPair>;
+    /**
+     * Derives a key pair from the input keying material.
+     *
+     * @param {ArrayBuffer} ikm The input keying material.
+     * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+     * @throws {DeriveKeyPairError} Thrown if the key pair cannot be derived.
+     * @throws {InvalidParamError} Thrown if the length of the IKM is not 32 bytes.
+     */
+    deriveKeyPair(ikm: ArrayBuffer): Promise<CryptoKeyPair>;
+    importKey(_format: "raw" | "jwk", _key: ArrayBuffer | JsonWebKey, _isPublic?: boolean): Promise<CryptoKey>;
+    encap(params: SenderContextParams): Promise<{
+        sharedSecret: ArrayBuffer;
+        enc: ArrayBuffer;
+    }>;
+    decap(params: RecipientContextParams): Promise<ArrayBuffer>;
+    /**
+     * Sets up the MlKemBase instance by loading the necessary crypto library.
+     * If the crypto library is already loaded, this method does nothing.
+     * @returns {Promise<void>} A promise that resolves when the setup is complete.
+     */
+    private _setup;
+    /**
+     * Generates a key pair from the secret key.
+     * @param sk The secret key.
+     * @returns {Promise<[Uint8Array, Uint8Array]>} A promise that resolves with the key pair derived from the secret key.
+     */
+    private _generateKeyPairDerand;
+    /**
+     * Expands the decapsulation key.
+     * @param sk The secret key.
+     * @returns {Promise<[Uint8Array, Uint8Array, Uint8Array, Uint8Array]>} A promise that resolves with the keys derived by expanding the secret key.
+     */
+    private _expandDecapsulationKey;
+    private _serializePublicKey;
+    private _deserializePublicKey;
+    private _serializePrivateKey;
+    private _deserializePrivateKey;
+}
+//# sourceMappingURL=hybridkemXWing.d.ts.map

package/script/src/hybridkemXWing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybridkemXWing.d.ts","sourceRoot":"","sources":["../../src/src/hybridkemXWing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEjC,OAAO,KAAK,EACV,YAAY,EACZ,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAQL,KAAK,EAKN,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAc,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAwCxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,cAAe,YAAW,YAAY;IACjD,SAAgB,EAAE,EAAE,KAAK,CAAwB;IACjD,SAAgB,IAAI,EAAE,MAAM,CAAY;IACxC,SAAgB,UAAU,EAAE,MAAM,CAAM;IACxC,SAAgB,OAAO,EAAE,MAAM,CAAQ;IACvC,SAAgB,aAAa,EAAE,MAAM,CAAQ;IAC7C,SAAgB,cAAc,EAAE,MAAM,CAAM;IAC5C,SAAgB,IAAI,EAAE,OAAO,CAAS;IACtC,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC;IACvB,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,IAAI,CAAiC;;IAOhC,kBAAkB,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IASxD,oBAAoB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAS1D,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC;IASzD,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IASxE;;;;OAIG;IACU,eAAe,IAAI,OAAO,CAAC,aAAa,CAAC;IAkBtD;;;;;;OAMG;IACU,qBAAqB,CAAC,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC;IAc1E;;;;;;;OAOG;IACU,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;IAevD,SAAS,CACpB,OAAO,EAAE,KAAK,GAAG,KAAK,EACtB,IAAI,EAAE,WAAW,GAAG,UAAU,EAC9B,SAAS,UAAO,GACf,OAAO,CAAC,SAAS,CAAC;IAcR,KAAK,CAChB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC;QAAE,YAAY,EAAE,WAAW,CAAC;QAAC,GAAG,EAAE,WAAW,CAAA;KAAE,CAAC;IA4C9C,KAAK,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,WAAW,CAAC;IAyBxE;;;;OAIG;YACW,MAAM;IAOpB;;;;OAIG;YACW,sBAAsB;IAOpC;;;;OAIG;YACW,uBAAuB;IAUrC,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,oBAAoB;IAe5B,OAAO,CAAC,sBAAsB;CAU/B"}

package/script/src/hybridkemXWing.js

@@ -0,0 +1,395 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@noble/hashes/sha3", "mlkem", "@hpke/common", "@hpke/dhkem-x25519"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HybridkemXWing = void 0;
+    const sha3_1 = require("@noble/hashes/sha3");
+    // @ts-ignore: Unreachable code error
+    const mlkem_1 = require("mlkem");
+    const common_1 = require("@hpke/common");
+    const dhkem_x25519_1 = require("@hpke/dhkem-x25519");
+    // deno-fmt-ignore
+    const X25519_BASE = new Uint8Array([
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    ]);
+    // XWingLabel = concat(
+    //   "\./",
+    //   "/^\",
+    // );
+    // deno-fmt-ignore
+    const XWING_LABEL = new Uint8Array([46, 47, 47, 94, 92]);
+    function emitNotSupported() {
+        return new Promise((_resolve, reject) => {
+            reject(new common_1.NotSupportedError("Not supported"));
+        });
+    }
+    function combiner(ssM, ssX, ctX, pkX) {
+        const ret = new Uint8Array(ssM.length + ssX.length + ctX.length + pkX.length + XWING_LABEL.length);
+        ret.set(ssM, 0);
+        ret.set(ssX, ssM.length);
+        ret.set(ctX, ssM.length + ssX.length);
+        ret.set(pkX, ssM.length + ssX.length + ctX.length);
+        ret.set(XWING_LABEL, ssM.length + ssX.length + ctX.length + pkX.length);
+        return sha3_1.sha3_256.create().update(ret).digest();
+    }
+    /**
+     * The Hybrid Post-Quantum KEM (X25519, Kyber768).
+     *
+     * This class is implemented using
+     * {@link https://github.com/Argyle-Software/kyber | pqc-kyber }.
+     *
+     * The instance of this class can be specified to the
+     * {@link https://jsr.io/@hpke/core/doc/~/CipherSuiteParams | CipherSuiteParams} as follows:
+     *
+     * @example Use with `@hpke/core`:
+     *
+     * ```ts
+     * import { Aes128Gcm, CipherSuite, HkdfSha256 } from "@hpke/core";
+     * import { HybridkemXWing } from "@hpke/hybridkem-x-wing";
+     * const suite = new CipherSuite({
+     *   kem: new HybridkemXWing(),
+     *   kdf: new HkdfSha256(),
+     *   aead: new Aes128Gcm(),
+     * });
+     * ```
+     */
+    class HybridkemXWing {
+        constructor() {
+            Object.defineProperty(this, "id", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: common_1.KemId.HybridkemXWing
+            });
+            Object.defineProperty(this, "name", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "X-Wing"
+            });
+            Object.defineProperty(this, "secretSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            Object.defineProperty(this, "encSize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 1120
+            });
+            Object.defineProperty(this, "publicKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 1216
+            });
+            Object.defineProperty(this, "privateKeySize", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 32
+            });
+            Object.defineProperty(this, "auth", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: false
+            });
+            Object.defineProperty(this, "_m", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_x25519", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_api", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: undefined
+            });
+            this._m = new mlkem_1.MlKem768();
+            this._x25519 = new dhkem_x25519_1.X25519(new dhkem_x25519_1.HkdfSha256());
+        }
+        async serializePublicKey(key) {
+            await this._setup();
+            try {
+                return await this._serializePublicKey(key);
+            }
+            catch (e) {
+                throw new common_1.SerializeError(e);
+            }
+        }
+        async deserializePublicKey(key) {
+            await this._setup();
+            try {
+                return await this._deserializePublicKey(key);
+            }
+            catch (e) {
+                throw new common_1.DeserializeError(e);
+            }
+        }
+        async serializePrivateKey(key) {
+            await this._setup();
+            try {
+                return await this._serializePrivateKey(key);
+            }
+            catch (e) {
+                throw new common_1.SerializeError(e);
+            }
+        }
+        async deserializePrivateKey(key) {
+            await this._setup();
+            try {
+                return await this._deserializePrivateKey(key);
+            }
+            catch (e) {
+                throw new common_1.DeserializeError(e);
+            }
+        }
+        /**
+         * Generates a new key pair.
+         *
+         * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+         */
+        async generateKeyPair() {
+            await this._setup();
+            const sk = new Uint8Array(32);
+            try {
+                this._api.getRandomValues(sk);
+            }
+            catch (e) {
+                throw new common_1.NotSupportedError(e);
+            }
+            try {
+                const [_sk, pk] = await this._generateKeyPairDerand(sk);
+                const dSk = await this.deserializePrivateKey(sk);
+                const dPk = await this.deserializePublicKey(pk);
+                return { privateKey: dSk, publicKey: dPk };
+            }
+            catch (e) {
+                throw new common_1.DeriveKeyPairError(e);
+            }
+        }
+        /**
+         * Generates a key pair from the secret key.
+         * @param sk The secret key.
+         * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+         * @throws {InvalidParamError} Thrown if the length of the secret key is not 32 bytes.
+         * @throws {DeriveKeyPairError} Thrown if the key pair cannot be derived.
+         */
+        async generateKeyPairDerand(sk) {
+            if (sk.byteLength !== 32) {
+                throw new common_1.InvalidParamError("Invalid length of sk");
+            }
+            try {
+                const [_sk, pk] = await this._generateKeyPairDerand(sk);
+                const dSk = await this.deserializePrivateKey(sk);
+                const dPk = await this.deserializePublicKey(pk);
+                return { privateKey: dSk, publicKey: dPk };
+            }
+            catch (e) {
+                throw new common_1.DeriveKeyPairError(e);
+            }
+        }
+        /**
+         * Derives a key pair from the input keying material.
+         *
+         * @param {ArrayBuffer} ikm The input keying material.
+         * @returns {Promise<CryptoKeyPair>} A promise that resolves with a new key pair.
+         * @throws {DeriveKeyPairError} Thrown if the key pair cannot be derived.
+         * @throws {InvalidParamError} Thrown if the length of the IKM is not 32 bytes.
+         */
+        async deriveKeyPair(ikm) {
+            await this._setup();
+            try {
+                const sk = sha3_1.shake256.create({ dkLen: 32 })
+                    .update(new Uint8Array(ikm))
+                    .digest();
+                const [_sk, pk] = await this._generateKeyPairDerand(sk);
+                const dSk = await this.deserializePrivateKey(sk);
+                const dPk = await this.deserializePublicKey(pk);
+                return { privateKey: dSk, publicKey: dPk };
+            }
+            catch (e) {
+                throw new common_1.DeriveKeyPairError(e);
+            }
+        }
+        async importKey(_format, _key, _isPublic = true) {
+            return await emitNotSupported();
+            // if (format !== "raw") {
+            //   throw new NotSupportedError("'jwk' is not supported");
+            // }
+            // if (!(key instanceof ArrayBuffer)) {
+            //   throw new InvalidParamError("Invalid type of key");
+            // }
+            // if (isPublic) {
+            //   return await this.deserializePublicKey(key as ArrayBuffer);
+            // }
+            // return await this.deserializePrivateKey(key as ArrayBuffer);
+        }
+        async encap(params) {
+            let ekm = undefined;
+            if (params.ekm !== undefined && !(0, common_1.isCryptoKeyPair)(params.ekm)) {
+                if (params.ekm.byteLength !== 64) {
+                    throw new common_1.InvalidParamError("ekm must be 64 bytes in length");
+                }
+                ekm = params.ekm;
+            }
+            let ekM = undefined;
+            let ekX;
+            if (ekm !== undefined) {
+                const ek = new Uint8Array(ekm);
+                ekM = ek.subarray(0, 32);
+                ekX = ek.subarray(32, 64);
+            }
+            else {
+                ekX = new Uint8Array(32);
+                try {
+                    this._api.getRandomValues(ekX);
+                }
+                catch (e) {
+                    throw new common_1.NotSupportedError(e);
+                }
+            }
+            const pk = new Uint8Array(await this.serializePublicKey(params.recipientPublicKey));
+            if (pk.byteLength !== 1216) {
+                throw new common_1.InvalidParamError("Invalid length of recipientPublicKey");
+            }
+            await this._setup();
+            try {
+                const pkM = pk.subarray(0, 1184);
+                const pkX = pk.subarray(1184, 1216);
+                const ctX = await this._x25519.derive(ekX, X25519_BASE);
+                const ssX = await this._x25519.derive(ekX, pkX);
+                const [ctM, ssM] = await this._m.encap(pkM, ekM);
+                return {
+                    sharedSecret: combiner(ssM, ssX, ctX, pkX),
+                    enc: (0, common_1.concat)(ctM, ctX),
+                };
+            }
+            catch (e) {
+                throw new common_1.EncapError(e);
+            }
+        }
+        async decap(params) {
+            const rSk = (0, common_1.isCryptoKeyPair)(params.recipientKey)
+                ? params.recipientKey.privateKey
+                : params.recipientKey;
+            if (params.enc.byteLength !== 1120) {
+                throw new common_1.InvalidParamError("Invalid length of enc");
+            }
+            const sk = new Uint8Array(await this.serializePrivateKey(rSk));
+            if (sk.byteLength !== 32) {
+                throw new common_1.InvalidParamError("Invalid length of recipientKey");
+            }
+            await this._setup();
+            try {
+                const [skM, skX, _pkM, pkX] = await this._expandDecapsulationKey(sk);
+                const ct = new Uint8Array(params.enc);
+                const ctM = ct.subarray(0, 1088);
+                const ctX = ct.subarray(1088);
+                const ssM = await this._m.decap(ctM, skM);
+                const ssX = await this._x25519.derive(skX, ctX);
+                return combiner(ssM, ssX, ctX, pkX);
+            }
+            catch (e) {
+                throw new common_1.DecapError(e);
+            }
+        }
+        /**
+         * Sets up the MlKemBase instance by loading the necessary crypto library.
+         * If the crypto library is already loaded, this method does nothing.
+         * @returns {Promise<void>} A promise that resolves when the setup is complete.
+         */
+        async _setup() {
+            if (this._api !== undefined) {
+                return;
+            }
+            this._api = await (0, common_1.loadCrypto)();
+        }
+        /**
+         * Generates a key pair from the secret key.
+         * @param sk The secret key.
+         * @returns {Promise<[Uint8Array, Uint8Array]>} A promise that resolves with the key pair derived from the secret key.
+         */
+        async _generateKeyPairDerand(sk) {
+            const [_skM, _skX, pkM, pkX] = await this._expandDecapsulationKey(sk);
+            return [sk, (0, common_1.concat)(pkM, pkX)];
+        }
+        /**
+         * Expands the decapsulation key.
+         * @param sk The secret key.
+         * @returns {Promise<[Uint8Array, Uint8Array, Uint8Array, Uint8Array]>} A promise that resolves with the keys derived by expanding the secret key.
+         */
+        async _expandDecapsulationKey(sk) {
+            const expanded = sha3_1.shake256.create({ dkLen: 96 }).update(sk).digest();
+            const [pkM, skM] = await this._m.deriveKeyPair(expanded.subarray(0, 64));
+            const skX = expanded.subarray(64, 96);
+            const pkX = await this._x25519.derive(skX, X25519_BASE);
+            return [skM, skX, pkM, pkX];
+        }
+        _serializePublicKey(k) {
+            return new Promise((resolve, reject) => {
+                if (k.type !== "public") {
+                    reject(new Error("Not public key"));
+                }
+                if (k.algorithm.name !== this.name) {
+                    reject(new Error(`Invalid algorithm name: ${k.algorithm.name}`));
+                }
+                if (k.key.byteLength !== this.publicKeySize) {
+                    reject(new Error(`Invalid key length: ${k.key.byteLength}`));
+                }
+                resolve(k.key.buffer);
+            });
+        }
+        _deserializePublicKey(k) {
+            return new Promise((resolve, reject) => {
+                if (k.byteLength !== this.publicKeySize) {
+                    reject(new Error(`Invalid key length: ${k.byteLength}`));
+                }
+                resolve(new common_1.XCryptoKey(this.name, new Uint8Array(k), "public"));
+            });
+        }
+        _serializePrivateKey(k) {
+            return new Promise((resolve, reject) => {
+                if (k.type !== "private") {
+                    reject(new Error("Not private key"));
+                }
+                if (k.algorithm.name !== this.name) {
+                    reject(new Error(`Invalid algorithm name: ${k.algorithm.name}`));
+                }
+                if (k.key.byteLength !== this.privateKeySize) {
+                    reject(new Error(`Invalid key length: ${k.key.byteLength}`));
+                }
+                resolve(k.key.buffer);
+            });
+        }
+        _deserializePrivateKey(k) {
+            return new Promise((resolve, reject) => {
+                if (k.byteLength !== this.privateKeySize) {
+                    reject(new Error(`Invalid key length: ${k.byteLength}`));
+                }
+                resolve(new common_1.XCryptoKey(this.name, new Uint8Array(k), "private", ["deriveBits"]));
+            });
+        }
+    }
+    exports.HybridkemXWing = HybridkemXWing;
+});

package/script/test/hybridkemXWing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybridkemXWing.test.d.ts","sourceRoot":"","sources":["../../src/test/hybridkemXWing.test.ts"],"names":[],"mappings":""}

package/script/test/testVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testVectors.d.ts","sourceRoot":"","sources":["../../src/test/testVectors.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,UAAU,CAY1C,CAAC"}