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 79744CF45C8 for ; Mon, 12 Jan 2026 19:24:24 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type: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=SEoENnWUcb8l0Cmsrhzc+Gdxwbk1lpPM3wnRuQBpEso=; b=jHHr+PBlPRD6Q7OuVTukl4Z3fO c601JfAI2ZaP6vLVidwORAqiyRs0UyrxLfiBuy2bdluO84VfXI8SawmDfZ9e8sT4KoDBl+gZO9ASR IqgOZIdTSKDfVTUZ5FHw1KMi/pn3I7Ls0oTI6yJs1WfYJevpvGLu1QyTGAAuKD6dQibeDKY5Xkoz/ 9tBqVCCMsHlb4GQqz3gqNA94hTxXhQFPGWX95VWmbL9a5TxNZpOZhieYLA74fBqlnROm079qbjKsW Q3mtsEHA/tz4boQ9BeNOqVrSa5r2AzJ5agV7GmEIL/+qmZY8Qq4dMXIVjN41ke18/4N7wVpzJJay2 ZDJ8LMGg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1vfNWO-0000000601t-41z1; Mon, 12 Jan 2026 19:24:13 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1vfNVe-00000005yzB-06kB; Mon, 12 Jan 2026 19:23:28 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sea.source.kernel.org (Postfix) with ESMTP id CD15040630; Mon, 12 Jan 2026 19:23:25 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4252DC19422; Mon, 12 Jan 2026 19:23:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1768245805; bh=cAzlxjnfetAXICKQEDRHR7jpw8oC/uEaOKgrdLNR7pI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pqT16Xv5y39AtbmZYAgOkHjMWCOa/h4oZZmyTmq0R4g9MqhPim0TUNaaIMF0+v9ze GsnV3fuIps6KEtb87qL3FbYr4EoQRM/M3VAguchs2auk6wcNXGZufbX69abPZcPkE8 63X9xxnUfPinp28JVmVSIvjQwFrH2cjGKSUmGsbqcqb6CB9JzwtJWlifgMRYUPfn9x 8fadfn9CewGB62+Zhn7oxXxU+VERktjR06ce8npPtrH9id1Uk2Ln4g3wqaDda2OXVU TaY3zHzfmGReU8xSJEBgbYZxPy9gnv3tR6lhLF7/x0I/eXHUD6QwSY9Ux/LB6ZBgIK sYxHbcLk1xb5Q== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , "Jason A . Donenfeld" , Herbert Xu , linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, sparclinux@vger.kernel.org, x86@kernel.org, Holger Dengler , Harald Freudenberger , Eric Biggers Subject: [PATCH v2 14/35] lib/crypto: riscv/aes: Migrate optimized code into library Date: Mon, 12 Jan 2026 11:20:12 -0800 Message-ID: <20260112192035.10427-15-ebiggers@kernel.org> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260112192035.10427-1-ebiggers@kernel.org> References: <20260112192035.10427-1-ebiggers@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260112_112326_157368_86CCEE6E X-CRM114-Status: GOOD ( 29.59 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Move the aes_encrypt_zvkned() and aes_decrypt_zvkned() assembly functions into lib/crypto/, wire them up to the AES library API, and remove the "aes-riscv64-zvkned" crypto_cipher algorithm. To make this possible, change the prototypes of these functions to take (rndkeys, key_len) instead of a pointer to crypto_aes_ctx, and change the RISC-V AES-XTS code to implement tweak encryption using the AES library instead of directly calling aes_encrypt_zvkned(). The result is that both the AES library and crypto_cipher APIs use RISC-V's AES instructions, whereas previously only crypto_cipher did (and it wasn't enabled by default, which this commit fixes as well). Acked-by: Ard Biesheuvel Signed-off-by: Eric Biggers --- arch/riscv/crypto/Kconfig | 2 - arch/riscv/crypto/aes-macros.S | 12 +++- arch/riscv/crypto/aes-riscv64-glue.c | 81 ++----------------------- arch/riscv/crypto/aes-riscv64-zvkned.S | 27 --------- lib/crypto/Kconfig | 2 + lib/crypto/Makefile | 1 + lib/crypto/riscv/aes-riscv64-zvkned.S | 84 ++++++++++++++++++++++++++ lib/crypto/riscv/aes.h | 63 +++++++++++++++++++ 8 files changed, 166 insertions(+), 106 deletions(-) create mode 100644 lib/crypto/riscv/aes-riscv64-zvkned.S create mode 100644 lib/crypto/riscv/aes.h diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index 14c5acb935e9..22d4eaab15f3 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -4,15 +4,13 @@ menu "Accelerated Cryptographic Algorithms for CPU (riscv)" config CRYPTO_AES_RISCV64 tristate "Ciphers: AES, modes: ECB, CBC, CTS, CTR, XTS" depends on 64BIT && TOOLCHAIN_HAS_VECTOR_CRYPTO && \ RISCV_EFFICIENT_VECTOR_UNALIGNED_ACCESS - select CRYPTO_ALGAPI select CRYPTO_LIB_AES select CRYPTO_SKCIPHER help - Block cipher: AES cipher algorithms Length-preserving ciphers: AES with ECB, CBC, CTS, CTR, XTS Architecture: riscv64 using: - Zvkned vector crypto extension - Zvbb vector extension (XTS) diff --git a/arch/riscv/crypto/aes-macros.S b/arch/riscv/crypto/aes-macros.S index d1a258d04bc7..1384164621a5 100644 --- a/arch/riscv/crypto/aes-macros.S +++ b/arch/riscv/crypto/aes-macros.S @@ -49,12 +49,14 @@ // - If AES-128, loads round keys into v1-v11 and jumps to \label128. // - If AES-192, loads round keys into v1-v13 and jumps to \label192. // - If AES-256, loads round keys into v1-v15 and continues onwards. // // Also sets vl=4 and vtype=e32,m1,ta,ma. Clobbers t0 and t1. -.macro aes_begin keyp, label128, label192 +.macro aes_begin keyp, label128, label192, key_len +.ifb \key_len lwu t0, 480(\keyp) // t0 = key length in bytes +.endif li t1, 24 // t1 = key length for AES-192 vsetivli zero, 4, e32, m1, ta, ma vle32.v v1, (\keyp) addi \keyp, \keyp, 16 vle32.v v2, (\keyp) @@ -74,16 +76,24 @@ vle32.v v9, (\keyp) addi \keyp, \keyp, 16 vle32.v v10, (\keyp) addi \keyp, \keyp, 16 vle32.v v11, (\keyp) +.ifb \key_len blt t0, t1, \label128 // If AES-128, goto label128. +.else + blt \key_len, t1, \label128 // If AES-128, goto label128. +.endif addi \keyp, \keyp, 16 vle32.v v12, (\keyp) addi \keyp, \keyp, 16 vle32.v v13, (\keyp) +.ifb \key_len beq t0, t1, \label192 // If AES-192, goto label192. +.else + beq \key_len, t1, \label192 // If AES-192, goto label192. +.endif // Else, it's AES-256. addi \keyp, \keyp, 16 vle32.v v14, (\keyp) addi \keyp, \keyp, 16 vle32.v v15, (\keyp) diff --git a/arch/riscv/crypto/aes-riscv64-glue.c b/arch/riscv/crypto/aes-riscv64-glue.c index f814ee048555..8bbf7f348c23 100644 --- a/arch/riscv/crypto/aes-riscv64-glue.c +++ b/arch/riscv/crypto/aes-riscv64-glue.c @@ -1,9 +1,8 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * AES using the RISC-V vector crypto extensions. Includes the bare block - * cipher and the ECB, CBC, CBC-CTS, CTR, and XTS modes. + * AES modes using the RISC-V vector crypto extensions * * Copyright (C) 2023 VRULL GmbH * Author: Heiko Stuebner * * Copyright (C) 2023 SiFive, Inc. @@ -13,25 +12,17 @@ */ #include #include #include -#include #include #include #include #include #include #include -asmlinkage void aes_encrypt_zvkned(const struct crypto_aes_ctx *key, - const u8 in[AES_BLOCK_SIZE], - u8 out[AES_BLOCK_SIZE]); -asmlinkage void aes_decrypt_zvkned(const struct crypto_aes_ctx *key, - const u8 in[AES_BLOCK_SIZE], - u8 out[AES_BLOCK_SIZE]); - asmlinkage void aes_ecb_encrypt_zvkned(const struct crypto_aes_ctx *key, const u8 *in, u8 *out, size_t len); asmlinkage void aes_ecb_decrypt_zvkned(const struct crypto_aes_ctx *key, const u8 *in, u8 *out, size_t len); @@ -84,54 +75,18 @@ static int riscv64_aes_setkey(struct crypto_aes_ctx *ctx, * struct crypto_aes_ctx and aes_expandkey() everywhere. */ return aes_expandkey(ctx, key, keylen); } -static int riscv64_aes_setkey_cipher(struct crypto_tfm *tfm, - const u8 *key, unsigned int keylen) -{ - struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); - - return riscv64_aes_setkey(ctx, key, keylen); -} - static int riscv64_aes_setkey_skcipher(struct crypto_skcipher *tfm, const u8 *key, unsigned int keylen) { struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); return riscv64_aes_setkey(ctx, key, keylen); } -/* Bare AES, without a mode of operation */ - -static void riscv64_aes_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) -{ - const struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); - - if (crypto_simd_usable()) { - kernel_vector_begin(); - aes_encrypt_zvkned(ctx, src, dst); - kernel_vector_end(); - } else { - aes_encrypt(ctx, dst, src); - } -} - -static void riscv64_aes_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) -{ - const struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); - - if (crypto_simd_usable()) { - kernel_vector_begin(); - aes_decrypt_zvkned(ctx, src, dst); - kernel_vector_end(); - } else { - aes_decrypt(ctx, dst, src); - } -} - /* AES-ECB */ static inline int riscv64_aes_ecb_crypt(struct skcipher_request *req, bool enc) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); @@ -336,21 +291,21 @@ static int riscv64_aes_ctr_crypt(struct skcipher_request *req) /* AES-XTS */ struct riscv64_aes_xts_ctx { struct crypto_aes_ctx ctx1; - struct crypto_aes_ctx ctx2; + struct aes_enckey tweak_key; }; static int riscv64_aes_xts_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int keylen) { struct riscv64_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm); return xts_verify_key(tfm, key, keylen) ?: riscv64_aes_setkey(&ctx->ctx1, key, keylen / 2) ?: - riscv64_aes_setkey(&ctx->ctx2, key + keylen / 2, keylen / 2); + aes_prepareenckey(&ctx->tweak_key, key + keylen / 2, keylen / 2); } static int riscv64_aes_xts_crypt(struct skcipher_request *req, bool enc) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); @@ -364,13 +319,11 @@ static int riscv64_aes_xts_crypt(struct skcipher_request *req, bool enc) if (req->cryptlen < AES_BLOCK_SIZE) return -EINVAL; /* Encrypt the IV with the tweak key to get the first tweak. */ - kernel_vector_begin(); - aes_encrypt_zvkned(&ctx->ctx2, req->iv, req->iv); - kernel_vector_end(); + aes_encrypt(&ctx->tweak_key, req->iv, req->iv); err = skcipher_walk_virt(&walk, req, false); /* * If the message length isn't divisible by the AES block size and the @@ -454,27 +407,10 @@ static int riscv64_aes_xts_decrypt(struct skcipher_request *req) return riscv64_aes_xts_crypt(req, false); } /* Algorithm definitions */ -static struct crypto_alg riscv64_zvkned_aes_cipher_alg = { - .cra_flags = CRYPTO_ALG_TYPE_CIPHER, - .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct crypto_aes_ctx), - .cra_priority = 300, - .cra_name = "aes", - .cra_driver_name = "aes-riscv64-zvkned", - .cra_cipher = { - .cia_min_keysize = AES_MIN_KEY_SIZE, - .cia_max_keysize = AES_MAX_KEY_SIZE, - .cia_setkey = riscv64_aes_setkey_cipher, - .cia_encrypt = riscv64_aes_encrypt, - .cia_decrypt = riscv64_aes_decrypt, - }, - .cra_module = THIS_MODULE, -}; - static struct skcipher_alg riscv64_zvkned_aes_skcipher_algs[] = { { .setkey = riscv64_aes_setkey_skcipher, .encrypt = riscv64_aes_ecb_encrypt, .decrypt = riscv64_aes_ecb_decrypt, @@ -572,19 +508,15 @@ static int __init riscv64_aes_mod_init(void) { int err = -ENODEV; if (riscv_isa_extension_available(NULL, ZVKNED) && riscv_vector_vlen() >= 128) { - err = crypto_register_alg(&riscv64_zvkned_aes_cipher_alg); - if (err) - return err; - err = crypto_register_skciphers( riscv64_zvkned_aes_skcipher_algs, ARRAY_SIZE(riscv64_zvkned_aes_skcipher_algs)); if (err) - goto unregister_zvkned_cipher_alg; + return err; if (riscv_isa_extension_available(NULL, ZVKB)) { err = crypto_register_skcipher( &riscv64_zvkned_zvkb_aes_skcipher_alg); if (err) @@ -605,12 +537,10 @@ static int __init riscv64_aes_mod_init(void) 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)); -unregister_zvkned_cipher_alg: - crypto_unregister_alg(&riscv64_zvkned_aes_cipher_alg); return err; } static void __exit riscv64_aes_mod_exit(void) { @@ -618,11 +548,10 @@ 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)); - crypto_unregister_alg(&riscv64_zvkned_aes_cipher_alg); } module_init(riscv64_aes_mod_init); module_exit(riscv64_aes_mod_exit); diff --git a/arch/riscv/crypto/aes-riscv64-zvkned.S b/arch/riscv/crypto/aes-riscv64-zvkned.S index 23d063f94ce6..d0fc4581a380 100644 --- a/arch/riscv/crypto/aes-riscv64-zvkned.S +++ b/arch/riscv/crypto/aes-riscv64-zvkned.S @@ -54,37 +54,10 @@ #define INP a1 #define OUTP a2 #define LEN a3 #define IVP a4 -.macro __aes_crypt_zvkned enc, keylen - vle32.v v16, (INP) - aes_crypt v16, \enc, \keylen - vse32.v v16, (OUTP) - ret -.endm - -.macro aes_crypt_zvkned enc - aes_begin KEYP, 128f, 192f - __aes_crypt_zvkned \enc, 256 -128: - __aes_crypt_zvkned \enc, 128 -192: - __aes_crypt_zvkned \enc, 192 -.endm - -// void aes_encrypt_zvkned(const struct crypto_aes_ctx *key, -// const u8 in[16], u8 out[16]); -SYM_FUNC_START(aes_encrypt_zvkned) - aes_crypt_zvkned 1 -SYM_FUNC_END(aes_encrypt_zvkned) - -// Same prototype and calling convention as the encryption function -SYM_FUNC_START(aes_decrypt_zvkned) - aes_crypt_zvkned 0 -SYM_FUNC_END(aes_decrypt_zvkned) - .macro __aes_ecb_crypt enc, keylen srli t0, LEN, 2 // t0 is the remaining length in 32-bit words. It's a multiple of 4. 1: vsetvli t1, t0, e32, m8, ta, ma diff --git a/lib/crypto/Kconfig b/lib/crypto/Kconfig index a0f1c105827e..2690b5ffc5ca 100644 --- a/lib/crypto/Kconfig +++ b/lib/crypto/Kconfig @@ -15,10 +15,12 @@ config CRYPTO_LIB_AES_ARCH bool depends on CRYPTO_LIB_AES && !UML && !KMSAN default y if ARM default y if ARM64 default y if PPC && (SPE || (PPC64 && VSX)) + default y if RISCV && 64BIT && TOOLCHAIN_HAS_VECTOR_CRYPTO && \ + RISCV_EFFICIENT_VECTOR_UNALIGNED_ACCESS config CRYPTO_LIB_AESCFB tristate select CRYPTO_LIB_AES select CRYPTO_LIB_UTILS diff --git a/lib/crypto/Makefile b/lib/crypto/Makefile index 16140616ace8..811b60787dd5 100644 --- a/lib/crypto/Makefile +++ b/lib/crypto/Makefile @@ -48,10 +48,11 @@ $(obj)/powerpc/aesp8-ppc.S: $(src)/powerpc/aesp8-ppc.pl FORCE targets += powerpc/aesp8-ppc.S OBJECT_FILES_NON_STANDARD_powerpc/aesp8-ppc.o := y endif # !CONFIG_SPE endif # CONFIG_PPC +libaes-$(CONFIG_RISCV) += riscv/aes-riscv64-zvkned.o endif # CONFIG_CRYPTO_LIB_AES_ARCH ################################################################################ obj-$(CONFIG_CRYPTO_LIB_AESCFB) += libaescfb.o diff --git a/lib/crypto/riscv/aes-riscv64-zvkned.S b/lib/crypto/riscv/aes-riscv64-zvkned.S new file mode 100644 index 000000000000..0d988bc3d37b --- /dev/null +++ b/lib/crypto/riscv/aes-riscv64-zvkned.S @@ -0,0 +1,84 @@ +/* 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 "../../arch/riscv/crypto/aes-macros.S" + +#define RNDKEYS a0 +#define KEY_LEN a1 +#define OUTP a2 +#define INP a3 + +.macro __aes_crypt_zvkned enc, keybits + vle32.v v16, (INP) + aes_crypt v16, \enc, \keybits + vse32.v v16, (OUTP) + ret +.endm + +.macro aes_crypt_zvkned enc + aes_begin RNDKEYS, 128f, 192f, KEY_LEN + __aes_crypt_zvkned \enc, 256 +128: + __aes_crypt_zvkned \enc, 128 +192: + __aes_crypt_zvkned \enc, 192 +.endm + +// void aes_encrypt_zvkned(const u32 rndkeys[], int key_len, +// u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]); +SYM_FUNC_START(aes_encrypt_zvkned) + aes_crypt_zvkned 1 +SYM_FUNC_END(aes_encrypt_zvkned) + +// void aes_decrypt_zvkned(const u32 rndkeys[], int key_len, +// u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]); +SYM_FUNC_START(aes_decrypt_zvkned) + aes_crypt_zvkned 0 +SYM_FUNC_END(aes_decrypt_zvkned) diff --git a/lib/crypto/riscv/aes.h b/lib/crypto/riscv/aes.h new file mode 100644 index 000000000000..0b26f58faf2b --- /dev/null +++ b/lib/crypto/riscv/aes.h @@ -0,0 +1,63 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2023 VRULL GmbH + * Copyright (C) 2023 SiFive, Inc. + * Copyright 2024 Google LLC + */ + +#include +#include + +static __ro_after_init DEFINE_STATIC_KEY_FALSE(have_zvkned); + +void aes_encrypt_zvkned(const u32 rndkeys[], int key_len, + u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]); +void aes_decrypt_zvkned(const u32 rndkeys[], int key_len, + u8 out[AES_BLOCK_SIZE], const u8 in[AES_BLOCK_SIZE]); + +static void aes_preparekey_arch(union aes_enckey_arch *k, + union aes_invkey_arch *inv_k, + const u8 *in_key, int key_len, int nrounds) +{ + aes_expandkey_generic(k->rndkeys, inv_k ? inv_k->inv_rndkeys : NULL, + in_key, key_len); +} + +static void aes_encrypt_arch(const struct aes_enckey *key, + u8 out[AES_BLOCK_SIZE], + const u8 in[AES_BLOCK_SIZE]) +{ + if (static_branch_likely(&have_zvkned) && likely(may_use_simd())) { + kernel_vector_begin(); + aes_encrypt_zvkned(key->k.rndkeys, key->len, out, in); + kernel_vector_end(); + } else { + aes_encrypt_generic(key->k.rndkeys, key->nrounds, out, in); + } +} + +static void aes_decrypt_arch(const struct aes_key *key, + u8 out[AES_BLOCK_SIZE], + const u8 in[AES_BLOCK_SIZE]) +{ + /* + * Note that the Zvkned code uses the standard round keys, while the + * fallback uses the inverse round keys. Thus both must be present. + */ + if (static_branch_likely(&have_zvkned) && likely(may_use_simd())) { + kernel_vector_begin(); + aes_decrypt_zvkned(key->k.rndkeys, key->len, out, in); + kernel_vector_end(); + } else { + aes_decrypt_generic(key->inv_k.inv_rndkeys, key->nrounds, + out, in); + } +} + +#define aes_mod_init_arch aes_mod_init_arch +static void aes_mod_init_arch(void) +{ + if (riscv_isa_extension_available(NULL, ZVKNED) && + riscv_vector_vlen() >= 128) + static_branch_enable(&have_zvkned); +} -- 2.52.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 C106BCF45C5 for ; Mon, 12 Jan 2026 19:24:34 +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=lD9ke02pY4XuwtiZDgAqr4wiA6XzRd4zwhgTr3QsBOE=; b=aOZVHN5ZaChqOn CsXb1D0szq9Yyjr1e6tPh/ZhfpY7pfDpnQ7xMJV+xUCq8A/VW88mQmQm3trmOZkY6rllEsy+/poU3 WkAs09cg40l/k5s6qrMZsDg7gFagR1mCeKOTb+bN2ixYX5yESr1kvFLMFqh6xDUu8yNBrQCFoRfxd Fa1orW+Y7YKB99RcimojpdbtDNI/OgAYzWKCLt5KZt1MEs0+yYE/aRzqaRFWeT2zEi2dRJopVZmx8 lRhJ2CMgsL7D4kOQBBb1q9lsObqgSHEo+XSD17q2wqrvxcL0tytasCLnSu0zxFYYTv2cfxMKG6Nwt ouBblotPySluR8EU3mwQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1vfNWS-0000000606M-1d5H; Mon, 12 Jan 2026 19:24:16 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1vfNVe-00000005yzB-06kB; Mon, 12 Jan 2026 19:23:28 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sea.source.kernel.org (Postfix) with ESMTP id CD15040630; Mon, 12 Jan 2026 19:23:25 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4252DC19422; Mon, 12 Jan 2026 19:23:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1768245805; bh=cAzlxjnfetAXICKQEDRHR7jpw8oC/uEaOKgrdLNR7pI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pqT16Xv5y39AtbmZYAgOkHjMWCOa/h4oZZmyTmq0R4g9MqhPim0TUNaaIMF0+v9ze GsnV3fuIps6KEtb87qL3FbYr4EoQRM/M3VAguchs2auk6wcNXGZufbX69abPZcPkE8 63X9xxnUfPinp28JVmVSIvjQwFrH2cjGKSUmGsbqcqb6CB9JzwtJWlifgMRYUPfn9x 8fadfn9CewGB62+Zhn7oxXxU+VERktjR06ce8npPtrH9id1Uk2Ln4g3wqaDda2OXVU TaY3zHzfmGReU8xSJEBgbYZxPy9gnv3tR6lhLF7/x0I/eXHUD6QwSY9Ux/LB6ZBgIK sYxHbcLk1xb5Q== From: Eric Biggers To: linux-crypto@vger.kernel.org Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , "Jason A . Donenfeld" , Herbert Xu , linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, sparclinux@vger.kernel.org, x86@kernel.org, Holger Dengler , Harald Freudenberger , Eric Biggers Subject: [PATCH v2 14/35] lib/crypto: riscv/aes: Migrate optimized code into library Date: Mon, 12 Jan 2026 11:20:12 -0800 Message-ID: <20260112192035.10427-15-ebiggers@kernel.org> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260112192035.10427-1-ebiggers@kernel.org> References: <20260112192035.10427-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260112_112326_157368_86CCEE6E X-CRM114-Status: GOOD ( 29.59 ) 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 TW92ZSB0aGUgYWVzX2VuY3J5cHRfenZrbmVkKCkgYW5kIGFlc19kZWNyeXB0X3p2a25lZCgpIGFz c2VtYmx5CmZ1bmN0aW9ucyBpbnRvIGxpYi9jcnlwdG8vLCB3aXJlIHRoZW0gdXAgdG8gdGhlIEFF UyBsaWJyYXJ5IEFQSSwgYW5kCnJlbW92ZSB0aGUgImFlcy1yaXNjdjY0LXp2a25lZCIgY3J5cHRv X2NpcGhlciBhbGdvcml0aG0uCgpUbyBtYWtlIHRoaXMgcG9zc2libGUsIGNoYW5nZSB0aGUgcHJv dG90eXBlcyBvZiB0aGVzZSBmdW5jdGlvbnMgdG8KdGFrZSAocm5ka2V5cywga2V5X2xlbikgaW5z dGVhZCBvZiBhIHBvaW50ZXIgdG8gY3J5cHRvX2Flc19jdHgsIGFuZApjaGFuZ2UgdGhlIFJJU0Mt ViBBRVMtWFRTIGNvZGUgdG8gaW1wbGVtZW50IHR3ZWFrIGVuY3J5cHRpb24gdXNpbmcgdGhlCkFF UyBsaWJyYXJ5IGluc3RlYWQgb2YgZGlyZWN0bHkgY2FsbGluZyBhZXNfZW5jcnlwdF96dmtuZWQo KS4KClRoZSByZXN1bHQgaXMgdGhhdCBib3RoIHRoZSBBRVMgbGlicmFyeSBhbmQgY3J5cHRvX2Np cGhlciBBUElzIHVzZQpSSVNDLVYncyBBRVMgaW5zdHJ1Y3Rpb25zLCB3aGVyZWFzIHByZXZpb3Vz bHkgb25seSBjcnlwdG9fY2lwaGVyIGRpZAooYW5kIGl0IHdhc24ndCBlbmFibGVkIGJ5IGRlZmF1 bHQsIHdoaWNoIHRoaXMgY29tbWl0IGZpeGVzIGFzIHdlbGwpLgoKQWNrZWQtYnk6IEFyZCBCaWVz aGV1dmVsIDxhcmRiQGtlcm5lbC5vcmc+ClNpZ25lZC1vZmYtYnk6IEVyaWMgQmlnZ2VycyA8ZWJp Z2dlcnNAa2VybmVsLm9yZz4KLS0tCiBhcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnICAgICAgICAg ICAgICB8ICAyIC0KIGFyY2gvcmlzY3YvY3J5cHRvL2Flcy1tYWNyb3MuUyAgICAgICAgIHwgMTIg KysrLQogYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2NjQtZ2x1ZS5jICAgfCA4MSArKy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiBhcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlzY3Y2NC16dmtuZWQu UyB8IDI3IC0tLS0tLS0tLQogbGliL2NyeXB0by9LY29uZmlnICAgICAgICAgICAgICAgICAgICAg fCAgMiArCiBsaWIvY3J5cHRvL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICB8ICAxICsKIGxp Yi9jcnlwdG8vcmlzY3YvYWVzLXJpc2N2NjQtenZrbmVkLlMgIHwgODQgKysrKysrKysrKysrKysr KysrKysrKysrKysKIGxpYi9jcnlwdG8vcmlzY3YvYWVzLmggICAgICAgICAgICAgICAgIHwgNjMg KysrKysrKysrKysrKysrKysrKwogOCBmaWxlcyBjaGFuZ2VkLCAxNjYgaW5zZXJ0aW9ucygrKSwg MTA2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGxpYi9jcnlwdG8vcmlzY3YvYWVz LXJpc2N2NjQtenZrbmVkLlMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBsaWIvY3J5cHRvL3Jpc2N2L2Fl cy5oCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZyBiL2FyY2gvcmlzY3Yv Y3J5cHRvL0tjb25maWcKaW5kZXggMTRjNWFjYjkzNWU5Li4yMmQ0ZWFhYjE1ZjMgMTAwNjQ0Ci0t LSBhL2FyY2gvcmlzY3YvY3J5cHRvL0tjb25maWcKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2Nv bmZpZwpAQCAtNCwxNSArNCwxMyBAQCBtZW51ICJBY2NlbGVyYXRlZCBDcnlwdG9ncmFwaGljIEFs Z29yaXRobXMgZm9yIENQVSAocmlzY3YpIgogCiBjb25maWcgQ1JZUFRPX0FFU19SSVNDVjY0CiAJ dHJpc3RhdGUgIkNpcGhlcnM6IEFFUywgbW9kZXM6IEVDQiwgQ0JDLCBDVFMsIENUUiwgWFRTIgog CWRlcGVuZHMgb24gNjRCSVQgJiYgVE9PTENIQUlOX0hBU19WRUNUT1JfQ1JZUFRPICYmIFwKIAkJ ICAgUklTQ1ZfRUZGSUNJRU5UX1ZFQ1RPUl9VTkFMSUdORURfQUNDRVNTCi0Jc2VsZWN0IENSWVBU T19BTEdBUEkKIAlzZWxlY3QgQ1JZUFRPX0xJQl9BRVMKIAlzZWxlY3QgQ1JZUFRPX1NLQ0lQSEVS CiAJaGVscAotCSAgQmxvY2sgY2lwaGVyOiBBRVMgY2lwaGVyIGFsZ29yaXRobXMKIAkgIExlbmd0 aC1wcmVzZXJ2aW5nIGNpcGhlcnM6IEFFUyB3aXRoIEVDQiwgQ0JDLCBDVFMsIENUUiwgWFRTCiAK IAkgIEFyY2hpdGVjdHVyZTogcmlzY3Y2NCB1c2luZzoKIAkgIC0gWnZrbmVkIHZlY3RvciBjcnlw dG8gZXh0ZW5zaW9uCiAJICAtIFp2YmIgdmVjdG9yIGV4dGVuc2lvbiAoWFRTKQpkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9jcnlwdG8vYWVzLW1hY3Jvcy5TIGIvYXJjaC9yaXNjdi9jcnlwdG8vYWVz LW1hY3Jvcy5TCmluZGV4IGQxYTI1OGQwNGJjNy4uMTM4NDE2NDYyMWE1IDEwMDY0NAotLS0gYS9h cmNoL3Jpc2N2L2NyeXB0by9hZXMtbWFjcm9zLlMKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vYWVz LW1hY3Jvcy5TCkBAIC00OSwxMiArNDksMTQgQEAKIC8vICAgLSBJZiBBRVMtMTI4LCBsb2FkcyBy b3VuZCBrZXlzIGludG8gdjEtdjExIGFuZCBqdW1wcyB0byBcbGFiZWwxMjguCiAvLyAgIC0gSWYg QUVTLTE5MiwgbG9hZHMgcm91bmQga2V5cyBpbnRvIHYxLXYxMyBhbmQganVtcHMgdG8gXGxhYmVs MTkyLgogLy8gICAtIElmIEFFUy0yNTYsIGxvYWRzIHJvdW5kIGtleXMgaW50byB2MS12MTUgYW5k IGNvbnRpbnVlcyBvbndhcmRzLgogLy8KIC8vIEFsc28gc2V0cyB2bD00IGFuZCB2dHlwZT1lMzIs bTEsdGEsbWEuICBDbG9iYmVycyB0MCBhbmQgdDEuCi0ubWFjcm8JYWVzX2JlZ2luCWtleXAsIGxh YmVsMTI4LCBsYWJlbDE5MgorLm1hY3JvCWFlc19iZWdpbglrZXlwLCBsYWJlbDEyOCwgbGFiZWwx OTIsIGtleV9sZW4KKy5pZmIgXGtleV9sZW4KIAlsd3UJCXQwLCA0ODAoXGtleXApCS8vIHQwID0g a2V5IGxlbmd0aCBpbiBieXRlcworLmVuZGlmCiAJbGkJCXQxLCAyNAkJLy8gdDEgPSBrZXkgbGVu Z3RoIGZvciBBRVMtMTkyCiAJdnNldGl2bGkJemVybywgNCwgZTMyLCBtMSwgdGEsIG1hCiAJdmxl MzIudgkJdjEsIChca2V5cCkKIAlhZGRpCQlca2V5cCwgXGtleXAsIDE2CiAJdmxlMzIudgkJdjIs IChca2V5cCkKQEAgLTc0LDE2ICs3NiwyNCBAQAogCXZsZTMyLnYJCXY5LCAoXGtleXApCiAJYWRk aQkJXGtleXAsIFxrZXlwLCAxNgogCXZsZTMyLnYJCXYxMCwgKFxrZXlwKQogCWFkZGkJCVxrZXlw LCBca2V5cCwgMTYKIAl2bGUzMi52CQl2MTEsIChca2V5cCkKKy5pZmIgXGtleV9sZW4KIAlibHQJ CXQwLCB0MSwgXGxhYmVsMTI4CS8vIElmIEFFUy0xMjgsIGdvdG8gbGFiZWwxMjguCisuZWxzZQor CWJsdAkJXGtleV9sZW4sIHQxLCBcbGFiZWwxMjgJLy8gSWYgQUVTLTEyOCwgZ290byBsYWJlbDEy OC4KKy5lbmRpZgogCWFkZGkJCVxrZXlwLCBca2V5cCwgMTYKIAl2bGUzMi52CQl2MTIsIChca2V5 cCkKIAlhZGRpCQlca2V5cCwgXGtleXAsIDE2CiAJdmxlMzIudgkJdjEzLCAoXGtleXApCisuaWZi IFxrZXlfbGVuCiAJYmVxCQl0MCwgdDEsIFxsYWJlbDE5MgkvLyBJZiBBRVMtMTkyLCBnb3RvIGxh YmVsMTkyLgorLmVsc2UKKwliZXEJCVxrZXlfbGVuLCB0MSwgXGxhYmVsMTkyCS8vIElmIEFFUy0x OTIsIGdvdG8gbGFiZWwxOTIuCisuZW5kaWYKIAkvLyBFbHNlLCBpdCdzIEFFUy0yNTYuCiAJYWRk aQkJXGtleXAsIFxrZXlwLCAxNgogCXZsZTMyLnYJCXYxNCwgKFxrZXlwKQogCWFkZGkJCVxrZXlw LCBca2V5cCwgMTYKIAl2bGUzMi52CQl2MTUsIChca2V5cCkKZGlmZiAtLWdpdCBhL2FyY2gvcmlz Y3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUuYyBiL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNj djY0LWdsdWUuYwppbmRleCBmODE0ZWUwNDg1NTUuLjhiYmY3ZjM0OGMyMyAxMDA2NDQKLS0tIGEv YXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2NjQtZ2x1ZS5jCisrKyBiL2FyY2gvcmlzY3YvY3J5 cHRvL2Flcy1yaXNjdjY0LWdsdWUuYwpAQCAtMSw5ICsxLDggQEAKIC8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKIC8qCi0gKiBBRVMgdXNpbmcgdGhlIFJJU0MtViB2ZWN0 b3IgY3J5cHRvIGV4dGVuc2lvbnMuICBJbmNsdWRlcyB0aGUgYmFyZSBibG9jawotICogY2lwaGVy IGFuZCB0aGUgRUNCLCBDQkMsIENCQy1DVFMsIENUUiwgYW5kIFhUUyBtb2Rlcy4KKyAqIEFFUyBt b2RlcyB1c2luZyB0aGUgUklTQy1WIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9ucwogICoKICAqIENv cHlyaWdodCAoQykgMjAyMyBWUlVMTCBHbWJICiAgKiBBdXRob3I6IEhlaWtvIFN0dWVibmVyIDxo ZWlrby5zdHVlYm5lckB2cnVsbC5ldT4KICAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMjMgU2lGaXZl LCBJbmMuCkBAIC0xMywyNSArMTIsMTcgQEAKICAqLwogCiAjaW5jbHVkZSA8YXNtL3NpbWQuaD4K ICNpbmNsdWRlIDxhc20vdmVjdG9yLmg+CiAjaW5jbHVkZSA8Y3J5cHRvL2Flcy5oPgotI2luY2x1 ZGUgPGNyeXB0by9pbnRlcm5hbC9jaXBoZXIuaD4KICNpbmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwv c2ltZC5oPgogI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9za2NpcGhlci5oPgogI2luY2x1ZGUg PGNyeXB0by9zY2F0dGVyd2Fsay5oPgogI2luY2x1ZGUgPGNyeXB0by94dHMuaD4KICNpbmNsdWRl IDxsaW51eC9saW5rYWdlLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAKLWFzbWxpbmth Z2Ugdm9pZCBhZXNfZW5jcnlwdF96dmtuZWQoY29uc3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4ICpr ZXksCi0JCQkJICAgY29uc3QgdTggaW5bQUVTX0JMT0NLX1NJWkVdLAotCQkJCSAgIHU4IG91dFtB RVNfQkxPQ0tfU0laRV0pOwotYXNtbGlua2FnZSB2b2lkIGFlc19kZWNyeXB0X3p2a25lZChjb25z dCBzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmtleSwKLQkJCQkgICBjb25zdCB1OCBpbltBRVNfQkxP Q0tfU0laRV0sCi0JCQkJICAgdTggb3V0W0FFU19CTE9DS19TSVpFXSk7Ci0KIGFzbWxpbmthZ2Ug dm9pZCBhZXNfZWNiX2VuY3J5cHRfenZrbmVkKGNvbnN0IHN0cnVjdCBjcnlwdG9fYWVzX2N0eCAq a2V5LAogCQkJCSAgICAgICBjb25zdCB1OCAqaW4sIHU4ICpvdXQsIHNpemVfdCBsZW4pOwogYXNt bGlua2FnZSB2b2lkIGFlc19lY2JfZGVjcnlwdF96dmtuZWQoY29uc3Qgc3RydWN0IGNyeXB0b19h ZXNfY3R4ICprZXksCiAJCQkJICAgICAgIGNvbnN0IHU4ICppbiwgdTggKm91dCwgc2l6ZV90IGxl bik7CiAKQEAgLTg0LDU0ICs3NSwxOCBAQCBzdGF0aWMgaW50IHJpc2N2NjRfYWVzX3NldGtleShz dHJ1Y3QgY3J5cHRvX2Flc19jdHggKmN0eCwKIAkgKiAgIHN0cnVjdCBjcnlwdG9fYWVzX2N0eCBh bmQgYWVzX2V4cGFuZGtleSgpIGV2ZXJ5d2hlcmUuCiAJICovCiAJcmV0dXJuIGFlc19leHBhbmRr ZXkoY3R4LCBrZXksIGtleWxlbik7CiB9CiAKLXN0YXRpYyBpbnQgcmlzY3Y2NF9hZXNfc2V0a2V5 X2NpcGhlcihzdHJ1Y3QgY3J5cHRvX3RmbSAqdGZtLAotCQkJCSAgICAgY29uc3QgdTggKmtleSwg dW5zaWduZWQgaW50IGtleWxlbikKLXsKLQlzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmN0eCA9IGNy eXB0b190Zm1fY3R4KHRmbSk7Ci0KLQlyZXR1cm4gcmlzY3Y2NF9hZXNfc2V0a2V5KGN0eCwga2V5 LCBrZXlsZW4pOwotfQotCiBzdGF0aWMgaW50IHJpc2N2NjRfYWVzX3NldGtleV9za2NpcGhlcihz dHJ1Y3QgY3J5cHRvX3NrY2lwaGVyICp0Zm0sCiAJCQkJICAgICAgIGNvbnN0IHU4ICprZXksIHVu c2lnbmVkIGludCBrZXlsZW4pCiB7CiAJc3RydWN0IGNyeXB0b19hZXNfY3R4ICpjdHggPSBjcnlw dG9fc2tjaXBoZXJfY3R4KHRmbSk7CiAKIAlyZXR1cm4gcmlzY3Y2NF9hZXNfc2V0a2V5KGN0eCwg a2V5LCBrZXlsZW4pOwogfQogCi0vKiBCYXJlIEFFUywgd2l0aG91dCBhIG1vZGUgb2Ygb3BlcmF0 aW9uICovCi0KLXN0YXRpYyB2b2lkIHJpc2N2NjRfYWVzX2VuY3J5cHQoc3RydWN0IGNyeXB0b190 Zm0gKnRmbSwgdTggKmRzdCwgY29uc3QgdTggKnNyYykKLXsKLQljb25zdCBzdHJ1Y3QgY3J5cHRv X2Flc19jdHggKmN0eCA9IGNyeXB0b190Zm1fY3R4KHRmbSk7Ci0KLQlpZiAoY3J5cHRvX3NpbWRf dXNhYmxlKCkpIHsKLQkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOwotCQlhZXNfZW5jcnlwdF96dmtu ZWQoY3R4LCBzcmMsIGRzdCk7Ci0JCWtlcm5lbF92ZWN0b3JfZW5kKCk7Ci0JfSBlbHNlIHsKLQkJ YWVzX2VuY3J5cHQoY3R4LCBkc3QsIHNyYyk7Ci0JfQotfQotCi1zdGF0aWMgdm9pZCByaXNjdjY0 X2Flc19kZWNyeXB0KHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0sIHU4ICpkc3QsIGNvbnN0IHU4ICpz cmMpCi17Ci0JY29uc3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4ICpjdHggPSBjcnlwdG9fdGZtX2N0 eCh0Zm0pOwotCi0JaWYgKGNyeXB0b19zaW1kX3VzYWJsZSgpKSB7Ci0JCWtlcm5lbF92ZWN0b3Jf YmVnaW4oKTsKLQkJYWVzX2RlY3J5cHRfenZrbmVkKGN0eCwgc3JjLCBkc3QpOwotCQlrZXJuZWxf dmVjdG9yX2VuZCgpOwotCX0gZWxzZSB7Ci0JCWFlc19kZWNyeXB0KGN0eCwgZHN0LCBzcmMpOwot CX0KLX0KLQogLyogQUVTLUVDQiAqLwogCiBzdGF0aWMgaW5saW5lIGludCByaXNjdjY0X2Flc19l Y2JfY3J5cHQoc3RydWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSwgYm9vbCBlbmMpCiB7CiAJc3Ry dWN0IGNyeXB0b19za2NpcGhlciAqdGZtID0gY3J5cHRvX3NrY2lwaGVyX3JlcXRmbShyZXEpOwpA QCAtMzM2LDIxICsyOTEsMjEgQEAgc3RhdGljIGludCByaXNjdjY0X2Flc19jdHJfY3J5cHQoc3Ry dWN0IHNrY2lwaGVyX3JlcXVlc3QgKnJlcSkKIAogLyogQUVTLVhUUyAqLwogCiBzdHJ1Y3Qgcmlz Y3Y2NF9hZXNfeHRzX2N0eCB7CiAJc3RydWN0IGNyeXB0b19hZXNfY3R4IGN0eDE7Ci0Jc3RydWN0 IGNyeXB0b19hZXNfY3R4IGN0eDI7CisJc3RydWN0IGFlc19lbmNrZXkgdHdlYWtfa2V5OwogfTsK IAogc3RhdGljIGludCByaXNjdjY0X2Flc194dHNfc2V0a2V5KHN0cnVjdCBjcnlwdG9fc2tjaXBo ZXIgKnRmbSwgY29uc3QgdTggKmtleSwKIAkJCQkgIHVuc2lnbmVkIGludCBrZXlsZW4pCiB7CiAJ c3RydWN0IHJpc2N2NjRfYWVzX3h0c19jdHggKmN0eCA9IGNyeXB0b19za2NpcGhlcl9jdHgodGZt KTsKIAogCXJldHVybiB4dHNfdmVyaWZ5X2tleSh0Zm0sIGtleSwga2V5bGVuKSA/OgogCSAgICAg ICByaXNjdjY0X2Flc19zZXRrZXkoJmN0eC0+Y3R4MSwga2V5LCBrZXlsZW4gLyAyKSA/OgotCSAg ICAgICByaXNjdjY0X2Flc19zZXRrZXkoJmN0eC0+Y3R4Miwga2V5ICsga2V5bGVuIC8gMiwga2V5 bGVuIC8gMik7CisJICAgICAgIGFlc19wcmVwYXJlZW5ja2V5KCZjdHgtPnR3ZWFrX2tleSwga2V5 ICsga2V5bGVuIC8gMiwga2V5bGVuIC8gMik7CiB9CiAKIHN0YXRpYyBpbnQgcmlzY3Y2NF9hZXNf eHRzX2NyeXB0KHN0cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEsIGJvb2wgZW5jKQogewogCXN0 cnVjdCBjcnlwdG9fc2tjaXBoZXIgKnRmbSA9IGNyeXB0b19za2NpcGhlcl9yZXF0Zm0ocmVxKTsK QEAgLTM2NCwxMyArMzE5LDExIEBAIHN0YXRpYyBpbnQgcmlzY3Y2NF9hZXNfeHRzX2NyeXB0KHN0 cnVjdCBza2NpcGhlcl9yZXF1ZXN0ICpyZXEsIGJvb2wgZW5jKQogCiAJaWYgKHJlcS0+Y3J5cHRs ZW4gPCBBRVNfQkxPQ0tfU0laRSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKIAkvKiBFbmNyeXB0IHRo ZSBJViB3aXRoIHRoZSB0d2VhayBrZXkgdG8gZ2V0IHRoZSBmaXJzdCB0d2Vhay4gKi8KLQlrZXJu ZWxfdmVjdG9yX2JlZ2luKCk7Ci0JYWVzX2VuY3J5cHRfenZrbmVkKCZjdHgtPmN0eDIsIHJlcS0+ aXYsIHJlcS0+aXYpOwotCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJYWVzX2VuY3J5cHQoJmN0eC0+ dHdlYWtfa2V5LCByZXEtPml2LCByZXEtPml2KTsKIAogCWVyciA9IHNrY2lwaGVyX3dhbGtfdmly dCgmd2FsaywgcmVxLCBmYWxzZSk7CiAKIAkvKgogCSAqIElmIHRoZSBtZXNzYWdlIGxlbmd0aCBp c24ndCBkaXZpc2libGUgYnkgdGhlIEFFUyBibG9jayBzaXplIGFuZCB0aGUKQEAgLTQ1NCwyNyAr NDA3LDEwIEBAIHN0YXRpYyBpbnQgcmlzY3Y2NF9hZXNfeHRzX2RlY3J5cHQoc3RydWN0IHNrY2lw aGVyX3JlcXVlc3QgKnJlcSkKIAlyZXR1cm4gcmlzY3Y2NF9hZXNfeHRzX2NyeXB0KHJlcSwgZmFs c2UpOwogfQogCiAvKiBBbGdvcml0aG0gZGVmaW5pdGlvbnMgKi8KIAotc3RhdGljIHN0cnVjdCBj cnlwdG9fYWxnIHJpc2N2NjRfenZrbmVkX2Flc19jaXBoZXJfYWxnID0gewotCS5jcmFfZmxhZ3Mg PSBDUllQVE9fQUxHX1RZUEVfQ0lQSEVSLAotCS5jcmFfYmxvY2tzaXplID0gQUVTX0JMT0NLX1NJ WkUsCi0JLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBjcnlwdG9fYWVzX2N0eCksCi0JLmNy YV9wcmlvcml0eSA9IDMwMCwKLQkuY3JhX25hbWUgPSAiYWVzIiwKLQkuY3JhX2RyaXZlcl9uYW1l ID0gImFlcy1yaXNjdjY0LXp2a25lZCIsCi0JLmNyYV9jaXBoZXIgPSB7Ci0JCS5jaWFfbWluX2tl eXNpemUgPSBBRVNfTUlOX0tFWV9TSVpFLAotCQkuY2lhX21heF9rZXlzaXplID0gQUVTX01BWF9L RVlfU0laRSwKLQkJLmNpYV9zZXRrZXkgPSByaXNjdjY0X2Flc19zZXRrZXlfY2lwaGVyLAotCQku Y2lhX2VuY3J5cHQgPSByaXNjdjY0X2Flc19lbmNyeXB0LAotCQkuY2lhX2RlY3J5cHQgPSByaXNj djY0X2Flc19kZWNyeXB0LAotCX0sCi0JLmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwKLX07Ci0K IHN0YXRpYyBzdHJ1Y3Qgc2tjaXBoZXJfYWxnIHJpc2N2NjRfenZrbmVkX2Flc19za2NpcGhlcl9h bGdzW10gPSB7CiAJewogCQkuc2V0a2V5ID0gcmlzY3Y2NF9hZXNfc2V0a2V5X3NrY2lwaGVyLAog CQkuZW5jcnlwdCA9IHJpc2N2NjRfYWVzX2VjYl9lbmNyeXB0LAogCQkuZGVjcnlwdCA9IHJpc2N2 NjRfYWVzX2VjYl9kZWNyeXB0LApAQCAtNTcyLDE5ICs1MDgsMTUgQEAgc3RhdGljIGludCBfX2lu aXQgcmlzY3Y2NF9hZXNfbW9kX2luaXQodm9pZCkKIHsKIAlpbnQgZXJyID0gLUVOT0RFVjsKIAog CWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktORUQpICYmCiAJICAg IHJpc2N2X3ZlY3Rvcl92bGVuKCkgPj0gMTI4KSB7Ci0JCWVyciA9IGNyeXB0b19yZWdpc3Rlcl9h bGcoJnJpc2N2NjRfenZrbmVkX2Flc19jaXBoZXJfYWxnKTsKLQkJaWYgKGVycikKLQkJCXJldHVy biBlcnI7Ci0KIAkJZXJyID0gY3J5cHRvX3JlZ2lzdGVyX3NrY2lwaGVycygKIAkJCXJpc2N2NjRf enZrbmVkX2Flc19za2NpcGhlcl9hbGdzLAogCQkJQVJSQVlfU0laRShyaXNjdjY0X3p2a25lZF9h ZXNfc2tjaXBoZXJfYWxncykpOwogCQlpZiAoZXJyKQotCQkJZ290byB1bnJlZ2lzdGVyX3p2a25l ZF9jaXBoZXJfYWxnOworCQkJcmV0dXJuIGVycjsKIAogCQlpZiAocmlzY3ZfaXNhX2V4dGVuc2lv bl9hdmFpbGFibGUoTlVMTCwgWlZLQikpIHsKIAkJCWVyciA9IGNyeXB0b19yZWdpc3Rlcl9za2Np cGhlcigKIAkJCQkmcmlzY3Y2NF96dmtuZWRfenZrYl9hZXNfc2tjaXBoZXJfYWxnKTsKIAkJCWlm IChlcnIpCkBAIC02MDUsMTIgKzUzNywxMCBAQCBzdGF0aWMgaW50IF9faW5pdCByaXNjdjY0X2Fl c19tb2RfaW5pdCh2b2lkKQogCWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxM LCBaVktCKSkKIAkJY3J5cHRvX3VucmVnaXN0ZXJfc2tjaXBoZXIoJnJpc2N2NjRfenZrbmVkX3p2 a2JfYWVzX3NrY2lwaGVyX2FsZyk7CiB1bnJlZ2lzdGVyX3p2a25lZF9za2NpcGhlcl9hbGdzOgog CWNyeXB0b191bnJlZ2lzdGVyX3NrY2lwaGVycyhyaXNjdjY0X3p2a25lZF9hZXNfc2tjaXBoZXJf YWxncywKIAkJCQkgICAgQVJSQVlfU0laRShyaXNjdjY0X3p2a25lZF9hZXNfc2tjaXBoZXJfYWxn cykpOwotdW5yZWdpc3Rlcl96dmtuZWRfY2lwaGVyX2FsZzoKLQljcnlwdG9fdW5yZWdpc3Rlcl9h bGcoJnJpc2N2NjRfenZrbmVkX2Flc19jaXBoZXJfYWxnKTsKIAlyZXR1cm4gZXJyOwogfQogCiBz dGF0aWMgdm9pZCBfX2V4aXQgcmlzY3Y2NF9hZXNfbW9kX2V4aXQodm9pZCkKIHsKQEAgLTYxOCwx MSArNTQ4LDEwIEBAIHN0YXRpYyB2b2lkIF9fZXhpdCByaXNjdjY0X2Flc19tb2RfZXhpdCh2b2lk KQogCQljcnlwdG9fdW5yZWdpc3Rlcl9za2NpcGhlcigmcmlzY3Y2NF96dmtuZWRfenZiYl96dmtn X2Flc19za2NpcGhlcl9hbGcpOwogCWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShO VUxMLCBaVktCKSkKIAkJY3J5cHRvX3VucmVnaXN0ZXJfc2tjaXBoZXIoJnJpc2N2NjRfenZrbmVk X3p2a2JfYWVzX3NrY2lwaGVyX2FsZyk7CiAJY3J5cHRvX3VucmVnaXN0ZXJfc2tjaXBoZXJzKHJp c2N2NjRfenZrbmVkX2Flc19za2NpcGhlcl9hbGdzLAogCQkJCSAgICBBUlJBWV9TSVpFKHJpc2N2 NjRfenZrbmVkX2Flc19za2NpcGhlcl9hbGdzKSk7Ci0JY3J5cHRvX3VucmVnaXN0ZXJfYWxnKCZy aXNjdjY0X3p2a25lZF9hZXNfY2lwaGVyX2FsZyk7CiB9CiAKIG1vZHVsZV9pbml0KHJpc2N2NjRf YWVzX21vZF9pbml0KTsKIG1vZHVsZV9leGl0KHJpc2N2NjRfYWVzX21vZF9leGl0KTsKIApkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2NjQtenZrbmVkLlMgYi9hcmNoL3Jp c2N2L2NyeXB0by9hZXMtcmlzY3Y2NC16dmtuZWQuUwppbmRleCAyM2QwNjNmOTRjZTYuLmQwZmM0 NTgxYTM4MCAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2NjQtenZrbmVk LlMKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJpc2N2NjQtenZrbmVkLlMKQEAgLTU0LDM3 ICs1NCwxMCBAQAogI2RlZmluZSBJTlAJCWExCiAjZGVmaW5lIE9VVFAJCWEyCiAjZGVmaW5lIExF TgkJYTMKICNkZWZpbmUgSVZQCQlhNAogCi0ubWFjcm8JX19hZXNfY3J5cHRfenZrbmVkCWVuYywg a2V5bGVuCi0JdmxlMzIudgkJdjE2LCAoSU5QKQotCWFlc19jcnlwdAl2MTYsIFxlbmMsIFxrZXls ZW4KLQl2c2UzMi52CQl2MTYsIChPVVRQKQotCXJldAotLmVuZG0KLQotLm1hY3JvCWFlc19jcnlw dF96dmtuZWQJZW5jCi0JYWVzX2JlZ2luCUtFWVAsIDEyOGYsIDE5MmYKLQlfX2Flc19jcnlwdF96 dmtuZWQJXGVuYywgMjU2Ci0xMjg6Ci0JX19hZXNfY3J5cHRfenZrbmVkCVxlbmMsIDEyOAotMTky OgotCV9fYWVzX2NyeXB0X3p2a25lZAlcZW5jLCAxOTIKLS5lbmRtCi0KLS8vIHZvaWQgYWVzX2Vu Y3J5cHRfenZrbmVkKGNvbnN0IHN0cnVjdCBjcnlwdG9fYWVzX2N0eCAqa2V5LAotLy8JCQkgICBj b25zdCB1OCBpblsxNl0sIHU4IG91dFsxNl0pOwotU1lNX0ZVTkNfU1RBUlQoYWVzX2VuY3J5cHRf enZrbmVkKQotCWFlc19jcnlwdF96dmtuZWQJMQotU1lNX0ZVTkNfRU5EKGFlc19lbmNyeXB0X3p2 a25lZCkKLQotLy8gU2FtZSBwcm90b3R5cGUgYW5kIGNhbGxpbmcgY29udmVudGlvbiBhcyB0aGUg ZW5jcnlwdGlvbiBmdW5jdGlvbgotU1lNX0ZVTkNfU1RBUlQoYWVzX2RlY3J5cHRfenZrbmVkKQot CWFlc19jcnlwdF96dmtuZWQJMAotU1lNX0ZVTkNfRU5EKGFlc19kZWNyeXB0X3p2a25lZCkKLQog Lm1hY3JvCV9fYWVzX2VjYl9jcnlwdAllbmMsIGtleWxlbgogCXNybGkJCXQwLCBMRU4sIDIKIAkv LyB0MCBpcyB0aGUgcmVtYWluaW5nIGxlbmd0aCBpbiAzMi1iaXQgd29yZHMuICBJdCdzIGEgbXVs dGlwbGUgb2YgNC4KIDE6CiAJdnNldHZsaQkJdDEsIHQwLCBlMzIsIG04LCB0YSwgbWEKZGlmZiAt LWdpdCBhL2xpYi9jcnlwdG8vS2NvbmZpZyBiL2xpYi9jcnlwdG8vS2NvbmZpZwppbmRleCBhMGYx YzEwNTgyN2UuLjI2OTBiNWZmYzVjYSAxMDA2NDQKLS0tIGEvbGliL2NyeXB0by9LY29uZmlnCisr KyBiL2xpYi9jcnlwdG8vS2NvbmZpZwpAQCAtMTUsMTAgKzE1LDEyIEBAIGNvbmZpZyBDUllQVE9f TElCX0FFU19BUkNICiAJYm9vbAogCWRlcGVuZHMgb24gQ1JZUFRPX0xJQl9BRVMgJiYgIVVNTCAm JiAhS01TQU4KIAlkZWZhdWx0IHkgaWYgQVJNCiAJZGVmYXVsdCB5IGlmIEFSTTY0CiAJZGVmYXVs dCB5IGlmIFBQQyAmJiAoU1BFIHx8IChQUEM2NCAmJiBWU1gpKQorCWRlZmF1bHQgeSBpZiBSSVND ViAmJiA2NEJJVCAmJiBUT09MQ0hBSU5fSEFTX1ZFQ1RPUl9DUllQVE8gJiYgXAorCQkgICAgIFJJ U0NWX0VGRklDSUVOVF9WRUNUT1JfVU5BTElHTkVEX0FDQ0VTUwogCiBjb25maWcgQ1JZUFRPX0xJ Ql9BRVNDRkIKIAl0cmlzdGF0ZQogCXNlbGVjdCBDUllQVE9fTElCX0FFUwogCXNlbGVjdCBDUllQ VE9fTElCX1VUSUxTCmRpZmYgLS1naXQgYS9saWIvY3J5cHRvL01ha2VmaWxlIGIvbGliL2NyeXB0 by9NYWtlZmlsZQppbmRleCAxNjE0MDYxNmFjZTguLjgxMWI2MDc4N2RkNSAxMDA2NDQKLS0tIGEv bGliL2NyeXB0by9NYWtlZmlsZQorKysgYi9saWIvY3J5cHRvL01ha2VmaWxlCkBAIC00OCwxMCAr NDgsMTEgQEAgJChvYmopL3Bvd2VycGMvYWVzcDgtcHBjLlM6ICQoc3JjKS9wb3dlcnBjL2Flc3A4 LXBwYy5wbCBGT1JDRQogdGFyZ2V0cyArPSBwb3dlcnBjL2Flc3A4LXBwYy5TCiBPQkpFQ1RfRklM RVNfTk9OX1NUQU5EQVJEX3Bvd2VycGMvYWVzcDgtcHBjLm8gOj0geQogZW5kaWYgIyAhQ09ORklH X1NQRQogZW5kaWYgIyBDT05GSUdfUFBDCiAKK2xpYmFlcy0kKENPTkZJR19SSVNDVikgKz0gcmlz Y3YvYWVzLXJpc2N2NjQtenZrbmVkLm8KIGVuZGlmICMgQ09ORklHX0NSWVBUT19MSUJfQUVTX0FS Q0gKIAogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKIAogb2JqLSQoQ09ORklHX0NSWVBUT19MSUJf QUVTQ0ZCKQkJCSs9IGxpYmFlc2NmYi5vCmRpZmYgLS1naXQgYS9saWIvY3J5cHRvL3Jpc2N2L2Fl cy1yaXNjdjY0LXp2a25lZC5TIGIvbGliL2NyeXB0by9yaXNjdi9hZXMtcmlzY3Y2NC16dmtuZWQu UwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjBkOTg4YmMzZDM3Ygot LS0gL2Rldi9udWxsCisrKyBiL2xpYi9jcnlwdG8vcmlzY3YvYWVzLXJpc2N2NjQtenZrbmVkLlMK QEAgLTAsMCArMSw4NCBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjAg T1IgQlNELTItQ2xhdXNlICovCisvLworLy8gVGhpcyBmaWxlIGlzIGR1YWwtbGljZW5zZWQsIG1l YW5pbmcgdGhhdCB5b3UgY2FuIHVzZSBpdCB1bmRlciB5b3VyCisvLyBjaG9pY2Ugb2YgZWl0aGVy IG9mIHRoZSBmb2xsb3dpbmcgdHdvIGxpY2Vuc2VzOgorLy8KKy8vIENvcHlyaWdodCAyMDIzIFRo ZSBPcGVuU1NMIFByb2plY3QgQXV0aG9ycy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKy8vCisvLyBM aWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UgMi4wICh0aGUgIkxpY2Vuc2UiKS4gWW91 IGNhbiBvYnRhaW4KKy8vIGEgY29weSBpbiB0aGUgZmlsZSBMSUNFTlNFIGluIHRoZSBzb3VyY2Ug ZGlzdHJpYnV0aW9uIG9yIGF0CisvLyBodHRwczovL3d3dy5vcGVuc3NsLm9yZy9zb3VyY2UvbGlj ZW5zZS5odG1sCisvLworLy8gb3IKKy8vCisvLyBDb3B5cmlnaHQgKGMpIDIwMjMsIENocmlzdG9w aCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxsLmV1PgorLy8gQ29weXJpZ2h0IChj KSAyMDIzLCBQaG9lYmUgQ2hlbiA8cGhvZWJlLmNoZW5Ac2lmaXZlLmNvbT4KKy8vIENvcHlyaWdo dCAoYykgMjAyMywgSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgorLy8gQ29weXJp Z2h0IDIwMjQgR29vZ2xlIExMQworLy8gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKy8vCisvLyBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKy8vIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworLy8gYXJlIG1ldDoKKy8vIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisvLyAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisvLyAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorLy8gICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorLy8gICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKy8v CisvLyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisvLyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorLy8gTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisvLyBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorLy8gT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisvLyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisvLyBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKy8vIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorLy8gVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorLy8gKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisvLyBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorCisvLyBUaGUgZ2VuZXJhdGVkIGNvZGUgb2YgdGhpcyBmaWxlIGRlcGVuZHMgb24gdGhlIGZv bGxvd2luZyBSSVNDLVYgZXh0ZW5zaW9uczoKKy8vIC0gUlY2NEkKKy8vIC0gUklTQy1WIFZlY3Rv ciAoJ1YnKSB3aXRoIFZMRU4gPj0gMTI4CisvLyAtIFJJU0MtViBWZWN0b3IgQUVTIGJsb2NrIGNp cGhlciBleHRlbnNpb24gKCdadmtuZWQnKQorCisjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgor CisudGV4dAorLm9wdGlvbiBhcmNoLCArenZrbmVkCisKKyNpbmNsdWRlICIuLi8uLi9hcmNoL3Jp c2N2L2NyeXB0by9hZXMtbWFjcm9zLlMiCisKKyNkZWZpbmUgUk5ES0VZUwkJYTAKKyNkZWZpbmUg S0VZX0xFTgkJYTEKKyNkZWZpbmUgT1VUUAkJYTIKKyNkZWZpbmUgSU5QCQlhMworCisubWFjcm8J X19hZXNfY3J5cHRfenZrbmVkCWVuYywga2V5Yml0cworCXZsZTMyLnYJCXYxNiwgKElOUCkKKwlh ZXNfY3J5cHQJdjE2LCBcZW5jLCBca2V5Yml0cworCXZzZTMyLnYJCXYxNiwgKE9VVFApCisJcmV0 CisuZW5kbQorCisubWFjcm8JYWVzX2NyeXB0X3p2a25lZAllbmMKKwlhZXNfYmVnaW4JUk5ES0VZ UywgMTI4ZiwgMTkyZiwgS0VZX0xFTgorCV9fYWVzX2NyeXB0X3p2a25lZAlcZW5jLCAyNTYKKzEy ODoKKwlfX2Flc19jcnlwdF96dmtuZWQJXGVuYywgMTI4CisxOTI6CisJX19hZXNfY3J5cHRfenZr bmVkCVxlbmMsIDE5MgorLmVuZG0KKworLy8gdm9pZCBhZXNfZW5jcnlwdF96dmtuZWQoY29uc3Qg dTMyIHJuZGtleXNbXSwgaW50IGtleV9sZW4sCisvLwkJCSAgIHU4IG91dFtBRVNfQkxPQ0tfU0la RV0sIGNvbnN0IHU4IGluW0FFU19CTE9DS19TSVpFXSk7CitTWU1fRlVOQ19TVEFSVChhZXNfZW5j cnlwdF96dmtuZWQpCisJYWVzX2NyeXB0X3p2a25lZAkxCitTWU1fRlVOQ19FTkQoYWVzX2VuY3J5 cHRfenZrbmVkKQorCisvLyB2b2lkIGFlc19kZWNyeXB0X3p2a25lZChjb25zdCB1MzIgcm5ka2V5 c1tdLCBpbnQga2V5X2xlbiwKKy8vCQkJICAgdTggb3V0W0FFU19CTE9DS19TSVpFXSwgY29uc3Qg dTggaW5bQUVTX0JMT0NLX1NJWkVdKTsKK1NZTV9GVU5DX1NUQVJUKGFlc19kZWNyeXB0X3p2a25l ZCkKKwlhZXNfY3J5cHRfenZrbmVkCTAKK1NZTV9GVU5DX0VORChhZXNfZGVjcnlwdF96dmtuZWQp CmRpZmYgLS1naXQgYS9saWIvY3J5cHRvL3Jpc2N2L2Flcy5oIGIvbGliL2NyeXB0by9yaXNjdi9h ZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjBiMjZmNThmYWYy YgotLS0gL2Rldi9udWxsCisrKyBiL2xpYi9jcnlwdG8vcmlzY3YvYWVzLmgKQEAgLTAsMCArMSw2 MyBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seSAqLworLyoKKyAq IENvcHlyaWdodCAoQykgMjAyMyBWUlVMTCBHbWJICisgKiBDb3B5cmlnaHQgKEMpIDIwMjMgU2lG aXZlLCBJbmMuCisgKiBDb3B5cmlnaHQgMjAyNCBHb29nbGUgTExDCisgKi8KKworI2luY2x1ZGUg PGFzbS9zaW1kLmg+CisjaW5jbHVkZSA8YXNtL3ZlY3Rvci5oPgorCitzdGF0aWMgX19yb19hZnRl cl9pbml0IERFRklORV9TVEFUSUNfS0VZX0ZBTFNFKGhhdmVfenZrbmVkKTsKKwordm9pZCBhZXNf ZW5jcnlwdF96dmtuZWQoY29uc3QgdTMyIHJuZGtleXNbXSwgaW50IGtleV9sZW4sCisJCQl1OCBv dXRbQUVTX0JMT0NLX1NJWkVdLCBjb25zdCB1OCBpbltBRVNfQkxPQ0tfU0laRV0pOwordm9pZCBh ZXNfZGVjcnlwdF96dmtuZWQoY29uc3QgdTMyIHJuZGtleXNbXSwgaW50IGtleV9sZW4sCisJCQl1 OCBvdXRbQUVTX0JMT0NLX1NJWkVdLCBjb25zdCB1OCBpbltBRVNfQkxPQ0tfU0laRV0pOworCitz dGF0aWMgdm9pZCBhZXNfcHJlcGFyZWtleV9hcmNoKHVuaW9uIGFlc19lbmNrZXlfYXJjaCAqaywK KwkJCQl1bmlvbiBhZXNfaW52a2V5X2FyY2ggKmludl9rLAorCQkJCWNvbnN0IHU4ICppbl9rZXks IGludCBrZXlfbGVuLCBpbnQgbnJvdW5kcykKK3sKKwlhZXNfZXhwYW5ka2V5X2dlbmVyaWMoay0+ cm5ka2V5cywgaW52X2sgPyBpbnZfay0+aW52X3JuZGtleXMgOiBOVUxMLAorCQkJICAgICAgaW5f a2V5LCBrZXlfbGVuKTsKK30KKworc3RhdGljIHZvaWQgYWVzX2VuY3J5cHRfYXJjaChjb25zdCBz dHJ1Y3QgYWVzX2VuY2tleSAqa2V5LAorCQkJICAgICB1OCBvdXRbQUVTX0JMT0NLX1NJWkVdLAor CQkJICAgICBjb25zdCB1OCBpbltBRVNfQkxPQ0tfU0laRV0pCit7CisJaWYgKHN0YXRpY19icmFu Y2hfbGlrZWx5KCZoYXZlX3p2a25lZCkgJiYgbGlrZWx5KG1heV91c2Vfc2ltZCgpKSkgeworCQlr ZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJCWFlc19lbmNyeXB0X3p2a25lZChrZXktPmsucm5ka2V5 cywga2V5LT5sZW4sIG91dCwgaW4pOworCQlrZXJuZWxfdmVjdG9yX2VuZCgpOworCX0gZWxzZSB7 CisJCWFlc19lbmNyeXB0X2dlbmVyaWMoa2V5LT5rLnJuZGtleXMsIGtleS0+bnJvdW5kcywgb3V0 LCBpbik7CisJfQorfQorCitzdGF0aWMgdm9pZCBhZXNfZGVjcnlwdF9hcmNoKGNvbnN0IHN0cnVj dCBhZXNfa2V5ICprZXksCisJCQkgICAgIHU4IG91dFtBRVNfQkxPQ0tfU0laRV0sCisJCQkgICAg IGNvbnN0IHU4IGluW0FFU19CTE9DS19TSVpFXSkKK3sKKwkvKgorCSAqIE5vdGUgdGhhdCB0aGUg WnZrbmVkIGNvZGUgdXNlcyB0aGUgc3RhbmRhcmQgcm91bmQga2V5cywgd2hpbGUgdGhlCisJICog ZmFsbGJhY2sgdXNlcyB0aGUgaW52ZXJzZSByb3VuZCBrZXlzLiAgVGh1cyBib3RoIG11c3QgYmUg cHJlc2VudC4KKwkgKi8KKwlpZiAoc3RhdGljX2JyYW5jaF9saWtlbHkoJmhhdmVfenZrbmVkKSAm JiBsaWtlbHkobWF5X3VzZV9zaW1kKCkpKSB7CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJ YWVzX2RlY3J5cHRfenZrbmVkKGtleS0+ay5ybmRrZXlzLCBrZXktPmxlbiwgb3V0LCBpbik7CisJ CWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJfSBlbHNlIHsKKwkJYWVzX2RlY3J5cHRfZ2VuZXJpYyhr ZXktPmludl9rLmludl9ybmRrZXlzLCBrZXktPm5yb3VuZHMsCisJCQkJICAgIG91dCwgaW4pOwor CX0KK30KKworI2RlZmluZSBhZXNfbW9kX2luaXRfYXJjaCBhZXNfbW9kX2luaXRfYXJjaAorc3Rh dGljIHZvaWQgYWVzX21vZF9pbml0X2FyY2godm9pZCkKK3sKKwlpZiAocmlzY3ZfaXNhX2V4dGVu c2lvbl9hdmFpbGFibGUoTlVMTCwgWlZLTkVEKSAmJgorCSAgICByaXNjdl92ZWN0b3Jfdmxlbigp ID49IDEyOCkKKwkJc3RhdGljX2JyYW5jaF9lbmFibGUoJmhhdmVfenZrbmVkKTsKK30KLS0gCjIu NTIuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp bnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK