From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 056533EB7F1; Sun, 27 Sep 2026 22:44:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790549089; cv=none; b=YuA7wxrMNExiwRKcdEYzF1XC/k8ww8vAgWj/gv93JHPF84RgHCdb8uFDZD2rCgomQl6aHlzTZiWBweFoPPXwSueN1rynDmB0o0mE17zYpj9sIAEBQ61ujZvaaOO/Wo+oGlc/Pbdij411L8KVC1DX/kj9OoVXkzFcz8VwTzuow8Q= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1790549089; c=relaxed/simple; bh=7lsTgsp3rNqb2iOXiB5NgGfo2WZOrOs1P6p1ft1h4a0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=s2UfskPduph2wW4JPUf2TKUmqnHqkeYgp9eRIWYJzT7X+UKhlT4mxrJ+hcYWq0HcBUq95NiiMcrdxYUoMJKU7ngqKcJXyj9nRQy1p/LzxhIc5GzQPQ4pPMxuz9EQshGyQIBokpc+IqScBSOwxVwZT/7qOlyGSvVXSo74dTjcgfc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=bxNptmOd; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="bxNptmOd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 73A231F0089A; Sun, 27 Sep 2026 22:44:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790549085; bh=/KgPf7qOImf02WNBc/Vis1MwsFR/IDPErtkbwnucFog=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=bxNptmOd/heJQcxhNrsEGeLA7P8vZ287twXdNlVuFnsG48L1jyPnNCT09bGD2QrHz 22fMhmV/TDuLDaNLpebZfPmqUzc1HJrbkpzaU69g/qCWHuJ3FHnSCSAthsJ7Xgd2KX GxIm5wMGLDaUjumYebH6CFW1GZfNpm0Gd+M93uPzuu4x0t7XoIJ+S1I0pcG0dsrPj1 hSSJYd1JYdalcE/B9kqZdOxP8bfzpW+tPlrLadpssc5YfAs6mQ/tue4lpOfolRp25N RL9TOBPTknFnxYvfeCS7Uv5qhqmXi1dcsKoy7z3iIZhQDkFmA5O8rMJdAXkzVvUMOo w8rUDsO9/8WGg== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , "Jason A . Donenfeld" , Herbert Xu , x86@kernel.org, linux-riscv@lists.infradead.org, Eric Biggers Subject: [PATCH v2 18/20] lib/crypto: riscv/aes-cbc: Migrate optimized code into library Date: Sun, 27 Sep 2026 15:43:09 -0700 Message-ID: <20260927224418.109759-19-ebiggers@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260927224418.109759-1-ebiggers@kernel.org> References: <20260927224418.109759-1-ebiggers@kernel.org> Precedence: bulk X-Mailing-List: linux-crypto@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Instead of exposing the riscv-optimized AES-CBC and AES-CBC-CTS code via a riscv-specific crypto_skcipher algorithm, just implement the AES-CBC and AES-CBC-CTS library functions. This is simpler, it makes the AES-CBC and AES-CBC-CTS library functions be riscv-optimized, and it also fixes the longstanding issue where the riscv-optimized AES-CBC and AES-CBC-CTS code was disabled by default. AES-CBC and AES-CBC-CTS support still remains available through crypto_skcipher via crypto/aes.c, but individual architectures no longer need to handle it. To match what the library expects, update the assembly functions to operate on struct aes_enckey or struct aes_key rather than struct crypto_aes_ctx, and adjust the argument order. Remove the single-block special case from the assembly code, since it's already handled by lib/crypto/aes.c before calling aes_cbc_cts_*_arch(). Bump up the priority of the corresponding library-based algorithms on riscv now that they no longer have to be lower than arch/riscv/crypto/. Signed-off-by: Eric Biggers --- arch/riscv/crypto/Kconfig | 4 +- arch/riscv/crypto/Makefile | 2 +- arch/riscv/crypto/aes-riscv64-glue.c | 167 +-------------- arch/riscv/crypto/aes-riscv64-zvkned.S | 273 ------------------------- crypto/aes.c | 6 +- lib/crypto/riscv/aes-riscv64-zvkned.S | 235 +++++++++++++++++++++ lib/crypto/riscv/aes.h | 68 ++++++ 7 files changed, 312 insertions(+), 443 deletions(-) delete mode 100644 arch/riscv/crypto/aes-riscv64-zvkned.S diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index 84c41824b433..0a3f87ad384e 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -3,13 +3,13 @@ menu "Accelerated Cryptographic Algorithms for CPU (riscv)" config CRYPTO_AES_RISCV64 - tristate "Ciphers: AES, modes: CBC, CTS, CTR, XTS" + tristate "Ciphers: AES, modes: CTR, XTS" depends on 64BIT && TOOLCHAIN_HAS_VECTOR_CRYPTO && \ RISCV_EFFICIENT_VECTOR_UNALIGNED_ACCESS select CRYPTO_LIB_AES select CRYPTO_SKCIPHER help - Length-preserving ciphers: AES with CBC, CTS, CTR, XTS + Length-preserving ciphers: AES with CTR, XTS Architecture: riscv64 using: - Zvkned vector crypto extension diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index 8cf31db57fc4..d8b85afa6d0b 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_CRYPTO_AES_RISCV64) += aes-riscv64.o -aes-riscv64-y := aes-riscv64-glue.o aes-riscv64-zvkned.o \ +aes-riscv64-y := aes-riscv64-glue.o \ aes-riscv64-zvkned-zvbb-zvkg.o aes-riscv64-zvkned-zvkb.o obj-$(CONFIG_CRYPTO_SM4_RISCV64) += sm4-riscv64.o diff --git a/arch/riscv/crypto/aes-riscv64-glue.c b/arch/riscv/crypto/aes-riscv64-glue.c index f7c492dcfd57..97f5369d7e71 100644 --- a/arch/riscv/crypto/aes-riscv64-glue.c +++ b/arch/riscv/crypto/aes-riscv64-glue.c @@ -22,17 +22,6 @@ #include #include -asmlinkage void aes_cbc_encrypt_zvkned(const struct crypto_aes_ctx *key, - const u8 *in, u8 *out, size_t len, - u8 iv[AES_BLOCK_SIZE]); -asmlinkage void aes_cbc_decrypt_zvkned(const struct crypto_aes_ctx *key, - const u8 *in, u8 *out, size_t len, - u8 iv[AES_BLOCK_SIZE]); - -asmlinkage void aes_cbc_cts_crypt_zvkned(const struct crypto_aes_ctx *key, - const u8 *in, u8 *out, size_t len, - const u8 iv[AES_BLOCK_SIZE], bool enc); - asmlinkage void aes_ctr32_crypt_zvkned_zvkb(const struct crypto_aes_ctx *key, const u8 *in, u8 *out, size_t len, u8 iv[AES_BLOCK_SIZE]); @@ -81,110 +70,6 @@ static int riscv64_aes_setkey_skcipher(struct crypto_skcipher *tfm, return riscv64_aes_setkey(ctx, key, keylen); } -/* AES-CBC */ - -static int riscv64_aes_cbc_crypt(struct skcipher_request *req, bool enc) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - const struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); - struct skcipher_walk walk; - unsigned int nbytes; - int err; - - err = skcipher_walk_virt(&walk, req, false); - while ((nbytes = walk.nbytes) != 0) { - kernel_vector_begin(); - if (enc) - aes_cbc_encrypt_zvkned(ctx, walk.src.virt.addr, - walk.dst.virt.addr, - nbytes & ~(AES_BLOCK_SIZE - 1), - walk.iv); - else - aes_cbc_decrypt_zvkned(ctx, walk.src.virt.addr, - walk.dst.virt.addr, - nbytes & ~(AES_BLOCK_SIZE - 1), - walk.iv); - kernel_vector_end(); - err = skcipher_walk_done(&walk, nbytes & (AES_BLOCK_SIZE - 1)); - } - - return err; -} - -static int riscv64_aes_cbc_encrypt(struct skcipher_request *req) -{ - return riscv64_aes_cbc_crypt(req, true); -} - -static int riscv64_aes_cbc_decrypt(struct skcipher_request *req) -{ - return riscv64_aes_cbc_crypt(req, false); -} - -/* AES-CBC-CTS */ - -static int riscv64_aes_cbc_cts_crypt(struct skcipher_request *req, bool enc) -{ - struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - const struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); - struct scatterlist sg_src[2], sg_dst[2]; - struct skcipher_request subreq; - struct scatterlist *src, *dst; - struct skcipher_walk walk; - unsigned int cbc_len; - int err; - - if (req->cryptlen < AES_BLOCK_SIZE) - return -EINVAL; - - err = skcipher_walk_virt(&walk, req, false); - if (err) - return err; - /* - * If the full message is available in one step, decrypt it in one call - * to the CBC-CTS assembly function. This reduces overhead, especially - * on short messages. Otherwise, fall back to doing CBC up to the last - * two blocks, then invoke CTS just for the ciphertext stealing. - */ - if (unlikely(walk.nbytes != req->cryptlen)) { - cbc_len = round_down(req->cryptlen - AES_BLOCK_SIZE - 1, - AES_BLOCK_SIZE); - skcipher_walk_abort(&walk); - skcipher_request_set_tfm(&subreq, tfm); - skcipher_request_set_callback(&subreq, - skcipher_request_flags(req), - NULL, NULL); - skcipher_request_set_crypt(&subreq, req->src, req->dst, - cbc_len, req->iv); - err = riscv64_aes_cbc_crypt(&subreq, enc); - if (err) - return err; - dst = src = scatterwalk_ffwd(sg_src, req->src, cbc_len); - if (req->dst != req->src) - dst = scatterwalk_ffwd(sg_dst, req->dst, cbc_len); - skcipher_request_set_crypt(&subreq, src, dst, - req->cryptlen - cbc_len, req->iv); - err = skcipher_walk_virt(&walk, &subreq, false); - if (err) - return err; - } - kernel_vector_begin(); - aes_cbc_cts_crypt_zvkned(ctx, walk.src.virt.addr, walk.dst.virt.addr, - walk.nbytes, req->iv, enc); - kernel_vector_end(); - return skcipher_walk_done(&walk, 0); -} - -static int riscv64_aes_cbc_cts_encrypt(struct skcipher_request *req) -{ - return riscv64_aes_cbc_cts_crypt(req, true); -} - -static int riscv64_aes_cbc_cts_decrypt(struct skcipher_request *req) -{ - return riscv64_aes_cbc_cts_crypt(req, false); -} - /* AES-CTR */ static int riscv64_aes_ctr_crypt(struct skcipher_request *req) @@ -366,41 +251,6 @@ static int riscv64_aes_xts_decrypt(struct skcipher_request *req) /* Algorithm definitions */ -static struct skcipher_alg riscv64_zvkned_aes_skcipher_algs[] = { - { - .setkey = riscv64_aes_setkey_skcipher, - .encrypt = riscv64_aes_cbc_encrypt, - .decrypt = riscv64_aes_cbc_decrypt, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .base = { - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct crypto_aes_ctx), - .cra_priority = 300, - .cra_name = "cbc(aes)", - .cra_driver_name = "cbc-aes-riscv64-zvkned", - .cra_module = THIS_MODULE, - }, - }, { - .setkey = riscv64_aes_setkey_skcipher, - .encrypt = riscv64_aes_cbc_cts_encrypt, - .decrypt = riscv64_aes_cbc_cts_decrypt, - .min_keysize = AES_MIN_KEY_SIZE, - .max_keysize = AES_MAX_KEY_SIZE, - .ivsize = AES_BLOCK_SIZE, - .walksize = 4 * AES_BLOCK_SIZE, /* matches LMUL=4 */ - .base = { - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct crypto_aes_ctx), - .cra_priority = 300, - .cra_name = "cts(cbc(aes))", - .cra_driver_name = "cts-cbc-aes-riscv64-zvkned", - .cra_module = THIS_MODULE, - }, - } -}; - static struct skcipher_alg riscv64_zvkned_zvkb_aes_skcipher_alg = { .setkey = riscv64_aes_setkey_skcipher, .encrypt = riscv64_aes_ctr_crypt, @@ -452,17 +302,11 @@ static int __init riscv64_aes_mod_init(void) if (riscv_isa_extension_available(NULL, ZVKNED) && riscv_vector_vlen() >= 128) { - err = crypto_register_skciphers( - riscv64_zvkned_aes_skcipher_algs, - ARRAY_SIZE(riscv64_zvkned_aes_skcipher_algs)); - if (err) - return err; - if (riscv_isa_extension_available(NULL, ZVKB)) { err = crypto_register_skcipher( &riscv64_zvkned_zvkb_aes_skcipher_alg); if (err) - goto unregister_zvkned_skcipher_algs; + return err; } if (riscv64_aes_xts_supported()) { @@ -478,9 +322,6 @@ static int __init riscv64_aes_mod_init(void) unregister_zvkned_zvkb_skcipher_alg: if (riscv_isa_extension_available(NULL, ZVKB)) crypto_unregister_skcipher(&riscv64_zvkned_zvkb_aes_skcipher_alg); -unregister_zvkned_skcipher_algs: - crypto_unregister_skciphers(riscv64_zvkned_aes_skcipher_algs, - ARRAY_SIZE(riscv64_zvkned_aes_skcipher_algs)); return err; } @@ -490,18 +331,14 @@ static void __exit riscv64_aes_mod_exit(void) crypto_unregister_skcipher(&riscv64_zvkned_zvbb_zvkg_aes_skcipher_alg); if (riscv_isa_extension_available(NULL, ZVKB)) crypto_unregister_skcipher(&riscv64_zvkned_zvkb_aes_skcipher_alg); - crypto_unregister_skciphers(riscv64_zvkned_aes_skcipher_algs, - ARRAY_SIZE(riscv64_zvkned_aes_skcipher_algs)); } module_init(riscv64_aes_mod_init); module_exit(riscv64_aes_mod_exit); -MODULE_DESCRIPTION("AES-CBC/CTS/CTR/XTS (RISC-V accelerated)"); +MODULE_DESCRIPTION("AES-CTR/XTS (RISC-V accelerated)"); MODULE_AUTHOR("Jerry Shih "); MODULE_LICENSE("GPL"); MODULE_ALIAS_CRYPTO("aes"); -MODULE_ALIAS_CRYPTO("cbc(aes)"); -MODULE_ALIAS_CRYPTO("cts(cbc(aes))"); MODULE_ALIAS_CRYPTO("ctr(aes)"); MODULE_ALIAS_CRYPTO("xts(aes)"); diff --git a/arch/riscv/crypto/aes-riscv64-zvkned.S b/arch/riscv/crypto/aes-riscv64-zvkned.S deleted file mode 100644 index 00f8a06596d3..000000000000 --- a/arch/riscv/crypto/aes-riscv64-zvkned.S +++ /dev/null @@ -1,273 +0,0 @@ -/* SPDX-License-Identifier: Apache-2.0 OR BSD-2-Clause */ -// -// This file is dual-licensed, meaning that you can use it under your -// choice of either of the following two licenses: -// -// Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. -// -// Licensed under the Apache License 2.0 (the "License"). You can obtain -// a copy in the file LICENSE in the source distribution or at -// https://www.openssl.org/source/license.html -// -// or -// -// Copyright (c) 2023, Christoph Müllner -// Copyright (c) 2023, Phoebe Chen -// Copyright (c) 2023, Jerry Shih -// Copyright 2024 Google LLC -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions -// are met: -// 1. Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// The generated code of this file depends on the following RISC-V extensions: -// - RV64I -// - RISC-V Vector ('V') with VLEN >= 128 -// - RISC-V Vector AES block cipher extension ('Zvkned') - -#include - -.text -.option arch, +zvkned - -#include "aes-macros.S" - -#define KEYP a0 -#define INP a1 -#define OUTP a2 -#define LEN a3 -#define IVP a4 - -.macro aes_cbc_encrypt keylen - vle32.v v16, (IVP) // Load IV -1: - vle32.v v17, (INP) // Load plaintext block - vxor.vv v16, v16, v17 // XOR with IV or prev ciphertext block - aes_encrypt v16, \keylen // Encrypt - vse32.v v16, (OUTP) // Store ciphertext block - addi INP, INP, 16 - addi OUTP, OUTP, 16 - addi LEN, LEN, -16 - bnez LEN, 1b - - vse32.v v16, (IVP) // Store next IV - ret -.endm - -.macro aes_cbc_decrypt keylen - srli LEN, LEN, 2 // Convert LEN from bytes to words - vle32.v v16, (IVP) // Load IV -1: - vsetvli t0, LEN, e32, m4, ta, ma - vle32.v v20, (INP) // Load ciphertext blocks - vslideup.vi v16, v20, 4 // Setup prev ciphertext blocks - addi t1, t0, -4 - vslidedown.vx v24, v20, t1 // Save last ciphertext block - aes_decrypt v20, \keylen // Decrypt the blocks - vxor.vv v20, v20, v16 // XOR with prev ciphertext blocks - vse32.v v20, (OUTP) // Store plaintext blocks - vmv.v.v v16, v24 // Next "IV" is last ciphertext block - slli t1, t0, 2 // Words to bytes - add INP, INP, t1 - add OUTP, OUTP, t1 - sub LEN, LEN, t0 - bnez LEN, 1b - - vsetivli zero, 4, e32, m1, ta, ma - vse32.v v16, (IVP) // Store next IV - ret -.endm - -// void aes_cbc_encrypt_zvkned(const struct crypto_aes_ctx *key, -// const u8 *in, u8 *out, size_t len, u8 iv[16]); -// -// |len| must be nonzero and a multiple of 16 (AES_BLOCK_SIZE). -SYM_FUNC_START(aes_cbc_encrypt_zvkned) - aes_begin KEYP, 128f, 192f - aes_cbc_encrypt 256 -128: - aes_cbc_encrypt 128 -192: - aes_cbc_encrypt 192 -SYM_FUNC_END(aes_cbc_encrypt_zvkned) - -// Same prototype and calling convention as the encryption function -SYM_FUNC_START(aes_cbc_decrypt_zvkned) - aes_begin KEYP, 128f, 192f - aes_cbc_decrypt 256 -128: - aes_cbc_decrypt 128 -192: - aes_cbc_decrypt 192 -SYM_FUNC_END(aes_cbc_decrypt_zvkned) - -.macro aes_cbc_cts_encrypt keylen - - // CBC-encrypt all blocks except the last. But don't store the - // second-to-last block to the output buffer yet, since it will be - // handled specially in the ciphertext stealing step. Exception: if the - // message is single-block, still encrypt the last (and only) block. - li t0, 16 - j 2f -1: - vse32.v v16, (OUTP) // Store ciphertext block - addi OUTP, OUTP, 16 -2: - vle32.v v17, (INP) // Load plaintext block - vxor.vv v16, v16, v17 // XOR with IV or prev ciphertext block - aes_encrypt v16, \keylen // Encrypt - addi INP, INP, 16 - addi LEN, LEN, -16 - bgt LEN, t0, 1b // Repeat if more than one block remains - - // Special case: if the message is a single block, just do CBC. - beqz LEN, .Lcts_encrypt_done\@ - - // Encrypt the last two blocks using ciphertext stealing as follows: - // C[n-1] = Encrypt(Encrypt(P[n-1] ^ C[n-2]) ^ P[n]) - // C[n] = Encrypt(P[n-1] ^ C[n-2])[0..LEN] - // - // C[i] denotes the i'th ciphertext block, and likewise P[i] the i'th - // plaintext block. Block n, the last block, may be partial; its length - // is 1 <= LEN <= 16. If there are only 2 blocks, C[n-2] means the IV. - // - // v16 already contains Encrypt(P[n-1] ^ C[n-2]). - // INP points to P[n]. OUTP points to where C[n-1] should go. - // To support in-place encryption, load P[n] before storing C[n]. - addi t0, OUTP, 16 // Get pointer to where C[n] should go - vsetvli zero, LEN, e8, m1, tu, ma - vle8.v v17, (INP) // Load P[n] - vse8.v v16, (t0) // Store C[n] - vxor.vv v16, v16, v17 // v16 = Encrypt(P[n-1] ^ C[n-2]) ^ P[n] - vsetivli zero, 4, e32, m1, ta, ma - aes_encrypt v16, \keylen -.Lcts_encrypt_done\@: - vse32.v v16, (OUTP) // Store C[n-1] (or C[n] in single-block case) - ret -.endm - -#define LEN32 t4 // Length of remaining full blocks in 32-bit words -#define LEN_MOD16 t5 // Length of message in bytes mod 16 - -.macro aes_cbc_cts_decrypt keylen - andi LEN32, LEN, ~15 - srli LEN32, LEN32, 2 - andi LEN_MOD16, LEN, 15 - - // Save C[n-2] in v28 so that it's available later during the ciphertext - // stealing step. If there are fewer than three blocks, C[n-2] means - // the IV, otherwise it means the third-to-last ciphertext block. - vmv.v.v v28, v16 // IV - add t0, LEN, -33 - bltz t0, .Lcts_decrypt_loop\@ - andi t0, t0, ~15 - add t0, t0, INP - vle32.v v28, (t0) - - // CBC-decrypt all full blocks. For the last full block, or the last 2 - // full blocks if the message is block-aligned, this doesn't write the - // correct output blocks (unless the message is only a single block), - // because it XORs the wrong values with the raw AES plaintexts. But we - // fix this after this loop without redoing the AES decryptions. This - // approach allows more of the AES decryptions to be parallelized. -.Lcts_decrypt_loop\@: - vsetvli t0, LEN32, e32, m4, ta, ma - addi t1, t0, -4 - vle32.v v20, (INP) // Load next set of ciphertext blocks - vmv.v.v v24, v16 // Get IV or last ciphertext block of prev set - vslideup.vi v24, v20, 4 // Setup prev ciphertext blocks - vslidedown.vx v16, v20, t1 // Save last ciphertext block of this set - aes_decrypt v20, \keylen // Decrypt this set of blocks - vxor.vv v24, v24, v20 // XOR prev ciphertext blocks with decrypted blocks - vse32.v v24, (OUTP) // Store this set of plaintext blocks - sub LEN32, LEN32, t0 - slli t0, t0, 2 // Words to bytes - add INP, INP, t0 - add OUTP, OUTP, t0 - bnez LEN32, .Lcts_decrypt_loop\@ - - vsetivli zero, 4, e32, m4, ta, ma - vslidedown.vx v20, v20, t1 // Extract raw plaintext of last full block - addi t0, OUTP, -16 // Get pointer to last full plaintext block - bnez LEN_MOD16, .Lcts_decrypt_non_block_aligned\@ - - // Special case: if the message is a single block, just do CBC. - li t1, 16 - beq LEN, t1, .Lcts_decrypt_done\@ - - // Block-aligned message. Just fix up the last 2 blocks. We need: - // - // P[n-1] = Decrypt(C[n]) ^ C[n-2] - // P[n] = Decrypt(C[n-1]) ^ C[n] - // - // We have C[n] in v16, Decrypt(C[n]) in v20, and C[n-2] in v28. - // Together with Decrypt(C[n-1]) ^ C[n-2] from the output buffer, this - // is everything needed to fix the output without re-decrypting blocks. - addi t1, OUTP, -32 // Get pointer to where P[n-1] should go - vxor.vv v20, v20, v28 // Decrypt(C[n]) ^ C[n-2] == P[n-1] - vle32.v v24, (t1) // Decrypt(C[n-1]) ^ C[n-2] - vse32.v v20, (t1) // Store P[n-1] - vxor.vv v20, v24, v16 // Decrypt(C[n-1]) ^ C[n-2] ^ C[n] == P[n] ^ C[n-2] - j .Lcts_decrypt_finish\@ - -.Lcts_decrypt_non_block_aligned\@: - // Decrypt the last two blocks using ciphertext stealing as follows: - // - // P[n-1] = Decrypt(C[n] || Decrypt(C[n-1])[LEN_MOD16..16]) ^ C[n-2] - // P[n] = (Decrypt(C[n-1]) ^ C[n])[0..LEN_MOD16] - // - // We already have Decrypt(C[n-1]) in v20 and C[n-2] in v28. - vmv.v.v v16, v20 // v16 = Decrypt(C[n-1]) - vsetvli zero, LEN_MOD16, e8, m1, tu, ma - vle8.v v20, (INP) // v20 = C[n] || Decrypt(C[n-1])[LEN_MOD16..16] - vxor.vv v16, v16, v20 // v16 = Decrypt(C[n-1]) ^ C[n] - vse8.v v16, (OUTP) // Store P[n] - vsetivli zero, 4, e32, m1, ta, ma - aes_decrypt v20, \keylen // v20 = Decrypt(C[n] || Decrypt(C[n-1])[LEN_MOD16..16]) -.Lcts_decrypt_finish\@: - vxor.vv v20, v20, v28 // XOR with C[n-2] - vse32.v v20, (t0) // Store last full plaintext block -.Lcts_decrypt_done\@: - ret -.endm - -.macro aes_cbc_cts_crypt keylen - vle32.v v16, (IVP) // Load IV - beqz a5, .Lcts_decrypt\@ - aes_cbc_cts_encrypt \keylen -.Lcts_decrypt\@: - aes_cbc_cts_decrypt \keylen -.endm - -// void aes_cbc_cts_crypt_zvkned(const struct crypto_aes_ctx *key, -// const u8 *in, u8 *out, size_t len, -// const u8 iv[16], bool enc); -// -// Encrypts or decrypts a message with the CS3 variant of AES-CBC-CTS. -// This is the variant that unconditionally swaps the last two blocks. -SYM_FUNC_START(aes_cbc_cts_crypt_zvkned) - aes_begin KEYP, 128f, 192f - aes_cbc_cts_crypt 256 -128: - aes_cbc_cts_crypt 128 -192: - aes_cbc_cts_crypt 192 -SYM_FUNC_END(aes_cbc_cts_crypt_zvkned) diff --git a/crypto/aes.c b/crypto/aes.c index 9b9e5b413fc4..1daaa59d0cdf 100644 --- a/crypto/aes.c +++ b/crypto/aes.c @@ -626,7 +626,8 @@ static struct skcipher_alg skcipher_algs[] = { { .base.cra_name = "cbc(aes)", .base.cra_driver_name = "cbc-aes-lib", - .base.cra_priority = IS_ENABLED(CONFIG_X86) ? 300 : 110, + .base.cra_priority = (IS_ENABLED(CONFIG_RISCV) || + IS_ENABLED(CONFIG_X86)) ? 300 : 110, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct aes_key), .base.cra_module = THIS_MODULE, @@ -652,7 +653,8 @@ static struct skcipher_alg skcipher_algs[] = { { .base.cra_name = "cts(cbc(aes))", .base.cra_driver_name = "cts-cbc-aes-lib", - .base.cra_priority = IS_ENABLED(CONFIG_X86) ? 300 : 110, + .base.cra_priority = (IS_ENABLED(CONFIG_RISCV) || + IS_ENABLED(CONFIG_X86)) ? 300 : 110, .base.cra_blocksize = AES_BLOCK_SIZE, .base.cra_ctxsize = sizeof(struct aes_key), .base.cra_module = THIS_MODULE, diff --git a/lib/crypto/riscv/aes-riscv64-zvkned.S b/lib/crypto/riscv/aes-riscv64-zvkned.S index 3700028e62ea..61c1f185c33d 100644 --- a/lib/crypto/riscv/aes-riscv64-zvkned.S +++ b/lib/crypto/riscv/aes-riscv64-zvkned.S @@ -132,3 +132,238 @@ SYM_FUNC_END(aes_ecb_encrypt_zvkned) SYM_FUNC_START(aes_ecb_decrypt_zvkned) aes_ecb_crypt 0 SYM_FUNC_END(aes_ecb_decrypt_zvkned) + +#undef DST +#undef SRC +#undef LEN +#undef KEYP + +#define DST a0 +#define SRC a1 +#define LEN a2 +#define IVP a3 +#define KEYP a4 + +.macro aes_cbc_encrypt keylen + vle32.v v16, (IVP) // Load IV +1: + vle32.v v17, (SRC) // Load plaintext block + vxor.vv v16, v16, v17 // XOR with IV or prev ciphertext block + aes_encrypt v16, \keylen // Encrypt + vse32.v v16, (DST) // Store ciphertext block + addi SRC, SRC, 16 + addi DST, DST, 16 + addi LEN, LEN, -16 + bnez LEN, 1b + + vse32.v v16, (IVP) // Store next IV + ret +.endm + +.macro aes_cbc_decrypt keylen + srli LEN, LEN, 2 // Convert LEN from bytes to words + vle32.v v16, (IVP) // Load IV +1: + vsetvli t0, LEN, e32, m4, ta, ma + vle32.v v20, (SRC) // Load ciphertext blocks + vslideup.vi v16, v20, 4 // Setup prev ciphertext blocks + addi t1, t0, -4 + vslidedown.vx v24, v20, t1 // Save last ciphertext block + aes_decrypt v20, \keylen // Decrypt the blocks + vxor.vv v20, v20, v16 // XOR with prev ciphertext blocks + vse32.v v20, (DST) // Store plaintext blocks + vmv.v.v v16, v24 // Next "IV" is last ciphertext block + slli t1, t0, 2 // Words to bytes + add SRC, SRC, t1 + add DST, DST, t1 + sub LEN, LEN, t0 + bnez LEN, 1b + + vsetivli zero, 4, e32, m1, ta, ma + vse32.v v16, (IVP) // Store next IV + ret +.endm + +// void aes_cbc_encrypt_zvkned(u8 *dst, const u8 *src, size_t len, +// u8 iv[AES_BLOCK_SIZE], +// const struct aes_enckey *key); +// +// |len| must be nonzero and a multiple of 16 (AES_BLOCK_SIZE). +SYM_FUNC_START(aes_cbc_encrypt_zvkned) + aes_begin KEYP, 128f, 192f + aes_cbc_encrypt 256 +128: + aes_cbc_encrypt 128 +192: + aes_cbc_encrypt 192 +SYM_FUNC_END(aes_cbc_encrypt_zvkned) + +// void aes_cbc_decrypt_zvkned(u8 *dst, const u8 *src, size_t len, +// u8 iv[AES_BLOCK_SIZE], +// const struct aes_key *key); +// +// |len| must be nonzero and a multiple of 16 (AES_BLOCK_SIZE). +SYM_FUNC_START(aes_cbc_decrypt_zvkned) + aes_begin KEYP, 128f, 192f + aes_cbc_decrypt 256 +128: + aes_cbc_decrypt 128 +192: + aes_cbc_decrypt 192 +SYM_FUNC_END(aes_cbc_decrypt_zvkned) + +#undef DST +#undef SRC +#undef LEN +#undef IVP +#undef KEYP + +#define DST a0 +#define SRC a1 +#define LEN a2 +#define IVP a3 +#define KEYP a4 +#define ENC a5 + +.macro aes_cbc_cts_encrypt keylen + + // CBC-encrypt all blocks except the last. But don't store the + // second-to-last block to the output buffer yet, since it will be + // handled specially in the ciphertext stealing step. + li t0, 16 + j 2f +1: + vse32.v v16, (DST) // Store ciphertext block + addi DST, DST, 16 +2: + vle32.v v17, (SRC) // Load plaintext block + vxor.vv v16, v16, v17 // XOR with IV or prev ciphertext block + aes_encrypt v16, \keylen // Encrypt + addi SRC, SRC, 16 + addi LEN, LEN, -16 + bgt LEN, t0, 1b // Repeat if more than one block remains + + // Encrypt the last two blocks using ciphertext stealing as follows: + // C[n-1] = Encrypt(Encrypt(P[n-1] ^ C[n-2]) ^ P[n]) + // C[n] = Encrypt(P[n-1] ^ C[n-2])[0..LEN] + // + // C[i] denotes the i'th ciphertext block, and likewise P[i] the i'th + // plaintext block. Block n, the last block, may be partial; its length + // is 1 <= LEN <= 16. If there are only 2 blocks, C[n-2] means the IV. + // + // v16 already contains Encrypt(P[n-1] ^ C[n-2]). + // SRC points to P[n]. DST points to where C[n-1] should go. + // To support in-place encryption, load P[n] before storing C[n]. + addi t0, DST, 16 // Get pointer to where C[n] should go + vsetvli zero, LEN, e8, m1, tu, ma + vle8.v v17, (SRC) // Load P[n] + vse8.v v16, (t0) // Store C[n] + vxor.vv v16, v16, v17 // v16 = Encrypt(P[n-1] ^ C[n-2]) ^ P[n] + vsetivli zero, 4, e32, m1, ta, ma + aes_encrypt v16, \keylen + vse32.v v16, (DST) // Store C[n-1] + ret +.endm + +#define LEN32 t4 // Length of remaining full blocks in 32-bit words +#define LEN_MOD16 t5 // Length of message in bytes mod 16 + +.macro aes_cbc_cts_decrypt keylen + andi LEN32, LEN, ~15 + srli LEN32, LEN32, 2 + andi LEN_MOD16, LEN, 15 + + // Save C[n-2] in v28 so that it's available later during the ciphertext + // stealing step. If there are fewer than three blocks, C[n-2] means + // the IV, otherwise it means the third-to-last ciphertext block. + vmv.v.v v28, v16 // IV + add t0, LEN, -33 + bltz t0, .Lcts_decrypt_loop\@ + andi t0, t0, ~15 + add t0, t0, SRC + vle32.v v28, (t0) + + // CBC-decrypt all full blocks. For the last full block, or the last 2 + // full blocks if the message is block-aligned, this doesn't write the + // correct output blocks, because it XORs the wrong values with the raw + // AES plaintexts. But we fix this after this loop without redoing the + // AES decryptions. This approach allows more of the AES decryptions to + // be parallelized. +.Lcts_decrypt_loop\@: + vsetvli t0, LEN32, e32, m4, ta, ma + addi t1, t0, -4 + vle32.v v20, (SRC) // Load next set of ciphertext blocks + vmv.v.v v24, v16 // Get IV or last ciphertext block of prev set + vslideup.vi v24, v20, 4 // Setup prev ciphertext blocks + vslidedown.vx v16, v20, t1 // Save last ciphertext block of this set + aes_decrypt v20, \keylen // Decrypt this set of blocks + vxor.vv v24, v24, v20 // XOR prev ciphertext blocks with decrypted blocks + vse32.v v24, (DST) // Store this set of plaintext blocks + sub LEN32, LEN32, t0 + slli t0, t0, 2 // Words to bytes + add SRC, SRC, t0 + add DST, DST, t0 + bnez LEN32, .Lcts_decrypt_loop\@ + + vsetivli zero, 4, e32, m4, ta, ma + vslidedown.vx v20, v20, t1 // Extract raw plaintext of last full block + addi t0, DST, -16 // Get pointer to last full plaintext block + bnez LEN_MOD16, .Lcts_decrypt_non_block_aligned\@ + + // Block-aligned message. Just fix up the last 2 blocks. We need: + // + // P[n-1] = Decrypt(C[n]) ^ C[n-2] + // P[n] = Decrypt(C[n-1]) ^ C[n] + // + // We have C[n] in v16, Decrypt(C[n]) in v20, and C[n-2] in v28. + // Together with Decrypt(C[n-1]) ^ C[n-2] from the output buffer, this + // is everything needed to fix the output without re-decrypting blocks. + addi t1, DST, -32 // Get pointer to where P[n-1] should go + vxor.vv v20, v20, v28 // Decrypt(C[n]) ^ C[n-2] == P[n-1] + vle32.v v24, (t1) // Decrypt(C[n-1]) ^ C[n-2] + vse32.v v20, (t1) // Store P[n-1] + vxor.vv v20, v24, v16 // Decrypt(C[n-1]) ^ C[n-2] ^ C[n] == P[n] ^ C[n-2] + j .Lcts_decrypt_finish\@ + +.Lcts_decrypt_non_block_aligned\@: + // Decrypt the last two blocks using ciphertext stealing as follows: + // + // P[n-1] = Decrypt(C[n] || Decrypt(C[n-1])[LEN_MOD16..16]) ^ C[n-2] + // P[n] = (Decrypt(C[n-1]) ^ C[n])[0..LEN_MOD16] + // + // We already have Decrypt(C[n-1]) in v20 and C[n-2] in v28. + vmv.v.v v16, v20 // v16 = Decrypt(C[n-1]) + vsetvli zero, LEN_MOD16, e8, m1, tu, ma + vle8.v v20, (SRC) // v20 = C[n] || Decrypt(C[n-1])[LEN_MOD16..16] + vxor.vv v16, v16, v20 // v16 = Decrypt(C[n-1]) ^ C[n] + vse8.v v16, (DST) // Store P[n] + vsetivli zero, 4, e32, m1, ta, ma + aes_decrypt v20, \keylen // v20 = Decrypt(C[n] || Decrypt(C[n-1])[LEN_MOD16..16]) +.Lcts_decrypt_finish\@: + vxor.vv v20, v20, v28 // XOR with C[n-2] + vse32.v v20, (t0) // Store last full plaintext block + ret +.endm + +.macro aes_cbc_cts_crypt keylen + vle32.v v16, (IVP) // Load IV + beqz ENC, .Lcts_decrypt\@ + aes_cbc_cts_encrypt \keylen +.Lcts_decrypt\@: + aes_cbc_cts_decrypt \keylen +.endm + +// void aes_cbc_cts_crypt_zvkned(u8 *dst, const u8 *src, size_t len, +// const u8 iv[AES_BLOCK_SIZE], +// aes_encrypt_arg key, bool enc); +// +// Encrypts or decrypts len >= 17 bytes of data using the CS3 variant of +// AES-CBC-CTS. This is the variant that always swaps the last two blocks. +SYM_FUNC_START(aes_cbc_cts_crypt_zvkned) + aes_begin KEYP, 128f, 192f + aes_cbc_cts_crypt 256 +128: + aes_cbc_cts_crypt 128 +192: + aes_cbc_cts_crypt 192 +SYM_FUNC_END(aes_cbc_cts_crypt_zvkned) diff --git a/lib/crypto/riscv/aes.h b/lib/crypto/riscv/aes.h index 5b36d0147d93..150cda82cb89 100644 --- a/lib/crypto/riscv/aes.h +++ b/lib/crypto/riscv/aes.h @@ -93,6 +93,74 @@ static bool aes_ecb_decrypt_arch(u8 *dst, const u8 *src, size_t len, } #endif /* CONFIG_CRYPTO_LIB_AES_ECB */ +#if IS_ENABLED(CONFIG_CRYPTO_LIB_AES_CBC) +void aes_cbc_encrypt_zvkned(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], const struct aes_enckey *key); +void aes_cbc_decrypt_zvkned(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], const struct aes_key *key); +void aes_cbc_cts_crypt_zvkned(u8 *dst, const u8 *src, size_t len, + const u8 iv[AES_BLOCK_SIZE], + aes_encrypt_arg key, bool enc); + +/* len is always a positive multiple of AES_BLOCK_SIZE here. */ +#define aes_cbc_encrypt_arch aes_cbc_encrypt_arch +static bool aes_cbc_encrypt_arch(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], + const struct aes_enckey *key) +{ + if (!static_branch_likely(&have_zvkned) || unlikely(!may_use_simd())) + return false; + kernel_vector_begin(); + aes_cbc_encrypt_zvkned(dst, src, len, iv, key); + kernel_vector_end(); + return true; +} + +/* len is always a positive multiple of AES_BLOCK_SIZE here. */ +#define aes_cbc_decrypt_arch aes_cbc_decrypt_arch +static bool aes_cbc_decrypt_arch(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], + const struct aes_key *key) +{ + if (!static_branch_likely(&have_zvkned) || unlikely(!may_use_simd())) + return false; + kernel_vector_begin(); + aes_cbc_decrypt_zvkned(dst, src, len, iv, key); + kernel_vector_end(); + return true; +} + +/* len can be any value greater than AES_BLOCK_SIZE here. */ +#define aes_cbc_cts_encrypt_arch aes_cbc_cts_encrypt_arch +static bool aes_cbc_cts_encrypt_arch(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], + const struct aes_enckey *key) +{ + if (!static_branch_likely(&have_zvkned) || unlikely(!may_use_simd())) + return false; + + kernel_vector_begin(); + aes_cbc_cts_crypt_zvkned(dst, src, len, iv, key, true); + kernel_vector_end(); + return true; +} + +/* len can be any value greater than AES_BLOCK_SIZE here. */ +#define aes_cbc_cts_decrypt_arch aes_cbc_cts_decrypt_arch +static bool aes_cbc_cts_decrypt_arch(u8 *dst, const u8 *src, size_t len, + u8 iv[AES_BLOCK_SIZE], + const struct aes_key *key) +{ + if (!static_branch_likely(&have_zvkned) || unlikely(!may_use_simd())) + return false; + + kernel_vector_begin(); + aes_cbc_cts_crypt_zvkned(dst, src, len, iv, key, false); + kernel_vector_end(); + return true; +} +#endif /* CONFIG_CRYPTO_LIB_AES_CBC */ + #define aes_mod_init_arch aes_mod_init_arch static void aes_mod_init_arch(void) { -- 2.55.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 99462CA5FA4 for ; Sun, 27 Sep 2026 22:45:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=mtUWt894Q+WP/xGKv9aZgnBj8Hjqk6xJPDtLnGcl/w0=; b=rur6Dx0T0DiPkZ /5FIyZPyQQh4nuf4dTWe1Js/p6YYvli/aQgGUuWD04B2sF5K/T0cchjUAXd+qIpjtshByQPTzjEgo K4kFf8FV72wjqBtx/Z6Qnds8NA+VDRQ53mZddycDynkxybScYGUSOOOdiwtoU+pqdDKrxTpe+PCUw f4gLR1Zip+TZmkzycyIln3KQRLpc4Drt86vWCQRWZ7U0dncGzeJ5hGFSv0ZmgdfiR+u5UJPeN1nqI FdknMZFfYUViIxeCZrk3Nw7PLs7XNNJj7/BlY4EyDxpDn2ioUnBlQ+WTTg9c3V+KEuG0FmgODSXy5 a4ndFrKTG6dpPWdmyG9Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xAxcJ-0000000Gwkl-0rTq; Sun, 27 Sep 2026 22:45:07 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1xAxby-0000000GwSx-0FmL for linux-riscv@lists.infradead.org; Sun, 27 Sep 2026 22:44:46 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id CA705444ED; Sun, 27 Sep 2026 22:44:45 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 73A231F0089A; Sun, 27 Sep 2026 22:44:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1790549085; bh=/KgPf7qOImf02WNBc/Vis1MwsFR/IDPErtkbwnucFog=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=bxNptmOd/heJQcxhNrsEGeLA7P8vZ287twXdNlVuFnsG48L1jyPnNCT09bGD2QrHz 22fMhmV/TDuLDaNLpebZfPmqUzc1HJrbkpzaU69g/qCWHuJ3FHnSCSAthsJ7Xgd2KX GxIm5wMGLDaUjumYebH6CFW1GZfNpm0Gd+M93uPzuu4x0t7XoIJ+S1I0pcG0dsrPj1 hSSJYd1JYdalcE/B9kqZdOxP8bfzpW+tPlrLadpssc5YfAs6mQ/tue4lpOfolRp25N RL9TOBPTknFnxYvfeCS7Uv5qhqmXi1dcsKoy7z3iIZhQDkFmA5O8rMJdAXkzVvUMOo w8rUDsO9/8WGg== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , "Jason A . Donenfeld" , Herbert Xu , x86@kernel.org, linux-riscv@lists.infradead.org, Eric Biggers Subject: [PATCH v2 18/20] lib/crypto: riscv/aes-cbc: Migrate optimized code into library Date: Sun, 27 Sep 2026 15:43:09 -0700 Message-ID: <20260927224418.109759-19-ebiggers@kernel.org> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260927224418.109759-1-ebiggers@kernel.org> References: <20260927224418.109759-1-ebiggers@kernel.org> MIME-Version: 1.0 X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org SW5zdGVhZCBvZiBleHBvc2luZyB0aGUgcmlzY3Ytb3B0aW1pemVkIEFFUy1DQkMgYW5kIEFFUy1D QkMtQ1RTIGNvZGUgdmlhCmEgcmlzY3Ytc3BlY2lmaWMgY3J5cHRvX3NrY2lwaGVyIGFsZ29yaXRo bSwganVzdCBpbXBsZW1lbnQgdGhlIEFFUy1DQkMKYW5kIEFFUy1DQkMtQ1RTIGxpYnJhcnkgZnVu Y3Rpb25zLiAgVGhpcyBpcyBzaW1wbGVyLCBpdCBtYWtlcyB0aGUKQUVTLUNCQyBhbmQgQUVTLUNC Qy1DVFMgbGlicmFyeSBmdW5jdGlvbnMgYmUgcmlzY3Ytb3B0aW1pemVkLCBhbmQgaXQKYWxzbyBm aXhlcyB0aGUgbG9uZ3N0YW5kaW5nIGlzc3VlIHdoZXJlIHRoZSByaXNjdi1vcHRpbWl6ZWQgQUVT LUNCQyBhbmQKQUVTLUNCQy1DVFMgY29kZSB3YXMgZGlzYWJsZWQgYnkgZGVmYXVsdC4gIEFFUy1D QkMgYW5kIEFFUy1DQkMtQ1RTCnN1cHBvcnQgc3RpbGwgcmVtYWlucyBhdmFpbGFibGUgdGhyb3Vn aCBjcnlwdG9fc2tjaXBoZXIgdmlhCmNyeXB0by9hZXMuYywgYnV0IGluZGl2aWR1YWwgYXJjaGl0 ZWN0dXJlcyBubyBsb25nZXIgbmVlZCB0byBoYW5kbGUgaXQuCgpUbyBtYXRjaCB3aGF0IHRoZSBs aWJyYXJ5IGV4cGVjdHMsIHVwZGF0ZSB0aGUgYXNzZW1ibHkgZnVuY3Rpb25zIHRvCm9wZXJhdGUg b24gc3RydWN0IGFlc19lbmNrZXkgb3Igc3RydWN0IGFlc19rZXkgcmF0aGVyIHRoYW4gc3RydWN0 CmNyeXB0b19hZXNfY3R4LCBhbmQgYWRqdXN0IHRoZSBhcmd1bWVudCBvcmRlci4KClJlbW92ZSB0 aGUgc2luZ2xlLWJsb2NrIHNwZWNpYWwgY2FzZSBmcm9tIHRoZSBhc3NlbWJseSBjb2RlLCBzaW5j ZSBpdCdzCmFscmVhZHkgaGFuZGxlZCBieSBsaWIvY3J5cHRvL2Flcy5jIGJlZm9yZSBjYWxsaW5n IGFlc19jYmNfY3RzXypfYXJjaCgpLgoKQnVtcCB1cCB0aGUgcHJpb3JpdHkgb2YgdGhlIGNvcnJl c3BvbmRpbmcgbGlicmFyeS1iYXNlZCBhbGdvcml0aG1zIG9uCnJpc2N2IG5vdyB0aGF0IHRoZXkg bm8gbG9uZ2VyIGhhdmUgdG8gYmUgbG93ZXIgdGhhbiBhcmNoL3Jpc2N2L2NyeXB0by8uCgpTaWdu ZWQtb2ZmLWJ5OiBFcmljIEJpZ2dlcnMgPGViaWdnZXJzQGtlcm5lbC5vcmc+Ci0tLQogYXJjaC9y aXNjdi9jcnlwdG8vS2NvbmZpZyAgICAgICAgICAgICAgfCAgIDQgKy0KIGFyY2gvcmlzY3YvY3J5 cHRvL01ha2VmaWxlICAgICAgICAgICAgIHwgICAyICstCiBhcmNoL3Jpc2N2L2NyeXB0by9hZXMt cmlzY3Y2NC1nbHVlLmMgICB8IDE2NyArLS0tLS0tLS0tLS0tLS0KIGFyY2gvcmlzY3YvY3J5cHRv L2Flcy1yaXNjdjY0LXp2a25lZC5TIHwgMjczIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGNy eXB0by9hZXMuYyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICstCiBsaWIvY3J5cHRv L3Jpc2N2L2Flcy1yaXNjdjY0LXp2a25lZC5TICB8IDIzNSArKysrKysrKysrKysrKysrKysrKysK IGxpYi9jcnlwdG8vcmlzY3YvYWVzLmggICAgICAgICAgICAgICAgIHwgIDY4ICsrKysrKwogNyBm aWxlcyBjaGFuZ2VkLCAzMTIgaW5zZXJ0aW9ucygrKSwgNDQzIGRlbGV0aW9ucygtKQogZGVsZXRl IG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LXp2a25lZC5TCgpkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZyBiL2FyY2gvcmlzY3YvY3J5cHRvL0tj b25maWcKaW5kZXggODRjNDE4MjRiNDMzLi4wYTNmODdhZDM4NGUgMTAwNjQ0Ci0tLSBhL2FyY2gv cmlzY3YvY3J5cHRvL0tjb25maWcKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZwpAQCAt MywxMyArMywxMyBAQAogbWVudSAiQWNjZWxlcmF0ZWQgQ3J5cHRvZ3JhcGhpYyBBbGdvcml0aG1z IGZvciBDUFUgKHJpc2N2KSIKIAogY29uZmlnIENSWVBUT19BRVNfUklTQ1Y2NAotCXRyaXN0YXRl ICJDaXBoZXJzOiBBRVMsIG1vZGVzOiBDQkMsIENUUywgQ1RSLCBYVFMiCisJdHJpc3RhdGUgIkNp cGhlcnM6IEFFUywgbW9kZXM6IENUUiwgWFRTIgogCWRlcGVuZHMgb24gNjRCSVQgJiYgVE9PTENI QUlOX0hBU19WRUNUT1JfQ1JZUFRPICYmIFwKIAkJICAgUklTQ1ZfRUZGSUNJRU5UX1ZFQ1RPUl9V TkFMSUdORURfQUNDRVNTCiAJc2VsZWN0IENSWVBUT19MSUJfQUVTCiAJc2VsZWN0IENSWVBUT19T S0NJUEhFUgogCWhlbHAKLQkgIExlbmd0aC1wcmVzZXJ2aW5nIGNpcGhlcnM6IEFFUyB3aXRoIENC QywgQ1RTLCBDVFIsIFhUUworCSAgTGVuZ3RoLXByZXNlcnZpbmcgY2lwaGVyczogQUVTIHdpdGgg Q1RSLCBYVFMKIAogCSAgQXJjaGl0ZWN0dXJlOiByaXNjdjY0IHVzaW5nOgogCSAgLSBadmtuZWQg dmVjdG9yIGNyeXB0byBleHRlbnNpb24KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL01h a2VmaWxlIGIvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUKaW5kZXggOGNmMzFkYjU3ZmM0Li5k OGI4NWFmYTZkMGIgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCisrKyBi L2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlCkBAIC0xLDcgKzEsNyBAQAogIyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CiAKIG9iai0kKENPTkZJR19DUllQVE9fQUVTX1JJ U0NWNjQpICs9IGFlcy1yaXNjdjY0Lm8KLWFlcy1yaXNjdjY0LXkgOj0gYWVzLXJpc2N2NjQtZ2x1 ZS5vIGFlcy1yaXNjdjY0LXp2a25lZC5vIFwKK2Flcy1yaXNjdjY0LXkgOj0gYWVzLXJpc2N2NjQt Z2x1ZS5vIFwKIAkJIGFlcy1yaXNjdjY0LXp2a25lZC16dmJiLXp2a2cubyBhZXMtcmlzY3Y2NC16 dmtuZWQtenZrYi5vCiAKIG9iai0kKENPTkZJR19DUllQVE9fU000X1JJU0NWNjQpICs9IHNtNC1y aXNjdjY0Lm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUu YyBiL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUuYwppbmRleCBmN2M0OTJkY2Zk NTcuLjk3ZjUzNjlkN2U3MSAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2 NjQtZ2x1ZS5jCisrKyBiL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUuYwpAQCAt MjIsMTcgKzIyLDYgQEAKICNpbmNsdWRlIDxsaW51eC9taW5tYXguaD4KICNpbmNsdWRlIDxsaW51 eC9tb2R1bGUuaD4KIAotYXNtbGlua2FnZSB2b2lkIGFlc19jYmNfZW5jcnlwdF96dmtuZWQoY29u c3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4ICprZXksCi0JCQkJICAgICAgIGNvbnN0IHU4ICppbiwg dTggKm91dCwgc2l6ZV90IGxlbiwKLQkJCQkgICAgICAgdTggaXZbQUVTX0JMT0NLX1NJWkVdKTsK LWFzbWxpbmthZ2Ugdm9pZCBhZXNfY2JjX2RlY3J5cHRfenZrbmVkKGNvbnN0IHN0cnVjdCBjcnlw dG9fYWVzX2N0eCAqa2V5LAotCQkJCSAgICAgICBjb25zdCB1OCAqaW4sIHU4ICpvdXQsIHNpemVf dCBsZW4sCi0JCQkJICAgICAgIHU4IGl2W0FFU19CTE9DS19TSVpFXSk7Ci0KLWFzbWxpbmthZ2Ug dm9pZCBhZXNfY2JjX2N0c19jcnlwdF96dmtuZWQoY29uc3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4 ICprZXksCi0JCQkJCSBjb25zdCB1OCAqaW4sIHU4ICpvdXQsIHNpemVfdCBsZW4sCi0JCQkJCSBj b25zdCB1OCBpdltBRVNfQkxPQ0tfU0laRV0sIGJvb2wgZW5jKTsKLQogYXNtbGlua2FnZSB2b2lk IGFlc19jdHIzMl9jcnlwdF96dmtuZWRfenZrYihjb25zdCBzdHJ1Y3QgY3J5cHRvX2Flc19jdHgg KmtleSwKIAkJCQkJICAgIGNvbnN0IHU4ICppbiwgdTggKm91dCwgc2l6ZV90IGxlbiwKIAkJCQkJ ICAgIHU4IGl2W0FFU19CTE9DS19TSVpFXSk7CkBAIC04MSwxMTAgKzcwLDYgQEAgc3RhdGljIGlu dCByaXNjdjY0X2Flc19zZXRrZXlfc2tjaXBoZXIoc3RydWN0IGNyeXB0b19za2NpcGhlciAqdGZt LAogCXJldHVybiByaXNjdjY0X2Flc19zZXRrZXkoY3R4LCBrZXksIGtleWxlbik7CiB9CiAKLS8q IEFFUy1DQkMgKi8KLQotc3RhdGljIGludCByaXNjdjY0X2Flc19jYmNfY3J5cHQoc3RydWN0IHNr Y2lwaGVyX3JlcXVlc3QgKnJlcSwgYm9vbCBlbmMpCi17Ci0Jc3RydWN0IGNyeXB0b19za2NpcGhl ciAqdGZtID0gY3J5cHRvX3NrY2lwaGVyX3JlcXRmbShyZXEpOwotCWNvbnN0IHN0cnVjdCBjcnlw dG9fYWVzX2N0eCAqY3R4ID0gY3J5cHRvX3NrY2lwaGVyX2N0eCh0Zm0pOwotCXN0cnVjdCBza2Np cGhlcl93YWxrIHdhbGs7Ci0JdW5zaWduZWQgaW50IG5ieXRlczsKLQlpbnQgZXJyOwotCi0JZXJy ID0gc2tjaXBoZXJfd2Fsa192aXJ0KCZ3YWxrLCByZXEsIGZhbHNlKTsKLQl3aGlsZSAoKG5ieXRl cyA9IHdhbGsubmJ5dGVzKSAhPSAwKSB7Ci0JCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKLQkJaWYg KGVuYykKLQkJCWFlc19jYmNfZW5jcnlwdF96dmtuZWQoY3R4LCB3YWxrLnNyYy52aXJ0LmFkZHIs Ci0JCQkJCSAgICAgICB3YWxrLmRzdC52aXJ0LmFkZHIsCi0JCQkJCSAgICAgICBuYnl0ZXMgJiB+ KEFFU19CTE9DS19TSVpFIC0gMSksCi0JCQkJCSAgICAgICB3YWxrLml2KTsKLQkJZWxzZQotCQkJ YWVzX2NiY19kZWNyeXB0X3p2a25lZChjdHgsIHdhbGsuc3JjLnZpcnQuYWRkciwKLQkJCQkJICAg ICAgIHdhbGsuZHN0LnZpcnQuYWRkciwKLQkJCQkJICAgICAgIG5ieXRlcyAmIH4oQUVTX0JMT0NL X1NJWkUgLSAxKSwKLQkJCQkJICAgICAgIHdhbGsuaXYpOwotCQlrZXJuZWxfdmVjdG9yX2VuZCgp OwotCQllcnIgPSBza2NpcGhlcl93YWxrX2RvbmUoJndhbGssIG5ieXRlcyAmIChBRVNfQkxPQ0tf U0laRSAtIDEpKTsKLQl9Ci0KLQlyZXR1cm4gZXJyOwotfQotCi1zdGF0aWMgaW50IHJpc2N2NjRf YWVzX2NiY19lbmNyeXB0KHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEpCi17Ci0JcmV0dXJu IHJpc2N2NjRfYWVzX2NiY19jcnlwdChyZXEsIHRydWUpOwotfQotCi1zdGF0aWMgaW50IHJpc2N2 NjRfYWVzX2NiY19kZWNyeXB0KHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEpCi17Ci0JcmV0 dXJuIHJpc2N2NjRfYWVzX2NiY19jcnlwdChyZXEsIGZhbHNlKTsKLX0KLQotLyogQUVTLUNCQy1D VFMgKi8KLQotc3RhdGljIGludCByaXNjdjY0X2Flc19jYmNfY3RzX2NyeXB0KHN0cnVjdCBza2Np cGhlcl9yZXF1ZXN0ICpyZXEsIGJvb2wgZW5jKQotewotCXN0cnVjdCBjcnlwdG9fc2tjaXBoZXIg KnRmbSA9IGNyeXB0b19za2NpcGhlcl9yZXF0Zm0ocmVxKTsKLQljb25zdCBzdHJ1Y3QgY3J5cHRv X2Flc19jdHggKmN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZtKTsKLQlzdHJ1Y3Qgc2NhdHRl cmxpc3Qgc2dfc3JjWzJdLCBzZ19kc3RbMl07Ci0Jc3RydWN0IHNrY2lwaGVyX3JlcXVlc3Qgc3Vi cmVxOwotCXN0cnVjdCBzY2F0dGVybGlzdCAqc3JjLCAqZHN0OwotCXN0cnVjdCBza2NpcGhlcl93 YWxrIHdhbGs7Ci0JdW5zaWduZWQgaW50IGNiY19sZW47Ci0JaW50IGVycjsKLQotCWlmIChyZXEt PmNyeXB0bGVuIDwgQUVTX0JMT0NLX1NJWkUpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JZXJyID0g c2tjaXBoZXJfd2Fsa192aXJ0KCZ3YWxrLCByZXEsIGZhbHNlKTsKLQlpZiAoZXJyKQotCQlyZXR1 cm4gZXJyOwotCS8qCi0JICogSWYgdGhlIGZ1bGwgbWVzc2FnZSBpcyBhdmFpbGFibGUgaW4gb25l IHN0ZXAsIGRlY3J5cHQgaXQgaW4gb25lIGNhbGwKLQkgKiB0byB0aGUgQ0JDLUNUUyBhc3NlbWJs eSBmdW5jdGlvbi4gIFRoaXMgcmVkdWNlcyBvdmVyaGVhZCwgZXNwZWNpYWxseQotCSAqIG9uIHNo b3J0IG1lc3NhZ2VzLiAgT3RoZXJ3aXNlLCBmYWxsIGJhY2sgdG8gZG9pbmcgQ0JDIHVwIHRvIHRo ZSBsYXN0Ci0JICogdHdvIGJsb2NrcywgdGhlbiBpbnZva2UgQ1RTIGp1c3QgZm9yIHRoZSBjaXBo ZXJ0ZXh0IHN0ZWFsaW5nLgotCSAqLwotCWlmICh1bmxpa2VseSh3YWxrLm5ieXRlcyAhPSByZXEt PmNyeXB0bGVuKSkgewotCQljYmNfbGVuID0gcm91bmRfZG93bihyZXEtPmNyeXB0bGVuIC0gQUVT X0JMT0NLX1NJWkUgLSAxLAotCQkJCSAgICAgQUVTX0JMT0NLX1NJWkUpOwotCQlza2NpcGhlcl93 YWxrX2Fib3J0KCZ3YWxrKTsKLQkJc2tjaXBoZXJfcmVxdWVzdF9zZXRfdGZtKCZzdWJyZXEsIHRm bSk7Ci0JCXNrY2lwaGVyX3JlcXVlc3Rfc2V0X2NhbGxiYWNrKCZzdWJyZXEsCi0JCQkJCSAgICAg IHNrY2lwaGVyX3JlcXVlc3RfZmxhZ3MocmVxKSwKLQkJCQkJICAgICAgTlVMTCwgTlVMTCk7Ci0J CXNrY2lwaGVyX3JlcXVlc3Rfc2V0X2NyeXB0KCZzdWJyZXEsIHJlcS0+c3JjLCByZXEtPmRzdCwK LQkJCQkJICAgY2JjX2xlbiwgcmVxLT5pdik7Ci0JCWVyciA9IHJpc2N2NjRfYWVzX2NiY19jcnlw dCgmc3VicmVxLCBlbmMpOwotCQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQkJZHN0ID0gc3Jj ID0gc2NhdHRlcndhbGtfZmZ3ZChzZ19zcmMsIHJlcS0+c3JjLCBjYmNfbGVuKTsKLQkJaWYgKHJl cS0+ZHN0ICE9IHJlcS0+c3JjKQotCQkJZHN0ID0gc2NhdHRlcndhbGtfZmZ3ZChzZ19kc3QsIHJl cS0+ZHN0LCBjYmNfbGVuKTsKLQkJc2tjaXBoZXJfcmVxdWVzdF9zZXRfY3J5cHQoJnN1YnJlcSwg c3JjLCBkc3QsCi0JCQkJCSAgIHJlcS0+Y3J5cHRsZW4gLSBjYmNfbGVuLCByZXEtPml2KTsKLQkJ ZXJyID0gc2tjaXBoZXJfd2Fsa192aXJ0KCZ3YWxrLCAmc3VicmVxLCBmYWxzZSk7Ci0JCWlmIChl cnIpCi0JCQlyZXR1cm4gZXJyOwotCX0KLQlrZXJuZWxfdmVjdG9yX2JlZ2luKCk7Ci0JYWVzX2Ni Y19jdHNfY3J5cHRfenZrbmVkKGN0eCwgd2Fsay5zcmMudmlydC5hZGRyLCB3YWxrLmRzdC52aXJ0 LmFkZHIsCi0JCQkJIHdhbGsubmJ5dGVzLCByZXEtPml2LCBlbmMpOwotCWtlcm5lbF92ZWN0b3Jf ZW5kKCk7Ci0JcmV0dXJuIHNrY2lwaGVyX3dhbGtfZG9uZSgmd2FsaywgMCk7Ci19Ci0KLXN0YXRp YyBpbnQgcmlzY3Y2NF9hZXNfY2JjX2N0c19lbmNyeXB0KHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0 ICpyZXEpCi17Ci0JcmV0dXJuIHJpc2N2NjRfYWVzX2NiY19jdHNfY3J5cHQocmVxLCB0cnVlKTsK LX0KLQotc3RhdGljIGludCByaXNjdjY0X2Flc19jYmNfY3RzX2RlY3J5cHQoc3RydWN0IHNrY2lw aGVyX3JlcXVlc3QgKnJlcSkKLXsKLQlyZXR1cm4gcmlzY3Y2NF9hZXNfY2JjX2N0c19jcnlwdChy ZXEsIGZhbHNlKTsKLX0KLQogLyogQUVTLUNUUiAqLwogCiBzdGF0aWMgaW50IHJpc2N2NjRfYWVz X2N0cl9jcnlwdChzdHJ1Y3Qgc2tjaXBoZXJfcmVxdWVzdCAqcmVxKQpAQCAtMzY2LDQxICsyNTEs NiBAQCBzdGF0aWMgaW50IHJpc2N2NjRfYWVzX3h0c19kZWNyeXB0KHN0cnVjdCBza2NpcGhlcl9y ZXF1ZXN0ICpyZXEpCiAKIC8qIEFsZ29yaXRobSBkZWZpbml0aW9ucyAqLwogCi1zdGF0aWMgc3Ry dWN0IHNrY2lwaGVyX2FsZyByaXNjdjY0X3p2a25lZF9hZXNfc2tjaXBoZXJfYWxnc1tdID0gewot CXsKLQkJLnNldGtleSA9IHJpc2N2NjRfYWVzX3NldGtleV9za2NpcGhlciwKLQkJLmVuY3J5cHQg PSByaXNjdjY0X2Flc19jYmNfZW5jcnlwdCwKLQkJLmRlY3J5cHQgPSByaXNjdjY0X2Flc19jYmNf ZGVjcnlwdCwKLQkJLm1pbl9rZXlzaXplID0gQUVTX01JTl9LRVlfU0laRSwKLQkJLm1heF9rZXlz aXplID0gQUVTX01BWF9LRVlfU0laRSwKLQkJLml2c2l6ZSA9IEFFU19CTE9DS19TSVpFLAotCQku YmFzZSA9IHsKLQkJCS5jcmFfYmxvY2tzaXplID0gQUVTX0JMT0NLX1NJWkUsCi0JCQkuY3JhX2N0 eHNpemUgPSBzaXplb2Yoc3RydWN0IGNyeXB0b19hZXNfY3R4KSwKLQkJCS5jcmFfcHJpb3JpdHkg PSAzMDAsCi0JCQkuY3JhX25hbWUgPSAiY2JjKGFlcykiLAotCQkJLmNyYV9kcml2ZXJfbmFtZSA9 ICJjYmMtYWVzLXJpc2N2NjQtenZrbmVkIiwKLQkJCS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUs Ci0JCX0sCi0JfSwgewotCQkuc2V0a2V5ID0gcmlzY3Y2NF9hZXNfc2V0a2V5X3NrY2lwaGVyLAot CQkuZW5jcnlwdCA9IHJpc2N2NjRfYWVzX2NiY19jdHNfZW5jcnlwdCwKLQkJLmRlY3J5cHQgPSBy aXNjdjY0X2Flc19jYmNfY3RzX2RlY3J5cHQsCi0JCS5taW5fa2V5c2l6ZSA9IEFFU19NSU5fS0VZ X1NJWkUsCi0JCS5tYXhfa2V5c2l6ZSA9IEFFU19NQVhfS0VZX1NJWkUsCi0JCS5pdnNpemUgPSBB RVNfQkxPQ0tfU0laRSwKLQkJLndhbGtzaXplID0gNCAqIEFFU19CTE9DS19TSVpFLCAvKiBtYXRj aGVzIExNVUw9NCAqLwotCQkuYmFzZSA9IHsKLQkJCS5jcmFfYmxvY2tzaXplID0gQUVTX0JMT0NL X1NJWkUsCi0JCQkuY3JhX2N0eHNpemUgPSBzaXplb2Yoc3RydWN0IGNyeXB0b19hZXNfY3R4KSwK LQkJCS5jcmFfcHJpb3JpdHkgPSAzMDAsCi0JCQkuY3JhX25hbWUgPSAiY3RzKGNiYyhhZXMpKSIs Ci0JCQkuY3JhX2RyaXZlcl9uYW1lID0gImN0cy1jYmMtYWVzLXJpc2N2NjQtenZrbmVkIiwKLQkJ CS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUsCi0JCX0sCi0JfQotfTsKLQogc3RhdGljIHN0cnVj dCBza2NpcGhlcl9hbGcgcmlzY3Y2NF96dmtuZWRfenZrYl9hZXNfc2tjaXBoZXJfYWxnID0gewog CS5zZXRrZXkgPSByaXNjdjY0X2Flc19zZXRrZXlfc2tjaXBoZXIsCiAJLmVuY3J5cHQgPSByaXNj djY0X2Flc19jdHJfY3J5cHQsCkBAIC00NTIsMTcgKzMwMiwxMSBAQCBzdGF0aWMgaW50IF9faW5p dCByaXNjdjY0X2Flc19tb2RfaW5pdCh2b2lkKQogCiAJaWYgKHJpc2N2X2lzYV9leHRlbnNpb25f YXZhaWxhYmxlKE5VTEwsIFpWS05FRCkgJiYKIAkgICAgcmlzY3ZfdmVjdG9yX3ZsZW4oKSA+PSAx MjgpIHsKLQkJZXJyID0gY3J5cHRvX3JlZ2lzdGVyX3NrY2lwaGVycygKLQkJCXJpc2N2NjRfenZr bmVkX2Flc19za2NpcGhlcl9hbGdzLAotCQkJQVJSQVlfU0laRShyaXNjdjY0X3p2a25lZF9hZXNf c2tjaXBoZXJfYWxncykpOwotCQlpZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQogCQlpZiAocmlz Y3ZfaXNhX2V4dGVuc2lvbl9hdmFpbGFibGUoTlVMTCwgWlZLQikpIHsKIAkJCWVyciA9IGNyeXB0 b19yZWdpc3Rlcl9za2NpcGhlcigKIAkJCQkmcmlzY3Y2NF96dmtuZWRfenZrYl9hZXNfc2tjaXBo ZXJfYWxnKTsKIAkJCWlmIChlcnIpCi0JCQkJZ290byB1bnJlZ2lzdGVyX3p2a25lZF9za2NpcGhl cl9hbGdzOworCQkJCXJldHVybiBlcnI7CiAJCX0KIAogCQlpZiAocmlzY3Y2NF9hZXNfeHRzX3N1 cHBvcnRlZCgpKSB7CkBAIC00NzgsOSArMzIyLDYgQEAgc3RhdGljIGludCBfX2luaXQgcmlzY3Y2 NF9hZXNfbW9kX2luaXQodm9pZCkKIHVucmVnaXN0ZXJfenZrbmVkX3p2a2Jfc2tjaXBoZXJfYWxn OgogCWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktCKSkKIAkJY3J5 cHRvX3VucmVnaXN0ZXJfc2tjaXBoZXIoJnJpc2N2NjRfenZrbmVkX3p2a2JfYWVzX3NrY2lwaGVy X2FsZyk7Ci11bnJlZ2lzdGVyX3p2a25lZF9za2NpcGhlcl9hbGdzOgotCWNyeXB0b191bnJlZ2lz dGVyX3NrY2lwaGVycyhyaXNjdjY0X3p2a25lZF9hZXNfc2tjaXBoZXJfYWxncywKLQkJCQkgICAg QVJSQVlfU0laRShyaXNjdjY0X3p2a25lZF9hZXNfc2tjaXBoZXJfYWxncykpOwogCXJldHVybiBl cnI7CiB9CiAKQEAgLTQ5MCwxOCArMzMxLDE0IEBAIHN0YXRpYyB2b2lkIF9fZXhpdCByaXNjdjY0 X2Flc19tb2RfZXhpdCh2b2lkKQogCQljcnlwdG9fdW5yZWdpc3Rlcl9za2NpcGhlcigmcmlzY3Y2 NF96dmtuZWRfenZiYl96dmtnX2Flc19za2NpcGhlcl9hbGcpOwogCWlmIChyaXNjdl9pc2FfZXh0 ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktCKSkKIAkJY3J5cHRvX3VucmVnaXN0ZXJfc2tjaXBo ZXIoJnJpc2N2NjRfenZrbmVkX3p2a2JfYWVzX3NrY2lwaGVyX2FsZyk7Ci0JY3J5cHRvX3VucmVn aXN0ZXJfc2tjaXBoZXJzKHJpc2N2NjRfenZrbmVkX2Flc19za2NpcGhlcl9hbGdzLAotCQkJCSAg ICBBUlJBWV9TSVpFKHJpc2N2NjRfenZrbmVkX2Flc19za2NpcGhlcl9hbGdzKSk7CiB9CiAKIG1v ZHVsZV9pbml0KHJpc2N2NjRfYWVzX21vZF9pbml0KTsKIG1vZHVsZV9leGl0KHJpc2N2NjRfYWVz X21vZF9leGl0KTsKIAotTU9EVUxFX0RFU0NSSVBUSU9OKCJBRVMtQ0JDL0NUUy9DVFIvWFRTIChS SVNDLVYgYWNjZWxlcmF0ZWQpIik7CitNT0RVTEVfREVTQ1JJUFRJT04oIkFFUy1DVFIvWFRTIChS SVNDLVYgYWNjZWxlcmF0ZWQpIik7CiBNT0RVTEVfQVVUSE9SKCJKZXJyeSBTaGloIDxqZXJyeS5z aGloQHNpZml2ZS5jb20+Iik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiBNT0RVTEVfQUxJQVNf Q1JZUFRPKCJhZXMiKTsKLU1PRFVMRV9BTElBU19DUllQVE8oImNiYyhhZXMpIik7Ci1NT0RVTEVf QUxJQVNfQ1JZUFRPKCJjdHMoY2JjKGFlcykpIik7CiBNT0RVTEVfQUxJQVNfQ1JZUFRPKCJjdHIo YWVzKSIpOwogTU9EVUxFX0FMSUFTX0NSWVBUTygieHRzKGFlcykiKTsKZGlmZiAtLWdpdCBhL2Fy Y2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LXp2a25lZC5TIGIvYXJjaC9yaXNjdi9jcnlwdG8v YWVzLXJpc2N2NjQtenZrbmVkLlMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwZjhh MDY1OTZkMy4uMDAwMDAwMDAwMDAwCi0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0 LXp2a25lZC5TCisrKyAvZGV2L251bGwKQEAgLTEsMjczICswLDAgQEAKLS8qIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wIE9SIEJTRC0yLUNsYXVzZSAqLwotLy8KLS8vIFRoaXMg ZmlsZSBpcyBkdWFsLWxpY2Vuc2VkLCBtZWFuaW5nIHRoYXQgeW91IGNhbiB1c2UgaXQgdW5kZXIg eW91cgotLy8gY2hvaWNlIG9mIGVpdGhlciBvZiB0aGUgZm9sbG93aW5nIHR3byBsaWNlbnNlczoK LS8vCi0vLyBDb3B5cmlnaHQgMjAyMyBUaGUgT3BlblNTTCBQcm9qZWN0IEF1dGhvcnMuIEFsbCBS aWdodHMgUmVzZXJ2ZWQuCi0vLwotLy8gTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNl IDIuMCAodGhlICJMaWNlbnNlIikuIFlvdSBjYW4gb2J0YWluCi0vLyBhIGNvcHkgaW4gdGhlIGZp bGUgTElDRU5TRSBpbiB0aGUgc291cmNlIGRpc3RyaWJ1dGlvbiBvciBhdAotLy8gaHR0cHM6Ly93 d3cub3BlbnNzbC5vcmcvc291cmNlL2xpY2Vuc2UuaHRtbAotLy8KLS8vIG9yCi0vLwotLy8gQ29w eXJpZ2h0IChjKSAyMDIzLCBDaHJpc3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2 cnVsbC5ldT4KLS8vIENvcHlyaWdodCAoYykgMjAyMywgUGhvZWJlIENoZW4gPHBob2ViZS5jaGVu QHNpZml2ZS5jb20+Ci0vLyBDb3B5cmlnaHQgKGMpIDIwMjMsIEplcnJ5IFNoaWggPGplcnJ5LnNo aWhAc2lmaXZlLmNvbT4KLS8vIENvcHlyaWdodCAyMDI0IEdvb2dsZSBMTEMKLS8vIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCi0vLwotLy8gUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0vLyBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLS8vIGFyZSBtZXQ6 Ci0vLyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAotLy8gICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotLy8gMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKLS8vICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKLS8vICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCi0vLwotLy8gVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwotLy8gIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKLS8v IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgotLy8gQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKLS8vIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAotLy8gU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAotLy8gTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCi0vLyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKLS8vIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKLS8vIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQotLy8gT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLQotLy8gVGhlIGdlbmVyYXRlZCBjb2RlIG9mIHRo aXMgZmlsZSBkZXBlbmRzIG9uIHRoZSBmb2xsb3dpbmcgUklTQy1WIGV4dGVuc2lvbnM6Ci0vLyAt IFJWNjRJCi0vLyAtIFJJU0MtViBWZWN0b3IgKCdWJykgd2l0aCBWTEVOID49IDEyOAotLy8gLSBS SVNDLVYgVmVjdG9yIEFFUyBibG9jayBjaXBoZXIgZXh0ZW5zaW9uICgnWnZrbmVkJykKLQotI2lu Y2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KLQotLnRleHQKLS5vcHRpb24gYXJjaCwgK3p2a25lZAot Ci0jaW5jbHVkZSAiYWVzLW1hY3Jvcy5TIgotCi0jZGVmaW5lIEtFWVAJCWEwCi0jZGVmaW5lIElO UAkJYTEKLSNkZWZpbmUgT1VUUAkJYTIKLSNkZWZpbmUgTEVOCQlhMwotI2RlZmluZSBJVlAJCWE0 Ci0KLS5tYWNybwlhZXNfY2JjX2VuY3J5cHQJa2V5bGVuCi0JdmxlMzIudgkJdjE2LCAoSVZQKQkv LyBMb2FkIElWCi0xOgotCXZsZTMyLnYJCXYxNywgKElOUCkJLy8gTG9hZCBwbGFpbnRleHQgYmxv Y2sKLQl2eG9yLnZ2CQl2MTYsIHYxNiwgdjE3CS8vIFhPUiB3aXRoIElWIG9yIHByZXYgY2lwaGVy dGV4dCBibG9jawotCWFlc19lbmNyeXB0CXYxNiwgXGtleWxlbgkvLyBFbmNyeXB0Ci0JdnNlMzIu dgkJdjE2LCAoT1VUUCkJLy8gU3RvcmUgY2lwaGVydGV4dCBibG9jawotCWFkZGkJCUlOUCwgSU5Q LCAxNgotCWFkZGkJCU9VVFAsIE9VVFAsIDE2Ci0JYWRkaQkJTEVOLCBMRU4sIC0xNgotCWJuZXoJ CUxFTiwgMWIKLQotCXZzZTMyLnYJCXYxNiwgKElWUCkJLy8gU3RvcmUgbmV4dCBJVgotCXJldAot LmVuZG0KLQotLm1hY3JvCWFlc19jYmNfZGVjcnlwdAlrZXlsZW4KLQlzcmxpCQlMRU4sIExFTiwg MgkvLyBDb252ZXJ0IExFTiBmcm9tIGJ5dGVzIHRvIHdvcmRzCi0JdmxlMzIudgkJdjE2LCAoSVZQ KQkvLyBMb2FkIElWCi0xOgotCXZzZXR2bGkJCXQwLCBMRU4sIGUzMiwgbTQsIHRhLCBtYQotCXZs ZTMyLnYJCXYyMCwgKElOUCkJLy8gTG9hZCBjaXBoZXJ0ZXh0IGJsb2NrcwotCXZzbGlkZXVwLnZp CXYxNiwgdjIwLCA0CS8vIFNldHVwIHByZXYgY2lwaGVydGV4dCBibG9ja3MKLQlhZGRpCQl0MSwg dDAsIC00Ci0JdnNsaWRlZG93bi52eAl2MjQsIHYyMCwgdDEJLy8gU2F2ZSBsYXN0IGNpcGhlcnRl eHQgYmxvY2sKLQlhZXNfZGVjcnlwdAl2MjAsIFxrZXlsZW4JLy8gRGVjcnlwdCB0aGUgYmxvY2tz Ci0Jdnhvci52dgkJdjIwLCB2MjAsIHYxNgkvLyBYT1Igd2l0aCBwcmV2IGNpcGhlcnRleHQgYmxv Y2tzCi0JdnNlMzIudgkJdjIwLCAoT1VUUCkJLy8gU3RvcmUgcGxhaW50ZXh0IGJsb2NrcwotCXZt di52LnYJCXYxNiwgdjI0CS8vIE5leHQgIklWIiBpcyBsYXN0IGNpcGhlcnRleHQgYmxvY2sKLQlz bGxpCQl0MSwgdDAsIDIJLy8gV29yZHMgdG8gYnl0ZXMKLQlhZGQJCUlOUCwgSU5QLCB0MQotCWFk ZAkJT1VUUCwgT1VUUCwgdDEKLQlzdWIJCUxFTiwgTEVOLCB0MAotCWJuZXoJCUxFTiwgMWIKLQot CXZzZXRpdmxpCXplcm8sIDQsIGUzMiwgbTEsIHRhLCBtYQotCXZzZTMyLnYJCXYxNiwgKElWUCkJ Ly8gU3RvcmUgbmV4dCBJVgotCXJldAotLmVuZG0KLQotLy8gdm9pZCBhZXNfY2JjX2VuY3J5cHRf enZrbmVkKGNvbnN0IHN0cnVjdCBjcnlwdG9fYWVzX2N0eCAqa2V5LAotLy8JCQkgICAgICAgY29u c3QgdTggKmluLCB1OCAqb3V0LCBzaXplX3QgbGVuLCB1OCBpdlsxNl0pOwotLy8KLS8vIHxsZW58 IG11c3QgYmUgbm9uemVybyBhbmQgYSBtdWx0aXBsZSBvZiAxNiAoQUVTX0JMT0NLX1NJWkUpLgot U1lNX0ZVTkNfU1RBUlQoYWVzX2NiY19lbmNyeXB0X3p2a25lZCkKLQlhZXNfYmVnaW4JS0VZUCwg MTI4ZiwgMTkyZgotCWFlc19jYmNfZW5jcnlwdAkyNTYKLTEyODoKLQlhZXNfY2JjX2VuY3J5cHQJ MTI4Ci0xOTI6Ci0JYWVzX2NiY19lbmNyeXB0CTE5MgotU1lNX0ZVTkNfRU5EKGFlc19jYmNfZW5j cnlwdF96dmtuZWQpCi0KLS8vIFNhbWUgcHJvdG90eXBlIGFuZCBjYWxsaW5nIGNvbnZlbnRpb24g YXMgdGhlIGVuY3J5cHRpb24gZnVuY3Rpb24KLVNZTV9GVU5DX1NUQVJUKGFlc19jYmNfZGVjcnlw dF96dmtuZWQpCi0JYWVzX2JlZ2luCUtFWVAsIDEyOGYsIDE5MmYKLQlhZXNfY2JjX2RlY3J5cHQJ MjU2Ci0xMjg6Ci0JYWVzX2NiY19kZWNyeXB0CTEyOAotMTkyOgotCWFlc19jYmNfZGVjcnlwdAkx OTIKLVNZTV9GVU5DX0VORChhZXNfY2JjX2RlY3J5cHRfenZrbmVkKQotCi0ubWFjcm8JYWVzX2Ni Y19jdHNfZW5jcnlwdAlrZXlsZW4KLQotCS8vIENCQy1lbmNyeXB0IGFsbCBibG9ja3MgZXhjZXB0 IHRoZSBsYXN0LiAgQnV0IGRvbid0IHN0b3JlIHRoZQotCS8vIHNlY29uZC10by1sYXN0IGJsb2Nr IHRvIHRoZSBvdXRwdXQgYnVmZmVyIHlldCwgc2luY2UgaXQgd2lsbCBiZQotCS8vIGhhbmRsZWQg c3BlY2lhbGx5IGluIHRoZSBjaXBoZXJ0ZXh0IHN0ZWFsaW5nIHN0ZXAuICBFeGNlcHRpb246IGlm IHRoZQotCS8vIG1lc3NhZ2UgaXMgc2luZ2xlLWJsb2NrLCBzdGlsbCBlbmNyeXB0IHRoZSBsYXN0 IChhbmQgb25seSkgYmxvY2suCi0JbGkJCXQwLCAxNgotCWoJCTJmCi0xOgotCXZzZTMyLnYJCXYx NiwgKE9VVFApCS8vIFN0b3JlIGNpcGhlcnRleHQgYmxvY2sKLQlhZGRpCQlPVVRQLCBPVVRQLCAx NgotMjoKLQl2bGUzMi52CQl2MTcsIChJTlApCS8vIExvYWQgcGxhaW50ZXh0IGJsb2NrCi0Jdnhv ci52dgkJdjE2LCB2MTYsIHYxNwkvLyBYT1Igd2l0aCBJViBvciBwcmV2IGNpcGhlcnRleHQgYmxv Y2sKLQlhZXNfZW5jcnlwdAl2MTYsIFxrZXlsZW4JLy8gRW5jcnlwdAotCWFkZGkJCUlOUCwgSU5Q LCAxNgotCWFkZGkJCUxFTiwgTEVOLCAtMTYKLQliZ3QJCUxFTiwgdDAsIDFiCS8vIFJlcGVhdCBp ZiBtb3JlIHRoYW4gb25lIGJsb2NrIHJlbWFpbnMKLQotCS8vIFNwZWNpYWwgY2FzZTogaWYgdGhl IG1lc3NhZ2UgaXMgYSBzaW5nbGUgYmxvY2ssIGp1c3QgZG8gQ0JDLgotCWJlcXoJCUxFTiwgLkxj dHNfZW5jcnlwdF9kb25lXEAKLQotCS8vIEVuY3J5cHQgdGhlIGxhc3QgdHdvIGJsb2NrcyB1c2lu ZyBjaXBoZXJ0ZXh0IHN0ZWFsaW5nIGFzIGZvbGxvd3M6Ci0JLy8JQ1tuLTFdID0gRW5jcnlwdChF bmNyeXB0KFBbbi0xXSBeIENbbi0yXSkgXiBQW25dKQotCS8vCUNbbl0gPSBFbmNyeXB0KFBbbi0x XSBeIENbbi0yXSlbMC4uTEVOXQotCS8vCi0JLy8gQ1tpXSBkZW5vdGVzIHRoZSBpJ3RoIGNpcGhl cnRleHQgYmxvY2ssIGFuZCBsaWtld2lzZSBQW2ldIHRoZSBpJ3RoCi0JLy8gcGxhaW50ZXh0IGJs b2NrLiAgQmxvY2sgbiwgdGhlIGxhc3QgYmxvY2ssIG1heSBiZSBwYXJ0aWFsOyBpdHMgbGVuZ3Ro Ci0JLy8gaXMgMSA8PSBMRU4gPD0gMTYuICBJZiB0aGVyZSBhcmUgb25seSAyIGJsb2NrcywgQ1tu LTJdIG1lYW5zIHRoZSBJVi4KLQkvLwotCS8vIHYxNiBhbHJlYWR5IGNvbnRhaW5zIEVuY3J5cHQo UFtuLTFdIF4gQ1tuLTJdKS4KLQkvLyBJTlAgcG9pbnRzIHRvIFBbbl0uICBPVVRQIHBvaW50cyB0 byB3aGVyZSBDW24tMV0gc2hvdWxkIGdvLgotCS8vIFRvIHN1cHBvcnQgaW4tcGxhY2UgZW5jcnlw dGlvbiwgbG9hZCBQW25dIGJlZm9yZSBzdG9yaW5nIENbbl0uCi0JYWRkaQkJdDAsIE9VVFAsIDE2 CS8vIEdldCBwb2ludGVyIHRvIHdoZXJlIENbbl0gc2hvdWxkIGdvCi0JdnNldHZsaQkJemVybywg TEVOLCBlOCwgbTEsIHR1LCBtYQotCXZsZTgudgkJdjE3LCAoSU5QKQkvLyBMb2FkIFBbbl0KLQl2 c2U4LnYJCXYxNiwgKHQwKQkvLyBTdG9yZSBDW25dCi0Jdnhvci52dgkJdjE2LCB2MTYsIHYxNwkv LyB2MTYgPSBFbmNyeXB0KFBbbi0xXSBeIENbbi0yXSkgXiBQW25dCi0JdnNldGl2bGkJemVybywg NCwgZTMyLCBtMSwgdGEsIG1hCi0JYWVzX2VuY3J5cHQJdjE2LCBca2V5bGVuCi0uTGN0c19lbmNy eXB0X2RvbmVcQDoKLQl2c2UzMi52CQl2MTYsIChPVVRQKQkvLyBTdG9yZSBDW24tMV0gKG9yIENb bl0gaW4gc2luZ2xlLWJsb2NrIGNhc2UpCi0JcmV0Ci0uZW5kbQotCi0jZGVmaW5lIExFTjMyCQl0 NCAvLyBMZW5ndGggb2YgcmVtYWluaW5nIGZ1bGwgYmxvY2tzIGluIDMyLWJpdCB3b3JkcwotI2Rl ZmluZSBMRU5fTU9EMTYJdDUgLy8gTGVuZ3RoIG9mIG1lc3NhZ2UgaW4gYnl0ZXMgbW9kIDE2Ci0K LS5tYWNybwlhZXNfY2JjX2N0c19kZWNyeXB0CWtleWxlbgotCWFuZGkJCUxFTjMyLCBMRU4sIH4x NQotCXNybGkJCUxFTjMyLCBMRU4zMiwgMgotCWFuZGkJCUxFTl9NT0QxNiwgTEVOLCAxNQotCi0J Ly8gU2F2ZSBDW24tMl0gaW4gdjI4IHNvIHRoYXQgaXQncyBhdmFpbGFibGUgbGF0ZXIgZHVyaW5n IHRoZSBjaXBoZXJ0ZXh0Ci0JLy8gc3RlYWxpbmcgc3RlcC4gIElmIHRoZXJlIGFyZSBmZXdlciB0 aGFuIHRocmVlIGJsb2NrcywgQ1tuLTJdIG1lYW5zCi0JLy8gdGhlIElWLCBvdGhlcndpc2UgaXQg bWVhbnMgdGhlIHRoaXJkLXRvLWxhc3QgY2lwaGVydGV4dCBibG9jay4KLQl2bXYudi52CQl2Mjgs IHYxNgkvLyBJVgotCWFkZAkJdDAsIExFTiwgLTMzCi0JYmx0egkJdDAsIC5MY3RzX2RlY3J5cHRf bG9vcFxACi0JYW5kaQkJdDAsIHQwLCB+MTUKLQlhZGQJCXQwLCB0MCwgSU5QCi0JdmxlMzIudgkJ djI4LCAodDApCi0KLQkvLyBDQkMtZGVjcnlwdCBhbGwgZnVsbCBibG9ja3MuICBGb3IgdGhlIGxh c3QgZnVsbCBibG9jaywgb3IgdGhlIGxhc3QgMgotCS8vIGZ1bGwgYmxvY2tzIGlmIHRoZSBtZXNz YWdlIGlzIGJsb2NrLWFsaWduZWQsIHRoaXMgZG9lc24ndCB3cml0ZSB0aGUKLQkvLyBjb3JyZWN0 IG91dHB1dCBibG9ja3MgKHVubGVzcyB0aGUgbWVzc2FnZSBpcyBvbmx5IGEgc2luZ2xlIGJsb2Nr KSwKLQkvLyBiZWNhdXNlIGl0IFhPUnMgdGhlIHdyb25nIHZhbHVlcyB3aXRoIHRoZSByYXcgQUVT IHBsYWludGV4dHMuICBCdXQgd2UKLQkvLyBmaXggdGhpcyBhZnRlciB0aGlzIGxvb3Agd2l0aG91 dCByZWRvaW5nIHRoZSBBRVMgZGVjcnlwdGlvbnMuICBUaGlzCi0JLy8gYXBwcm9hY2ggYWxsb3dz IG1vcmUgb2YgdGhlIEFFUyBkZWNyeXB0aW9ucyB0byBiZSBwYXJhbGxlbGl6ZWQuCi0uTGN0c19k ZWNyeXB0X2xvb3BcQDoKLQl2c2V0dmxpCQl0MCwgTEVOMzIsIGUzMiwgbTQsIHRhLCBtYQotCWFk ZGkJCXQxLCB0MCwgLTQKLQl2bGUzMi52CQl2MjAsIChJTlApCS8vIExvYWQgbmV4dCBzZXQgb2Yg Y2lwaGVydGV4dCBibG9ja3MKLQl2bXYudi52CQl2MjQsIHYxNgkvLyBHZXQgSVYgb3IgbGFzdCBj aXBoZXJ0ZXh0IGJsb2NrIG9mIHByZXYgc2V0Ci0JdnNsaWRldXAudmkJdjI0LCB2MjAsIDQJLy8g U2V0dXAgcHJldiBjaXBoZXJ0ZXh0IGJsb2NrcwotCXZzbGlkZWRvd24udngJdjE2LCB2MjAsIHQx CS8vIFNhdmUgbGFzdCBjaXBoZXJ0ZXh0IGJsb2NrIG9mIHRoaXMgc2V0Ci0JYWVzX2RlY3J5cHQJ djIwLCBca2V5bGVuCS8vIERlY3J5cHQgdGhpcyBzZXQgb2YgYmxvY2tzCi0Jdnhvci52dgkJdjI0 LCB2MjQsIHYyMAkvLyBYT1IgcHJldiBjaXBoZXJ0ZXh0IGJsb2NrcyB3aXRoIGRlY3J5cHRlZCBi bG9ja3MKLQl2c2UzMi52CQl2MjQsIChPVVRQKQkvLyBTdG9yZSB0aGlzIHNldCBvZiBwbGFpbnRl eHQgYmxvY2tzCi0Jc3ViCQlMRU4zMiwgTEVOMzIsIHQwCi0Jc2xsaQkJdDAsIHQwLCAyCS8vIFdv cmRzIHRvIGJ5dGVzCi0JYWRkCQlJTlAsIElOUCwgdDAKLQlhZGQJCU9VVFAsIE9VVFAsIHQwCi0J Ym5legkJTEVOMzIsIC5MY3RzX2RlY3J5cHRfbG9vcFxACi0KLQl2c2V0aXZsaQl6ZXJvLCA0LCBl MzIsIG00LCB0YSwgbWEKLQl2c2xpZGVkb3duLnZ4CXYyMCwgdjIwLCB0MQkvLyBFeHRyYWN0IHJh dyBwbGFpbnRleHQgb2YgbGFzdCBmdWxsIGJsb2NrCi0JYWRkaQkJdDAsIE9VVFAsIC0xNgkvLyBH ZXQgcG9pbnRlciB0byBsYXN0IGZ1bGwgcGxhaW50ZXh0IGJsb2NrCi0JYm5legkJTEVOX01PRDE2 LCAuTGN0c19kZWNyeXB0X25vbl9ibG9ja19hbGlnbmVkXEAKLQotCS8vIFNwZWNpYWwgY2FzZTog aWYgdGhlIG1lc3NhZ2UgaXMgYSBzaW5nbGUgYmxvY2ssIGp1c3QgZG8gQ0JDLgotCWxpCQl0MSwg MTYKLQliZXEJCUxFTiwgdDEsIC5MY3RzX2RlY3J5cHRfZG9uZVxACi0KLQkvLyBCbG9jay1hbGln bmVkIG1lc3NhZ2UuICBKdXN0IGZpeCB1cCB0aGUgbGFzdCAyIGJsb2Nrcy4gIFdlIG5lZWQ6Ci0J Ly8KLQkvLwlQW24tMV0gPSBEZWNyeXB0KENbbl0pIF4gQ1tuLTJdCi0JLy8JUFtuXSA9IERlY3J5 cHQoQ1tuLTFdKSBeIENbbl0KLQkvLwotCS8vIFdlIGhhdmUgQ1tuXSBpbiB2MTYsIERlY3J5cHQo Q1tuXSkgaW4gdjIwLCBhbmQgQ1tuLTJdIGluIHYyOC4KLQkvLyBUb2dldGhlciB3aXRoIERlY3J5 cHQoQ1tuLTFdKSBeIENbbi0yXSBmcm9tIHRoZSBvdXRwdXQgYnVmZmVyLCB0aGlzCi0JLy8gaXMg ZXZlcnl0aGluZyBuZWVkZWQgdG8gZml4IHRoZSBvdXRwdXQgd2l0aG91dCByZS1kZWNyeXB0aW5n IGJsb2Nrcy4KLQlhZGRpCQl0MSwgT1VUUCwgLTMyCS8vIEdldCBwb2ludGVyIHRvIHdoZXJlIFBb bi0xXSBzaG91bGQgZ28KLQl2eG9yLnZ2CQl2MjAsIHYyMCwgdjI4CS8vIERlY3J5cHQoQ1tuXSkg XiBDW24tMl0gPT0gUFtuLTFdCi0JdmxlMzIudgkJdjI0LCAodDEpCS8vIERlY3J5cHQoQ1tuLTFd KSBeIENbbi0yXQotCXZzZTMyLnYJCXYyMCwgKHQxKQkvLyBTdG9yZSBQW24tMV0KLQl2eG9yLnZ2 CQl2MjAsIHYyNCwgdjE2CS8vIERlY3J5cHQoQ1tuLTFdKSBeIENbbi0yXSBeIENbbl0gPT0gUFtu XSBeIENbbi0yXQotCWoJCS5MY3RzX2RlY3J5cHRfZmluaXNoXEAKLQotLkxjdHNfZGVjcnlwdF9u b25fYmxvY2tfYWxpZ25lZFxAOgotCS8vIERlY3J5cHQgdGhlIGxhc3QgdHdvIGJsb2NrcyB1c2lu ZyBjaXBoZXJ0ZXh0IHN0ZWFsaW5nIGFzIGZvbGxvd3M6Ci0JLy8KLQkvLwlQW24tMV0gPSBEZWNy eXB0KENbbl0gfHwgRGVjcnlwdChDW24tMV0pW0xFTl9NT0QxNi4uMTZdKSBeIENbbi0yXQotCS8v CVBbbl0gPSAoRGVjcnlwdChDW24tMV0pIF4gQ1tuXSlbMC4uTEVOX01PRDE2XQotCS8vCi0JLy8g V2UgYWxyZWFkeSBoYXZlIERlY3J5cHQoQ1tuLTFdKSBpbiB2MjAgYW5kIENbbi0yXSBpbiB2Mjgu Ci0Jdm12LnYudgkJdjE2LCB2MjAJLy8gdjE2ID0gRGVjcnlwdChDW24tMV0pCi0JdnNldHZsaQkJ emVybywgTEVOX01PRDE2LCBlOCwgbTEsIHR1LCBtYQotCXZsZTgudgkJdjIwLCAoSU5QKQkvLyB2 MjAgPSBDW25dIHx8IERlY3J5cHQoQ1tuLTFdKVtMRU5fTU9EMTYuLjE2XQotCXZ4b3IudnYJCXYx NiwgdjE2LCB2MjAJLy8gdjE2ID0gRGVjcnlwdChDW24tMV0pIF4gQ1tuXQotCXZzZTgudgkJdjE2 LCAoT1VUUCkJLy8gU3RvcmUgUFtuXQotCXZzZXRpdmxpCXplcm8sIDQsIGUzMiwgbTEsIHRhLCBt YQotCWFlc19kZWNyeXB0CXYyMCwgXGtleWxlbgkvLyB2MjAgPSBEZWNyeXB0KENbbl0gfHwgRGVj cnlwdChDW24tMV0pW0xFTl9NT0QxNi4uMTZdKQotLkxjdHNfZGVjcnlwdF9maW5pc2hcQDoKLQl2 eG9yLnZ2CQl2MjAsIHYyMCwgdjI4CS8vIFhPUiB3aXRoIENbbi0yXQotCXZzZTMyLnYJCXYyMCwg KHQwKQkvLyBTdG9yZSBsYXN0IGZ1bGwgcGxhaW50ZXh0IGJsb2NrCi0uTGN0c19kZWNyeXB0X2Rv bmVcQDoKLQlyZXQKLS5lbmRtCi0KLS5tYWNybwlhZXNfY2JjX2N0c19jcnlwdAlrZXlsZW4KLQl2 bGUzMi52CQl2MTYsIChJVlApCS8vIExvYWQgSVYKLQliZXF6CQlhNSwgLkxjdHNfZGVjcnlwdFxA Ci0JYWVzX2NiY19jdHNfZW5jcnlwdCBca2V5bGVuCi0uTGN0c19kZWNyeXB0XEA6Ci0JYWVzX2Ni Y19jdHNfZGVjcnlwdCBca2V5bGVuCi0uZW5kbQotCi0vLyB2b2lkIGFlc19jYmNfY3RzX2NyeXB0 X3p2a25lZChjb25zdCBzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmtleSwKLS8vCQkJICAgICAgICAg Y29uc3QgdTggKmluLCB1OCAqb3V0LCBzaXplX3QgbGVuLAotLy8JCQkJIGNvbnN0IHU4IGl2WzE2 XSwgYm9vbCBlbmMpOwotLy8KLS8vIEVuY3J5cHRzIG9yIGRlY3J5cHRzIGEgbWVzc2FnZSB3aXRo IHRoZSBDUzMgdmFyaWFudCBvZiBBRVMtQ0JDLUNUUy4KLS8vIFRoaXMgaXMgdGhlIHZhcmlhbnQg dGhhdCB1bmNvbmRpdGlvbmFsbHkgc3dhcHMgdGhlIGxhc3QgdHdvIGJsb2Nrcy4KLVNZTV9GVU5D X1NUQVJUKGFlc19jYmNfY3RzX2NyeXB0X3p2a25lZCkKLQlhZXNfYmVnaW4JS0VZUCwgMTI4Ziwg MTkyZgotCWFlc19jYmNfY3RzX2NyeXB0IDI1NgotMTI4OgotCWFlc19jYmNfY3RzX2NyeXB0IDEy OAotMTkyOgotCWFlc19jYmNfY3RzX2NyeXB0IDE5MgotU1lNX0ZVTkNfRU5EKGFlc19jYmNfY3Rz X2NyeXB0X3p2a25lZCkKZGlmZiAtLWdpdCBhL2NyeXB0by9hZXMuYyBiL2NyeXB0by9hZXMuYwpp bmRleCA5YjllNWI0MTNmYzQuLjFkYWFhNTlkMGNkZiAxMDA2NDQKLS0tIGEvY3J5cHRvL2Flcy5j CisrKyBiL2NyeXB0by9hZXMuYwpAQCAtNjI2LDcgKzYyNiw4IEBAIHN0YXRpYyBzdHJ1Y3Qgc2tj aXBoZXJfYWxnIHNrY2lwaGVyX2FsZ3NbXSA9IHsKIAl7CiAJCS5iYXNlLmNyYV9uYW1lID0gImNi YyhhZXMpIiwKIAkJLmJhc2UuY3JhX2RyaXZlcl9uYW1lID0gImNiYy1hZXMtbGliIiwKLQkJLmJh c2UuY3JhX3ByaW9yaXR5ID0gSVNfRU5BQkxFRChDT05GSUdfWDg2KSA/IDMwMCA6IDExMCwKKwkJ LmJhc2UuY3JhX3ByaW9yaXR5ID0gKElTX0VOQUJMRUQoQ09ORklHX1JJU0NWKSB8fAorCQkJCSAg ICAgIElTX0VOQUJMRUQoQ09ORklHX1g4NikpID8gMzAwIDogMTEwLAogCQkuYmFzZS5jcmFfYmxv Y2tzaXplID0gQUVTX0JMT0NLX1NJWkUsCiAJCS5iYXNlLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0 cnVjdCBhZXNfa2V5KSwKIAkJLmJhc2UuY3JhX21vZHVsZSA9IFRISVNfTU9EVUxFLApAQCAtNjUy LDcgKzY1Myw4IEBAIHN0YXRpYyBzdHJ1Y3Qgc2tjaXBoZXJfYWxnIHNrY2lwaGVyX2FsZ3NbXSA9 IHsKIAl7CiAJCS5iYXNlLmNyYV9uYW1lID0gImN0cyhjYmMoYWVzKSkiLAogCQkuYmFzZS5jcmFf ZHJpdmVyX25hbWUgPSAiY3RzLWNiYy1hZXMtbGliIiwKLQkJLmJhc2UuY3JhX3ByaW9yaXR5ID0g SVNfRU5BQkxFRChDT05GSUdfWDg2KSA/IDMwMCA6IDExMCwKKwkJLmJhc2UuY3JhX3ByaW9yaXR5 ID0gKElTX0VOQUJMRUQoQ09ORklHX1JJU0NWKSB8fAorCQkJCSAgICAgIElTX0VOQUJMRUQoQ09O RklHX1g4NikpID8gMzAwIDogMTEwLAogCQkuYmFzZS5jcmFfYmxvY2tzaXplID0gQUVTX0JMT0NL X1NJWkUsCiAJCS5iYXNlLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBhZXNfa2V5KSwKIAkJ LmJhc2UuY3JhX21vZHVsZSA9IFRISVNfTU9EVUxFLApkaWZmIC0tZ2l0IGEvbGliL2NyeXB0by9y aXNjdi9hZXMtcmlzY3Y2NC16dmtuZWQuUyBiL2xpYi9jcnlwdG8vcmlzY3YvYWVzLXJpc2N2NjQt enZrbmVkLlMKaW5kZXggMzcwMDAyOGU2MmVhLi42MWMxZjE4NWMzM2QgMTAwNjQ0Ci0tLSBhL2xp Yi9jcnlwdG8vcmlzY3YvYWVzLXJpc2N2NjQtenZrbmVkLlMKKysrIGIvbGliL2NyeXB0by9yaXNj di9hZXMtcmlzY3Y2NC16dmtuZWQuUwpAQCAtMTMyLDMgKzEzMiwyMzggQEAgU1lNX0ZVTkNfRU5E KGFlc19lY2JfZW5jcnlwdF96dmtuZWQpCiBTWU1fRlVOQ19TVEFSVChhZXNfZWNiX2RlY3J5cHRf enZrbmVkKQogCWFlc19lY2JfY3J5cHQJMAogU1lNX0ZVTkNfRU5EKGFlc19lY2JfZGVjcnlwdF96 dmtuZWQpCisKKyN1bmRlZiBEU1QKKyN1bmRlZiBTUkMKKyN1bmRlZiBMRU4KKyN1bmRlZiBLRVlQ CisKKyNkZWZpbmUgRFNUCQlhMAorI2RlZmluZSBTUkMJCWExCisjZGVmaW5lIExFTgkJYTIKKyNk ZWZpbmUgSVZQCQlhMworI2RlZmluZSBLRVlQCQlhNAorCisubWFjcm8JYWVzX2NiY19lbmNyeXB0 CWtleWxlbgorCXZsZTMyLnYJCXYxNiwgKElWUCkJLy8gTG9hZCBJVgorMToKKwl2bGUzMi52CQl2 MTcsIChTUkMpCS8vIExvYWQgcGxhaW50ZXh0IGJsb2NrCisJdnhvci52dgkJdjE2LCB2MTYsIHYx NwkvLyBYT1Igd2l0aCBJViBvciBwcmV2IGNpcGhlcnRleHQgYmxvY2sKKwlhZXNfZW5jcnlwdAl2 MTYsIFxrZXlsZW4JLy8gRW5jcnlwdAorCXZzZTMyLnYJCXYxNiwgKERTVCkJLy8gU3RvcmUgY2lw aGVydGV4dCBibG9jaworCWFkZGkJCVNSQywgU1JDLCAxNgorCWFkZGkJCURTVCwgRFNULCAxNgor CWFkZGkJCUxFTiwgTEVOLCAtMTYKKwlibmV6CQlMRU4sIDFiCisKKwl2c2UzMi52CQl2MTYsIChJ VlApCS8vIFN0b3JlIG5leHQgSVYKKwlyZXQKKy5lbmRtCisKKy5tYWNybwlhZXNfY2JjX2RlY3J5 cHQJa2V5bGVuCisJc3JsaQkJTEVOLCBMRU4sIDIJLy8gQ29udmVydCBMRU4gZnJvbSBieXRlcyB0 byB3b3JkcworCXZsZTMyLnYJCXYxNiwgKElWUCkJLy8gTG9hZCBJVgorMToKKwl2c2V0dmxpCQl0 MCwgTEVOLCBlMzIsIG00LCB0YSwgbWEKKwl2bGUzMi52CQl2MjAsIChTUkMpCS8vIExvYWQgY2lw aGVydGV4dCBibG9ja3MKKwl2c2xpZGV1cC52aQl2MTYsIHYyMCwgNAkvLyBTZXR1cCBwcmV2IGNp cGhlcnRleHQgYmxvY2tzCisJYWRkaQkJdDEsIHQwLCAtNAorCXZzbGlkZWRvd24udngJdjI0LCB2 MjAsIHQxCS8vIFNhdmUgbGFzdCBjaXBoZXJ0ZXh0IGJsb2NrCisJYWVzX2RlY3J5cHQJdjIwLCBc a2V5bGVuCS8vIERlY3J5cHQgdGhlIGJsb2NrcworCXZ4b3IudnYJCXYyMCwgdjIwLCB2MTYJLy8g WE9SIHdpdGggcHJldiBjaXBoZXJ0ZXh0IGJsb2NrcworCXZzZTMyLnYJCXYyMCwgKERTVCkJLy8g U3RvcmUgcGxhaW50ZXh0IGJsb2NrcworCXZtdi52LnYJCXYxNiwgdjI0CS8vIE5leHQgIklWIiBp cyBsYXN0IGNpcGhlcnRleHQgYmxvY2sKKwlzbGxpCQl0MSwgdDAsIDIJLy8gV29yZHMgdG8gYnl0 ZXMKKwlhZGQJCVNSQywgU1JDLCB0MQorCWFkZAkJRFNULCBEU1QsIHQxCisJc3ViCQlMRU4sIExF TiwgdDAKKwlibmV6CQlMRU4sIDFiCisKKwl2c2V0aXZsaQl6ZXJvLCA0LCBlMzIsIG0xLCB0YSwg bWEKKwl2c2UzMi52CQl2MTYsIChJVlApCS8vIFN0b3JlIG5leHQgSVYKKwlyZXQKKy5lbmRtCisK Ky8vIHZvaWQgYWVzX2NiY19lbmNyeXB0X3p2a25lZCh1OCAqZHN0LCBjb25zdCB1OCAqc3JjLCBz aXplX3QgbGVuLAorLy8JCQkgICAgICAgdTggaXZbQUVTX0JMT0NLX1NJWkVdLAorLy8JCQkgICAg ICAgY29uc3Qgc3RydWN0IGFlc19lbmNrZXkgKmtleSk7CisvLworLy8gfGxlbnwgbXVzdCBiZSBu b256ZXJvIGFuZCBhIG11bHRpcGxlIG9mIDE2IChBRVNfQkxPQ0tfU0laRSkuCitTWU1fRlVOQ19T VEFSVChhZXNfY2JjX2VuY3J5cHRfenZrbmVkKQorCWFlc19iZWdpbglLRVlQLCAxMjhmLCAxOTJm CisJYWVzX2NiY19lbmNyeXB0CTI1NgorMTI4OgorCWFlc19jYmNfZW5jcnlwdAkxMjgKKzE5MjoK KwlhZXNfY2JjX2VuY3J5cHQJMTkyCitTWU1fRlVOQ19FTkQoYWVzX2NiY19lbmNyeXB0X3p2a25l ZCkKKworLy8gdm9pZCBhZXNfY2JjX2RlY3J5cHRfenZrbmVkKHU4ICpkc3QsIGNvbnN0IHU4ICpz cmMsIHNpemVfdCBsZW4sCisvLwkJCSAgICAgICB1OCBpdltBRVNfQkxPQ0tfU0laRV0sCisvLwkJ CSAgICAgICBjb25zdCBzdHJ1Y3QgYWVzX2tleSAqa2V5KTsKKy8vCisvLyB8bGVufCBtdXN0IGJl IG5vbnplcm8gYW5kIGEgbXVsdGlwbGUgb2YgMTYgKEFFU19CTE9DS19TSVpFKS4KK1NZTV9GVU5D X1NUQVJUKGFlc19jYmNfZGVjcnlwdF96dmtuZWQpCisJYWVzX2JlZ2luCUtFWVAsIDEyOGYsIDE5 MmYKKwlhZXNfY2JjX2RlY3J5cHQJMjU2CisxMjg6CisJYWVzX2NiY19kZWNyeXB0CTEyOAorMTky OgorCWFlc19jYmNfZGVjcnlwdAkxOTIKK1NZTV9GVU5DX0VORChhZXNfY2JjX2RlY3J5cHRfenZr bmVkKQorCisjdW5kZWYgRFNUCisjdW5kZWYgU1JDCisjdW5kZWYgTEVOCisjdW5kZWYgSVZQCisj dW5kZWYgS0VZUAorCisjZGVmaW5lIERTVAkJYTAKKyNkZWZpbmUgU1JDCQlhMQorI2RlZmluZSBM RU4JCWEyCisjZGVmaW5lIElWUAkJYTMKKyNkZWZpbmUgS0VZUAkJYTQKKyNkZWZpbmUgRU5DCQlh NQorCisubWFjcm8JYWVzX2NiY19jdHNfZW5jcnlwdAlrZXlsZW4KKworCS8vIENCQy1lbmNyeXB0 IGFsbCBibG9ja3MgZXhjZXB0IHRoZSBsYXN0LiAgQnV0IGRvbid0IHN0b3JlIHRoZQorCS8vIHNl Y29uZC10by1sYXN0IGJsb2NrIHRvIHRoZSBvdXRwdXQgYnVmZmVyIHlldCwgc2luY2UgaXQgd2ls bCBiZQorCS8vIGhhbmRsZWQgc3BlY2lhbGx5IGluIHRoZSBjaXBoZXJ0ZXh0IHN0ZWFsaW5nIHN0 ZXAuCisJbGkJCXQwLCAxNgorCWoJCTJmCisxOgorCXZzZTMyLnYJCXYxNiwgKERTVCkJLy8gU3Rv cmUgY2lwaGVydGV4dCBibG9jaworCWFkZGkJCURTVCwgRFNULCAxNgorMjoKKwl2bGUzMi52CQl2 MTcsIChTUkMpCS8vIExvYWQgcGxhaW50ZXh0IGJsb2NrCisJdnhvci52dgkJdjE2LCB2MTYsIHYx NwkvLyBYT1Igd2l0aCBJViBvciBwcmV2IGNpcGhlcnRleHQgYmxvY2sKKwlhZXNfZW5jcnlwdAl2 MTYsIFxrZXlsZW4JLy8gRW5jcnlwdAorCWFkZGkJCVNSQywgU1JDLCAxNgorCWFkZGkJCUxFTiwg TEVOLCAtMTYKKwliZ3QJCUxFTiwgdDAsIDFiCS8vIFJlcGVhdCBpZiBtb3JlIHRoYW4gb25lIGJs b2NrIHJlbWFpbnMKKworCS8vIEVuY3J5cHQgdGhlIGxhc3QgdHdvIGJsb2NrcyB1c2luZyBjaXBo ZXJ0ZXh0IHN0ZWFsaW5nIGFzIGZvbGxvd3M6CisJLy8JQ1tuLTFdID0gRW5jcnlwdChFbmNyeXB0 KFBbbi0xXSBeIENbbi0yXSkgXiBQW25dKQorCS8vCUNbbl0gPSBFbmNyeXB0KFBbbi0xXSBeIENb bi0yXSlbMC4uTEVOXQorCS8vCisJLy8gQ1tpXSBkZW5vdGVzIHRoZSBpJ3RoIGNpcGhlcnRleHQg YmxvY2ssIGFuZCBsaWtld2lzZSBQW2ldIHRoZSBpJ3RoCisJLy8gcGxhaW50ZXh0IGJsb2NrLiAg QmxvY2sgbiwgdGhlIGxhc3QgYmxvY2ssIG1heSBiZSBwYXJ0aWFsOyBpdHMgbGVuZ3RoCisJLy8g aXMgMSA8PSBMRU4gPD0gMTYuICBJZiB0aGVyZSBhcmUgb25seSAyIGJsb2NrcywgQ1tuLTJdIG1l YW5zIHRoZSBJVi4KKwkvLworCS8vIHYxNiBhbHJlYWR5IGNvbnRhaW5zIEVuY3J5cHQoUFtuLTFd IF4gQ1tuLTJdKS4KKwkvLyBTUkMgcG9pbnRzIHRvIFBbbl0uICBEU1QgcG9pbnRzIHRvIHdoZXJl IENbbi0xXSBzaG91bGQgZ28uCisJLy8gVG8gc3VwcG9ydCBpbi1wbGFjZSBlbmNyeXB0aW9uLCBs b2FkIFBbbl0gYmVmb3JlIHN0b3JpbmcgQ1tuXS4KKwlhZGRpCQl0MCwgRFNULCAxNgkvLyBHZXQg cG9pbnRlciB0byB3aGVyZSBDW25dIHNob3VsZCBnbworCXZzZXR2bGkJCXplcm8sIExFTiwgZTgs IG0xLCB0dSwgbWEKKwl2bGU4LnYJCXYxNywgKFNSQykJLy8gTG9hZCBQW25dCisJdnNlOC52CQl2 MTYsICh0MCkJLy8gU3RvcmUgQ1tuXQorCXZ4b3IudnYJCXYxNiwgdjE2LCB2MTcJLy8gdjE2ID0g RW5jcnlwdChQW24tMV0gXiBDW24tMl0pIF4gUFtuXQorCXZzZXRpdmxpCXplcm8sIDQsIGUzMiwg bTEsIHRhLCBtYQorCWFlc19lbmNyeXB0CXYxNiwgXGtleWxlbgorCXZzZTMyLnYJCXYxNiwgKERT VCkJLy8gU3RvcmUgQ1tuLTFdCisJcmV0CisuZW5kbQorCisjZGVmaW5lIExFTjMyCQl0NCAvLyBM ZW5ndGggb2YgcmVtYWluaW5nIGZ1bGwgYmxvY2tzIGluIDMyLWJpdCB3b3JkcworI2RlZmluZSBM RU5fTU9EMTYJdDUgLy8gTGVuZ3RoIG9mIG1lc3NhZ2UgaW4gYnl0ZXMgbW9kIDE2CisKKy5tYWNy bwlhZXNfY2JjX2N0c19kZWNyeXB0CWtleWxlbgorCWFuZGkJCUxFTjMyLCBMRU4sIH4xNQorCXNy bGkJCUxFTjMyLCBMRU4zMiwgMgorCWFuZGkJCUxFTl9NT0QxNiwgTEVOLCAxNQorCisJLy8gU2F2 ZSBDW24tMl0gaW4gdjI4IHNvIHRoYXQgaXQncyBhdmFpbGFibGUgbGF0ZXIgZHVyaW5nIHRoZSBj aXBoZXJ0ZXh0CisJLy8gc3RlYWxpbmcgc3RlcC4gIElmIHRoZXJlIGFyZSBmZXdlciB0aGFuIHRo cmVlIGJsb2NrcywgQ1tuLTJdIG1lYW5zCisJLy8gdGhlIElWLCBvdGhlcndpc2UgaXQgbWVhbnMg dGhlIHRoaXJkLXRvLWxhc3QgY2lwaGVydGV4dCBibG9jay4KKwl2bXYudi52CQl2MjgsIHYxNgkv LyBJVgorCWFkZAkJdDAsIExFTiwgLTMzCisJYmx0egkJdDAsIC5MY3RzX2RlY3J5cHRfbG9vcFxA CisJYW5kaQkJdDAsIHQwLCB+MTUKKwlhZGQJCXQwLCB0MCwgU1JDCisJdmxlMzIudgkJdjI4LCAo dDApCisKKwkvLyBDQkMtZGVjcnlwdCBhbGwgZnVsbCBibG9ja3MuICBGb3IgdGhlIGxhc3QgZnVs bCBibG9jaywgb3IgdGhlIGxhc3QgMgorCS8vIGZ1bGwgYmxvY2tzIGlmIHRoZSBtZXNzYWdlIGlz IGJsb2NrLWFsaWduZWQsIHRoaXMgZG9lc24ndCB3cml0ZSB0aGUKKwkvLyBjb3JyZWN0IG91dHB1 dCBibG9ja3MsIGJlY2F1c2UgaXQgWE9ScyB0aGUgd3JvbmcgdmFsdWVzIHdpdGggdGhlIHJhdwor CS8vIEFFUyBwbGFpbnRleHRzLiAgQnV0IHdlIGZpeCB0aGlzIGFmdGVyIHRoaXMgbG9vcCB3aXRo b3V0IHJlZG9pbmcgdGhlCisJLy8gQUVTIGRlY3J5cHRpb25zLiAgVGhpcyBhcHByb2FjaCBhbGxv d3MgbW9yZSBvZiB0aGUgQUVTIGRlY3J5cHRpb25zIHRvCisJLy8gYmUgcGFyYWxsZWxpemVkLgor LkxjdHNfZGVjcnlwdF9sb29wXEA6CisJdnNldHZsaQkJdDAsIExFTjMyLCBlMzIsIG00LCB0YSwg bWEKKwlhZGRpCQl0MSwgdDAsIC00CisJdmxlMzIudgkJdjIwLCAoU1JDKQkvLyBMb2FkIG5leHQg c2V0IG9mIGNpcGhlcnRleHQgYmxvY2tzCisJdm12LnYudgkJdjI0LCB2MTYJLy8gR2V0IElWIG9y IGxhc3QgY2lwaGVydGV4dCBibG9jayBvZiBwcmV2IHNldAorCXZzbGlkZXVwLnZpCXYyNCwgdjIw LCA0CS8vIFNldHVwIHByZXYgY2lwaGVydGV4dCBibG9ja3MKKwl2c2xpZGVkb3duLnZ4CXYxNiwg djIwLCB0MQkvLyBTYXZlIGxhc3QgY2lwaGVydGV4dCBibG9jayBvZiB0aGlzIHNldAorCWFlc19k ZWNyeXB0CXYyMCwgXGtleWxlbgkvLyBEZWNyeXB0IHRoaXMgc2V0IG9mIGJsb2NrcworCXZ4b3Iu dnYJCXYyNCwgdjI0LCB2MjAJLy8gWE9SIHByZXYgY2lwaGVydGV4dCBibG9ja3Mgd2l0aCBkZWNy eXB0ZWQgYmxvY2tzCisJdnNlMzIudgkJdjI0LCAoRFNUKQkvLyBTdG9yZSB0aGlzIHNldCBvZiBw bGFpbnRleHQgYmxvY2tzCisJc3ViCQlMRU4zMiwgTEVOMzIsIHQwCisJc2xsaQkJdDAsIHQwLCAy CS8vIFdvcmRzIHRvIGJ5dGVzCisJYWRkCQlTUkMsIFNSQywgdDAKKwlhZGQJCURTVCwgRFNULCB0 MAorCWJuZXoJCUxFTjMyLCAuTGN0c19kZWNyeXB0X2xvb3BcQAorCisJdnNldGl2bGkJemVybywg NCwgZTMyLCBtNCwgdGEsIG1hCisJdnNsaWRlZG93bi52eAl2MjAsIHYyMCwgdDEJLy8gRXh0cmFj dCByYXcgcGxhaW50ZXh0IG9mIGxhc3QgZnVsbCBibG9jaworCWFkZGkJCXQwLCBEU1QsIC0xNgkv LyBHZXQgcG9pbnRlciB0byBsYXN0IGZ1bGwgcGxhaW50ZXh0IGJsb2NrCisJYm5legkJTEVOX01P RDE2LCAuTGN0c19kZWNyeXB0X25vbl9ibG9ja19hbGlnbmVkXEAKKworCS8vIEJsb2NrLWFsaWdu ZWQgbWVzc2FnZS4gIEp1c3QgZml4IHVwIHRoZSBsYXN0IDIgYmxvY2tzLiAgV2UgbmVlZDoKKwkv LworCS8vCVBbbi0xXSA9IERlY3J5cHQoQ1tuXSkgXiBDW24tMl0KKwkvLwlQW25dID0gRGVjcnlw dChDW24tMV0pIF4gQ1tuXQorCS8vCisJLy8gV2UgaGF2ZSBDW25dIGluIHYxNiwgRGVjcnlwdChD W25dKSBpbiB2MjAsIGFuZCBDW24tMl0gaW4gdjI4LgorCS8vIFRvZ2V0aGVyIHdpdGggRGVjcnlw dChDW24tMV0pIF4gQ1tuLTJdIGZyb20gdGhlIG91dHB1dCBidWZmZXIsIHRoaXMKKwkvLyBpcyBl dmVyeXRoaW5nIG5lZWRlZCB0byBmaXggdGhlIG91dHB1dCB3aXRob3V0IHJlLWRlY3J5cHRpbmcg YmxvY2tzLgorCWFkZGkJCXQxLCBEU1QsIC0zMgkvLyBHZXQgcG9pbnRlciB0byB3aGVyZSBQW24t MV0gc2hvdWxkIGdvCisJdnhvci52dgkJdjIwLCB2MjAsIHYyOAkvLyBEZWNyeXB0KENbbl0pIF4g Q1tuLTJdID09IFBbbi0xXQorCXZsZTMyLnYJCXYyNCwgKHQxKQkvLyBEZWNyeXB0KENbbi0xXSkg XiBDW24tMl0KKwl2c2UzMi52CQl2MjAsICh0MSkJLy8gU3RvcmUgUFtuLTFdCisJdnhvci52dgkJ djIwLCB2MjQsIHYxNgkvLyBEZWNyeXB0KENbbi0xXSkgXiBDW24tMl0gXiBDW25dID09IFBbbl0g XiBDW24tMl0KKwlqCQkuTGN0c19kZWNyeXB0X2ZpbmlzaFxACisKKy5MY3RzX2RlY3J5cHRfbm9u X2Jsb2NrX2FsaWduZWRcQDoKKwkvLyBEZWNyeXB0IHRoZSBsYXN0IHR3byBibG9ja3MgdXNpbmcg Y2lwaGVydGV4dCBzdGVhbGluZyBhcyBmb2xsb3dzOgorCS8vCisJLy8JUFtuLTFdID0gRGVjcnlw dChDW25dIHx8IERlY3J5cHQoQ1tuLTFdKVtMRU5fTU9EMTYuLjE2XSkgXiBDW24tMl0KKwkvLwlQ W25dID0gKERlY3J5cHQoQ1tuLTFdKSBeIENbbl0pWzAuLkxFTl9NT0QxNl0KKwkvLworCS8vIFdl IGFscmVhZHkgaGF2ZSBEZWNyeXB0KENbbi0xXSkgaW4gdjIwIGFuZCBDW24tMl0gaW4gdjI4Lgor CXZtdi52LnYJCXYxNiwgdjIwCS8vIHYxNiA9IERlY3J5cHQoQ1tuLTFdKQorCXZzZXR2bGkJCXpl cm8sIExFTl9NT0QxNiwgZTgsIG0xLCB0dSwgbWEKKwl2bGU4LnYJCXYyMCwgKFNSQykJLy8gdjIw ID0gQ1tuXSB8fCBEZWNyeXB0KENbbi0xXSlbTEVOX01PRDE2Li4xNl0KKwl2eG9yLnZ2CQl2MTYs IHYxNiwgdjIwCS8vIHYxNiA9IERlY3J5cHQoQ1tuLTFdKSBeIENbbl0KKwl2c2U4LnYJCXYxNiwg KERTVCkJLy8gU3RvcmUgUFtuXQorCXZzZXRpdmxpCXplcm8sIDQsIGUzMiwgbTEsIHRhLCBtYQor CWFlc19kZWNyeXB0CXYyMCwgXGtleWxlbgkvLyB2MjAgPSBEZWNyeXB0KENbbl0gfHwgRGVjcnlw dChDW24tMV0pW0xFTl9NT0QxNi4uMTZdKQorLkxjdHNfZGVjcnlwdF9maW5pc2hcQDoKKwl2eG9y LnZ2CQl2MjAsIHYyMCwgdjI4CS8vIFhPUiB3aXRoIENbbi0yXQorCXZzZTMyLnYJCXYyMCwgKHQw KQkvLyBTdG9yZSBsYXN0IGZ1bGwgcGxhaW50ZXh0IGJsb2NrCisJcmV0CisuZW5kbQorCisubWFj cm8JYWVzX2NiY19jdHNfY3J5cHQJa2V5bGVuCisJdmxlMzIudgkJdjE2LCAoSVZQKQkvLyBMb2Fk IElWCisJYmVxegkJRU5DLCAuTGN0c19kZWNyeXB0XEAKKwlhZXNfY2JjX2N0c19lbmNyeXB0IFxr ZXlsZW4KKy5MY3RzX2RlY3J5cHRcQDoKKwlhZXNfY2JjX2N0c19kZWNyeXB0IFxrZXlsZW4KKy5l bmRtCisKKy8vIHZvaWQgYWVzX2NiY19jdHNfY3J5cHRfenZrbmVkKHU4ICpkc3QsIGNvbnN0IHU4 ICpzcmMsIHNpemVfdCBsZW4sCisvLwkJCQkgY29uc3QgdTggaXZbQUVTX0JMT0NLX1NJWkVdLAor Ly8JCQkJIGFlc19lbmNyeXB0X2FyZyBrZXksIGJvb2wgZW5jKTsKKy8vCisvLyBFbmNyeXB0cyBv ciBkZWNyeXB0cyBsZW4gPj0gMTcgYnl0ZXMgb2YgZGF0YSB1c2luZyB0aGUgQ1MzIHZhcmlhbnQg b2YKKy8vIEFFUy1DQkMtQ1RTLiAgVGhpcyBpcyB0aGUgdmFyaWFudCB0aGF0IGFsd2F5cyBzd2Fw cyB0aGUgbGFzdCB0d28gYmxvY2tzLgorU1lNX0ZVTkNfU1RBUlQoYWVzX2NiY19jdHNfY3J5cHRf enZrbmVkKQorCWFlc19iZWdpbglLRVlQLCAxMjhmLCAxOTJmCisJYWVzX2NiY19jdHNfY3J5cHQg MjU2CisxMjg6CisJYWVzX2NiY19jdHNfY3J5cHQgMTI4CisxOTI6CisJYWVzX2NiY19jdHNfY3J5 cHQgMTkyCitTWU1fRlVOQ19FTkQoYWVzX2NiY19jdHNfY3J5cHRfenZrbmVkKQpkaWZmIC0tZ2l0 IGEvbGliL2NyeXB0by9yaXNjdi9hZXMuaCBiL2xpYi9jcnlwdG8vcmlzY3YvYWVzLmgKaW5kZXgg NWIzNmQwMTQ3ZDkzLi4xNTBjZGE4MmNiODkgMTAwNjQ0Ci0tLSBhL2xpYi9jcnlwdG8vcmlzY3Yv YWVzLmgKKysrIGIvbGliL2NyeXB0by9yaXNjdi9hZXMuaApAQCAtOTMsNiArOTMsNzQgQEAgc3Rh dGljIGJvb2wgYWVzX2VjYl9kZWNyeXB0X2FyY2godTggKmRzdCwgY29uc3QgdTggKnNyYywgc2l6 ZV90IGxlbiwKIH0KICNlbmRpZiAvKiBDT05GSUdfQ1JZUFRPX0xJQl9BRVNfRUNCICovCiAKKyNp ZiBJU19FTkFCTEVEKENPTkZJR19DUllQVE9fTElCX0FFU19DQkMpCit2b2lkIGFlc19jYmNfZW5j cnlwdF96dmtuZWQodTggKmRzdCwgY29uc3QgdTggKnNyYywgc2l6ZV90IGxlbiwKKwkJCSAgICB1 OCBpdltBRVNfQkxPQ0tfU0laRV0sIGNvbnN0IHN0cnVjdCBhZXNfZW5ja2V5ICprZXkpOwordm9p ZCBhZXNfY2JjX2RlY3J5cHRfenZrbmVkKHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMsIHNpemVfdCBs ZW4sCisJCQkgICAgdTggaXZbQUVTX0JMT0NLX1NJWkVdLCBjb25zdCBzdHJ1Y3QgYWVzX2tleSAq a2V5KTsKK3ZvaWQgYWVzX2NiY19jdHNfY3J5cHRfenZrbmVkKHU4ICpkc3QsIGNvbnN0IHU4ICpz cmMsIHNpemVfdCBsZW4sCisJCQkgICAgICBjb25zdCB1OCBpdltBRVNfQkxPQ0tfU0laRV0sCisJ CQkgICAgICBhZXNfZW5jcnlwdF9hcmcga2V5LCBib29sIGVuYyk7CisKKy8qIGxlbiBpcyBhbHdh eXMgYSBwb3NpdGl2ZSBtdWx0aXBsZSBvZiBBRVNfQkxPQ0tfU0laRSBoZXJlLiAqLworI2RlZmlu ZSBhZXNfY2JjX2VuY3J5cHRfYXJjaCBhZXNfY2JjX2VuY3J5cHRfYXJjaAorc3RhdGljIGJvb2wg YWVzX2NiY19lbmNyeXB0X2FyY2godTggKmRzdCwgY29uc3QgdTggKnNyYywgc2l6ZV90IGxlbiwK KwkJCQkgdTggaXZbQUVTX0JMT0NLX1NJWkVdLAorCQkJCSBjb25zdCBzdHJ1Y3QgYWVzX2VuY2tl eSAqa2V5KQoreworCWlmICghc3RhdGljX2JyYW5jaF9saWtlbHkoJmhhdmVfenZrbmVkKSB8fCB1 bmxpa2VseSghbWF5X3VzZV9zaW1kKCkpKQorCQlyZXR1cm4gZmFsc2U7CisJa2VybmVsX3ZlY3Rv cl9iZWdpbigpOworCWFlc19jYmNfZW5jcnlwdF96dmtuZWQoZHN0LCBzcmMsIGxlbiwgaXYsIGtl eSk7CisJa2VybmVsX3ZlY3Rvcl9lbmQoKTsKKwlyZXR1cm4gdHJ1ZTsKK30KKworLyogbGVuIGlz IGFsd2F5cyBhIHBvc2l0aXZlIG11bHRpcGxlIG9mIEFFU19CTE9DS19TSVpFIGhlcmUuICovCisj ZGVmaW5lIGFlc19jYmNfZGVjcnlwdF9hcmNoIGFlc19jYmNfZGVjcnlwdF9hcmNoCitzdGF0aWMg Ym9vbCBhZXNfY2JjX2RlY3J5cHRfYXJjaCh1OCAqZHN0LCBjb25zdCB1OCAqc3JjLCBzaXplX3Qg bGVuLAorCQkJCSB1OCBpdltBRVNfQkxPQ0tfU0laRV0sCisJCQkJIGNvbnN0IHN0cnVjdCBhZXNf a2V5ICprZXkpCit7CisJaWYgKCFzdGF0aWNfYnJhbmNoX2xpa2VseSgmaGF2ZV96dmtuZWQpIHx8 IHVubGlrZWx5KCFtYXlfdXNlX3NpbWQoKSkpCisJCXJldHVybiBmYWxzZTsKKwlrZXJuZWxfdmVj dG9yX2JlZ2luKCk7CisJYWVzX2NiY19kZWNyeXB0X3p2a25lZChkc3QsIHNyYywgbGVuLCBpdiwg a2V5KTsKKwlrZXJuZWxfdmVjdG9yX2VuZCgpOworCXJldHVybiB0cnVlOworfQorCisvKiBsZW4g Y2FuIGJlIGFueSB2YWx1ZSBncmVhdGVyIHRoYW4gQUVTX0JMT0NLX1NJWkUgaGVyZS4gKi8KKyNk ZWZpbmUgYWVzX2NiY19jdHNfZW5jcnlwdF9hcmNoIGFlc19jYmNfY3RzX2VuY3J5cHRfYXJjaAor c3RhdGljIGJvb2wgYWVzX2NiY19jdHNfZW5jcnlwdF9hcmNoKHU4ICpkc3QsIGNvbnN0IHU4ICpz cmMsIHNpemVfdCBsZW4sCisJCQkJICAgICB1OCBpdltBRVNfQkxPQ0tfU0laRV0sCisJCQkJICAg ICBjb25zdCBzdHJ1Y3QgYWVzX2VuY2tleSAqa2V5KQoreworCWlmICghc3RhdGljX2JyYW5jaF9s aWtlbHkoJmhhdmVfenZrbmVkKSB8fCB1bmxpa2VseSghbWF5X3VzZV9zaW1kKCkpKQorCQlyZXR1 cm4gZmFsc2U7CisKKwlrZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJYWVzX2NiY19jdHNfY3J5cHRf enZrbmVkKGRzdCwgc3JjLCBsZW4sIGl2LCBrZXksIHRydWUpOworCWtlcm5lbF92ZWN0b3JfZW5k KCk7CisJcmV0dXJuIHRydWU7Cit9CisKKy8qIGxlbiBjYW4gYmUgYW55IHZhbHVlIGdyZWF0ZXIg dGhhbiBBRVNfQkxPQ0tfU0laRSBoZXJlLiAqLworI2RlZmluZSBhZXNfY2JjX2N0c19kZWNyeXB0 X2FyY2ggYWVzX2NiY19jdHNfZGVjcnlwdF9hcmNoCitzdGF0aWMgYm9vbCBhZXNfY2JjX2N0c19k ZWNyeXB0X2FyY2godTggKmRzdCwgY29uc3QgdTggKnNyYywgc2l6ZV90IGxlbiwKKwkJCQkgICAg IHU4IGl2W0FFU19CTE9DS19TSVpFXSwKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBhZXNfa2V5ICpr ZXkpCit7CisJaWYgKCFzdGF0aWNfYnJhbmNoX2xpa2VseSgmaGF2ZV96dmtuZWQpIHx8IHVubGlr ZWx5KCFtYXlfdXNlX3NpbWQoKSkpCisJCXJldHVybiBmYWxzZTsKKworCWtlcm5lbF92ZWN0b3Jf YmVnaW4oKTsKKwlhZXNfY2JjX2N0c19jcnlwdF96dmtuZWQoZHN0LCBzcmMsIGxlbiwgaXYsIGtl eSwgZmFsc2UpOworCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJcmV0dXJuIHRydWU7Cit9CisjZW5k aWYgLyogQ09ORklHX0NSWVBUT19MSUJfQUVTX0NCQyAqLworCiAjZGVmaW5lIGFlc19tb2RfaW5p dF9hcmNoIGFlc19tb2RfaW5pdF9hcmNoCiBzdGF0aWMgdm9pZCBhZXNfbW9kX2luaXRfYXJjaCh2 b2lkKQogewotLSAKMi41NS4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmlu ZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9s aW51eC1yaXNjdgo=