From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 8AD9812E5E; Tue, 2 Jan 2024 06:50:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ucDSxbRB" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2D51BC433C8; Tue, 2 Jan 2024 06:50:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704178249; bh=6HrmutA4w4lJw9CHMXV+TxNZ0KU+8Hg+Z65BKTFYS74=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ucDSxbRBbTiz0AzoQHUy+H+gUWK/XnS3DCif5T/hE4u/TJ0MyXBc96G8Bz/XVDrwc 71xJWlSbob8LCNZeE1+wTrEWdSdG+e5WgLHZfK93MtPsdjoggZ+a0rEeTT09rNdcha 4WagtwTlo6hiMjGy0DJma4R2YBfIjSrq+uY7rEgu6NTWdcwVpttCUjPxZCmh+ER7JW lCz+XTVTkbwef1nxZWpP56AtvBrsVX4mdI1zMKxnNMZVSXhYkY8w4Do3H58kayTJUg J149VouGeItcpW0YT6V9F4ga1Mk4l9F/nd9NMWIUUabRlOcx99xL2Bgtd2ZzFAquOA mJJK+IVwlyMHg== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner Subject: [RFC PATCH 13/13] crypto: riscv - add vector crypto accelerated SM4 Date: Tue, 2 Jan 2024 00:47:39 -0600 Message-ID: <20240102064743.220490-14-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240102064743.220490-1-ebiggers@kernel.org> References: <20240102064743.220490-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 From: Jerry Shih Add an implementation of SM4 using the Zvksed extension. The assembly code is derived from OpenSSL code (openssl/openssl#21923) that was dual-licensed so that it could be reused in the kernel. Nevertheless, the assembly has been significantly reworked for integration with the kernel, for example by using a regular .S file instead of the so-called perlasm, using the assembler instead of bare '.inst', and greatly reducing code duplication. Co-developed-by: Christoph Müllner Signed-off-by: Christoph Müllner Co-developed-by: Heiko Stuebner Signed-off-by: Heiko Stuebner Signed-off-by: Jerry Shih Co-developed-by: Eric Biggers Signed-off-by: Eric Biggers --- arch/riscv/crypto/Kconfig | 17 +++ arch/riscv/crypto/Makefile | 3 + arch/riscv/crypto/sm4-riscv64-glue.c | 109 ++++++++++++++++++ arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S | 117 ++++++++++++++++++++ 4 files changed, 246 insertions(+) create mode 100644 arch/riscv/crypto/sm4-riscv64-glue.c create mode 100644 arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index d44911853fa2d..9ba225d968289 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -81,11 +81,28 @@ config CRYPTO_SM3_RISCV64 depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO select CRYPTO_HASH select CRYPTO_SM3 help SM3 (ShangMi 3) secure hash function (OSCCA GM/T 0004-2012) Architecture: riscv64 using: - Zvksh vector crypto extension - Zvkb vector crypto extension +config CRYPTO_SM4_RISCV64 + tristate "Ciphers: SM4 (ShangMi 4)" + depends on 64BIT && RISCV_ISA_V && TOOLCHAIN_HAS_VECTOR_CRYPTO + select CRYPTO_ALGAPI + select CRYPTO_SM4 + help + SM4 block cipher algorithm (OSCCA GB/T 32907-2016, + ISO/IEC 18033-3:2010/Amd 1:2021) + + SM4 (GBT.32907-2016) is a cryptographic standard issued by the + Organization of State Commercial Administration of China (OSCCA) + as an authorized cryptographic algorithm for use within China. + + Architecture: riscv64 using: + - Zvksed vector crypto extension + - Zvkb vector crypto extension + endmenu diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index 4b5efabd1162a..70d60060d9b26 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -16,10 +16,13 @@ obj-$(CONFIG_CRYPTO_GHASH_RISCV64) += ghash-riscv64.o ghash-riscv64-y := ghash-riscv64-glue.o ghash-riscv64-zvkg.o obj-$(CONFIG_CRYPTO_SHA256_RISCV64) += sha256-riscv64.o sha256-riscv64-y := sha256-riscv64-glue.o sha256-riscv64-zvknha_or_zvknhb-zvkb.o obj-$(CONFIG_CRYPTO_SHA512_RISCV64) += sha512-riscv64.o sha512-riscv64-y := sha512-riscv64-glue.o sha512-riscv64-zvknhb-zvkb.o obj-$(CONFIG_CRYPTO_SM3_RISCV64) += sm3-riscv64.o sm3-riscv64-y := sm3-riscv64-glue.o sm3-riscv64-zvksh-zvkb.o + +obj-$(CONFIG_CRYPTO_SM4_RISCV64) += sm4-riscv64.o +sm4-riscv64-y := sm4-riscv64-glue.o sm4-riscv64-zvksed-zvkb.o diff --git a/arch/riscv/crypto/sm4-riscv64-glue.c b/arch/riscv/crypto/sm4-riscv64-glue.c new file mode 100644 index 0000000000000..b8993f1411f45 --- /dev/null +++ b/arch/riscv/crypto/sm4-riscv64-glue.c @@ -0,0 +1,109 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * SM4 using the RISC-V vector crypto extensions + * + * Copyright (C) 2023 VRULL GmbH + * Author: Heiko Stuebner + * + * Copyright (C) 2023 SiFive, Inc. + * Author: Jerry Shih + */ + +#include +#include +#include +#include +#include +#include +#include + +asmlinkage void sm4_expandkey_zvksed_zvkb(const u8 user_key[SM4_KEY_SIZE], + u32 rkey_enc[SM4_RKEY_WORDS], + u32 rkey_dec[SM4_RKEY_WORDS]); +asmlinkage void sm4_crypt_zvksed_zvkb(const u32 rkey[SM4_RKEY_WORDS], + const u8 in[SM4_BLOCK_SIZE], + u8 out[SM4_BLOCK_SIZE]); + +static int riscv64_sm4_setkey(struct crypto_tfm *tfm, const u8 *key, + unsigned int key_len) +{ + struct sm4_ctx *ctx = crypto_tfm_ctx(tfm); + + if (key_len != SM4_KEY_SIZE) + return -EINVAL; + + if (crypto_simd_usable()) { + kernel_vector_begin(); + sm4_expandkey_zvksed_zvkb(key, ctx->rkey_enc, ctx->rkey_dec); + kernel_vector_end(); + } else { + sm4_expandkey(ctx, key, key_len); + } + return 0; +} + +static void riscv64_sm4_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) +{ + const struct sm4_ctx *ctx = crypto_tfm_ctx(tfm); + + if (crypto_simd_usable()) { + kernel_vector_begin(); + sm4_crypt_zvksed_zvkb(ctx->rkey_enc, src, dst); + kernel_vector_end(); + } else { + sm4_crypt_block(ctx->rkey_enc, dst, src); + } +} + +static void riscv64_sm4_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) +{ + const struct sm4_ctx *ctx = crypto_tfm_ctx(tfm); + + if (crypto_simd_usable()) { + kernel_vector_begin(); + sm4_crypt_zvksed_zvkb(ctx->rkey_dec, src, dst); + kernel_vector_end(); + } else { + sm4_crypt_block(ctx->rkey_dec, dst, src); + } +} + +static struct crypto_alg riscv64_sm4_alg = { + .cra_flags = CRYPTO_ALG_TYPE_CIPHER, + .cra_blocksize = SM4_BLOCK_SIZE, + .cra_ctxsize = sizeof(struct sm4_ctx), + .cra_priority = 300, + .cra_name = "sm4", + .cra_driver_name = "sm4-riscv64-zvksed-zvkb", + .cra_cipher = { + .cia_min_keysize = SM4_KEY_SIZE, + .cia_max_keysize = SM4_KEY_SIZE, + .cia_setkey = riscv64_sm4_setkey, + .cia_encrypt = riscv64_sm4_encrypt, + .cia_decrypt = riscv64_sm4_decrypt, + }, + .cra_module = THIS_MODULE, +}; + +static int __init riscv64_sm4_mod_init(void) +{ + if (riscv_isa_extension_available(NULL, ZVKSED) && + riscv_isa_extension_available(NULL, ZVKB) && + riscv_vector_vlen() >= 128) + return crypto_register_alg(&riscv64_sm4_alg); + + return -ENODEV; +} + +static void __exit riscv64_sm4_mod_fini(void) +{ + crypto_unregister_alg(&riscv64_sm4_alg); +} + +module_init(riscv64_sm4_mod_init); +module_exit(riscv64_sm4_mod_fini); + +MODULE_DESCRIPTION("SM4 (RISC-V accelerated)"); +MODULE_AUTHOR("Heiko Stuebner "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CRYPTO("sm4"); diff --git a/arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S b/arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S new file mode 100644 index 0000000000000..143e60ddf3fe4 --- /dev/null +++ b/arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S @@ -0,0 +1,117 @@ +/* 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, 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 SM4 Block Cipher extension ('Zvksed') +// - RISC-V Vector Cryptography Bit-manipulation extension ('Zvkb') + +#include + +.text +.option arch, +zvksed, +zvkb + +// void sm4_expandkey_zksed_zvkb(const u8 user_key[16], u32 rkey_enc[32], +// u32 rkey_dec[32]); +SYM_FUNC_START(sm4_expandkey_zvksed_zvkb) + vsetivli zero, 4, e32, m1, ta, ma + + // Load the user key. + vle32.v v1, (a0) + vrev8.v v1, v1 + + // XOR the user key with the family key. + la t0, FAMILY_KEY + vle32.v v2, (t0) + vxor.vv v1, v1, v2 + + // Compute the round keys. Store them in forwards order in rkey_enc + // and in reverse order in rkey_dec. + addi a2, a2, 31*4 + li t0, -4 + .set i, 0 +.rept 8 + vsm4k.vi v1, v1, i + vse32.v v1, (a1) // Store to rkey_enc. + vsse32.v v1, (a2), t0 // Store to rkey_dec. +.if i < 7 + addi a1, a1, 16 + addi a2, a2, -16 +.endif + .set i, i + 1 +.endr + + ret +SYM_FUNC_END(sm4_expandkey_zvksed_zvkb) + +// void sm4_crypt_zvksed_zvkb(const u32 rkey[32], const u8 in[16], u8 out[16]); +SYM_FUNC_START(sm4_crypt_zvksed_zvkb) + vsetivli zero, 4, e32, m1, ta, ma + + // Load the input data. + vle32.v v1, (a1) + vrev8.v v1, v1 + + // Do the 32 rounds of SM4, 4 at a time. + .set i, 0 +.rept 8 + vle32.v v2, (a0) + vsm4r.vs v1, v2 +.if i < 7 + addi a0, a0, 16 +.endif + .set i, i + 1 +.endr + + // Store the output data (in reverse element order). + vrev8.v v1, v1 + li t0, -4 + addi a2, a2, 12 + vsse32.v v1, (a2), t0 + + ret +SYM_FUNC_END(sm4_crypt_zvksed_zvkb) + +.section ".rodata" +.p2align 2 +.type FAMILY_KEY, @object +FAMILY_KEY: + .word 0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC +.size FAMILY_KEY, .-FAMILY_KEY -- 2.43.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 6BCE9C47077 for ; Tue, 2 Jan 2024 06:51:01 +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=k1h9gJNINmOX7V0tGyUAMYKUTFiQnl8FG9R6gTDi6TQ=; b=FyWwsEw14uxI1j UdTcWKbRMrFVIZJQd6X3pDU225ZFULEWvINNV8qp98ept8DWR1jwr0zclJoPK88zo5wTPzpLlHpbK gbpYYquMSmgGBeDoz/lCHKAkoALfIE26DebWvpSwNePPUhJfRUjdPaSZPP50wPY1NcOOkXj0MzwbZ kAEQPOGm3uo1cCPwUab/ZTaPVHI7ymfApgHX5mAL8fxMvGLh6JyjVXWmawNYd5vzZbT49v9UPlHS3 HLuRIHpqxaftW0RGRfMc72Z0WnUpImW61vaech8oWiiveQaNCPUiy89XozWAjLp1kPkT07wzEC6pn +JDW1i7498acA7CtP1wQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rKYc2-007Ccg-0U; Tue, 02 Jan 2024 06:50:54 +0000 Received: from dfw.source.kernel.org ([139.178.84.217]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rKYby-007CXs-16 for linux-riscv@lists.infradead.org; Tue, 02 Jan 2024 06:50:52 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id C34B760FB5; Tue, 2 Jan 2024 06:50:49 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2D51BC433C8; Tue, 2 Jan 2024 06:50:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704178249; bh=6HrmutA4w4lJw9CHMXV+TxNZ0KU+8Hg+Z65BKTFYS74=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=ucDSxbRBbTiz0AzoQHUy+H+gUWK/XnS3DCif5T/hE4u/TJ0MyXBc96G8Bz/XVDrwc 71xJWlSbob8LCNZeE1+wTrEWdSdG+e5WgLHZfK93MtPsdjoggZ+a0rEeTT09rNdcha 4WagtwTlo6hiMjGy0DJma4R2YBfIjSrq+uY7rEgu6NTWdcwVpttCUjPxZCmh+ER7JW lCz+XTVTkbwef1nxZWpP56AtvBrsVX4mdI1zMKxnNMZVSXhYkY8w4Do3H58kayTJUg J149VouGeItcpW0YT6V9F4ga1Mk4l9F/nd9NMWIUUabRlOcx99xL2Bgtd2ZzFAquOA mJJK+IVwlyMHg== From: Eric Biggers To: linux-crypto@vger.kernel.org, linux-riscv@lists.infradead.org, Jerry Shih Cc: linux-kernel@vger.kernel.org, Ard Biesheuvel , Heiko Stuebner , Phoebe Chen , hongrong.hsu@sifive.com, Paul Walmsley , Palmer Dabbelt , Albert Ou , Andy Chiu , =?UTF-8?q?Christoph=20M=C3=BCllner?= , Heiko Stuebner Subject: [RFC PATCH 13/13] crypto: riscv - add vector crypto accelerated SM4 Date: Tue, 2 Jan 2024 00:47:39 -0600 Message-ID: <20240102064743.220490-14-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240102064743.220490-1-ebiggers@kernel.org> References: <20240102064743.220490-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240101_225050_529617_88B0FCA9 X-CRM114-Status: GOOD ( 27.29 ) 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 RnJvbTogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgoKQWRkIGFuIGltcGxlbWVu dGF0aW9uIG9mIFNNNCB1c2luZyB0aGUgWnZrc2VkIGV4dGVuc2lvbi4gIFRoZSBhc3NlbWJseQpj b2RlIGlzIGRlcml2ZWQgZnJvbSBPcGVuU1NMIGNvZGUgKG9wZW5zc2wvb3BlbnNzbCMyMTkyMykg dGhhdCB3YXMKZHVhbC1saWNlbnNlZCBzbyB0aGF0IGl0IGNvdWxkIGJlIHJldXNlZCBpbiB0aGUg a2VybmVsLiAgTmV2ZXJ0aGVsZXNzLAp0aGUgYXNzZW1ibHkgaGFzIGJlZW4gc2lnbmlmaWNhbnRs eSByZXdvcmtlZCBmb3IgaW50ZWdyYXRpb24gd2l0aCB0aGUKa2VybmVsLCBmb3IgZXhhbXBsZSBi eSB1c2luZyBhIHJlZ3VsYXIgLlMgZmlsZSBpbnN0ZWFkIG9mIHRoZSBzby1jYWxsZWQKcGVybGFz bSwgdXNpbmcgdGhlIGFzc2VtYmxlciBpbnN0ZWFkIG9mIGJhcmUgJy5pbnN0JywgYW5kIGdyZWF0 bHkKcmVkdWNpbmcgY29kZSBkdXBsaWNhdGlvbi4KCkNvLWRldmVsb3BlZC1ieTogQ2hyaXN0b3Bo IE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwuZXU+ClNpZ25lZC1vZmYtYnk6IENo cmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxsLmV1PgpDby1kZXZlbG9w ZWQtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2cnVsbC5ldT4KU2lnbmVkLW9m Zi1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgpTaWduZWQtb2Zm LWJ5OiBKZXJyeSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+CkNvLWRldmVsb3BlZC1ieTog RXJpYyBCaWdnZXJzIDxlYmlnZ2Vyc0Bnb29nbGUuY29tPgpTaWduZWQtb2ZmLWJ5OiBFcmljIEJp Z2dlcnMgPGViaWdnZXJzQGdvb2dsZS5jb20+Ci0tLQogYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZp ZyAgICAgICAgICAgICAgICAgICB8ICAxNyArKysKIGFyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxl ICAgICAgICAgICAgICAgICAgfCAgIDMgKwogYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQt Z2x1ZS5jICAgICAgICB8IDEwOSArKysrKysrKysrKysrKysrKysKIGFyY2gvcmlzY3YvY3J5cHRv L3NtNC1yaXNjdjY0LXp2a3NlZC16dmtiLlMgfCAxMTcgKysrKysrKysrKysrKysrKysrKysKIDQg ZmlsZXMgY2hhbmdlZCwgMjQ2IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNo L3Jpc2N2L2NyeXB0by9zbTQtcmlzY3Y2NC1nbHVlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNo L3Jpc2N2L2NyeXB0by9zbTQtcmlzY3Y2NC16dmtzZWQtenZrYi5TCgpkaWZmIC0tZ2l0IGEvYXJj aC9yaXNjdi9jcnlwdG8vS2NvbmZpZyBiL2FyY2gvcmlzY3YvY3J5cHRvL0tjb25maWcKaW5kZXgg ZDQ0OTExODUzZmEyZC4uOWJhMjI1ZDk2ODI4OSAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlw dG8vS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnCkBAIC04MSwxMSArODEs MjggQEAgY29uZmlnIENSWVBUT19TTTNfUklTQ1Y2NAogCWRlcGVuZHMgb24gNjRCSVQgJiYgUklT Q1ZfSVNBX1YgJiYgVE9PTENIQUlOX0hBU19WRUNUT1JfQ1JZUFRPCiAJc2VsZWN0IENSWVBUT19I QVNICiAJc2VsZWN0IENSWVBUT19TTTMKIAloZWxwCiAJICBTTTMgKFNoYW5nTWkgMykgc2VjdXJl IGhhc2ggZnVuY3Rpb24gKE9TQ0NBIEdNL1QgMDAwNC0yMDEyKQogCiAJICBBcmNoaXRlY3R1cmU6 IHJpc2N2NjQgdXNpbmc6CiAJICAtIFp2a3NoIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9uCiAJICAt IFp2a2IgdmVjdG9yIGNyeXB0byBleHRlbnNpb24KIAorY29uZmlnIENSWVBUT19TTTRfUklTQ1Y2 NAorCXRyaXN0YXRlICJDaXBoZXJzOiBTTTQgKFNoYW5nTWkgNCkiCisJZGVwZW5kcyBvbiA2NEJJ VCAmJiBSSVNDVl9JU0FfViAmJiBUT09MQ0hBSU5fSEFTX1ZFQ1RPUl9DUllQVE8KKwlzZWxlY3Qg Q1JZUFRPX0FMR0FQSQorCXNlbGVjdCBDUllQVE9fU000CisJaGVscAorCSAgU000IGJsb2NrIGNp cGhlciBhbGdvcml0aG0gKE9TQ0NBIEdCL1QgMzI5MDctMjAxNiwKKwkgIElTTy9JRUMgMTgwMzMt MzoyMDEwL0FtZCAxOjIwMjEpCisKKwkgIFNNNCAoR0JULjMyOTA3LTIwMTYpIGlzIGEgY3J5cHRv Z3JhcGhpYyBzdGFuZGFyZCBpc3N1ZWQgYnkgdGhlCisJICBPcmdhbml6YXRpb24gb2YgU3RhdGUg Q29tbWVyY2lhbCBBZG1pbmlzdHJhdGlvbiBvZiBDaGluYSAoT1NDQ0EpCisJICBhcyBhbiBhdXRo b3JpemVkIGNyeXB0b2dyYXBoaWMgYWxnb3JpdGhtIGZvciB1c2Ugd2l0aGluIENoaW5hLgorCisJ ICBBcmNoaXRlY3R1cmU6IHJpc2N2NjQgdXNpbmc6CisJICAtIFp2a3NlZCB2ZWN0b3IgY3J5cHRv IGV4dGVuc2lvbgorCSAgLSBadmtiIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9uCisKIGVuZG1lbnUK ZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlIGIvYXJjaC9yaXNjdi9jcnlw dG8vTWFrZWZpbGUKaW5kZXggNGI1ZWZhYmQxMTYyYS4uNzBkNjAwNjBkOWIyNiAxMDA2NDQKLS0t IGEvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vTWFr ZWZpbGUKQEAgLTE2LDEwICsxNiwxMyBAQCBvYmotJChDT05GSUdfQ1JZUFRPX0dIQVNIX1JJU0NW NjQpICs9IGdoYXNoLXJpc2N2NjQubwogZ2hhc2gtcmlzY3Y2NC15IDo9IGdoYXNoLXJpc2N2NjQt Z2x1ZS5vIGdoYXNoLXJpc2N2NjQtenZrZy5vCiAKIG9iai0kKENPTkZJR19DUllQVE9fU0hBMjU2 X1JJU0NWNjQpICs9IHNoYTI1Ni1yaXNjdjY0Lm8KIHNoYTI1Ni1yaXNjdjY0LXkgOj0gc2hhMjU2 LXJpc2N2NjQtZ2x1ZS5vIHNoYTI1Ni1yaXNjdjY0LXp2a25oYV9vcl96dmtuaGItenZrYi5vCiAK IG9iai0kKENPTkZJR19DUllQVE9fU0hBNTEyX1JJU0NWNjQpICs9IHNoYTUxMi1yaXNjdjY0Lm8K IHNoYTUxMi1yaXNjdjY0LXkgOj0gc2hhNTEyLXJpc2N2NjQtZ2x1ZS5vIHNoYTUxMi1yaXNjdjY0 LXp2a25oYi16dmtiLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19TTTNfUklTQ1Y2NCkgKz0gc20z LXJpc2N2NjQubwogc20zLXJpc2N2NjQteSA6PSBzbTMtcmlzY3Y2NC1nbHVlLm8gc20zLXJpc2N2 NjQtenZrc2gtenZrYi5vCisKK29iai0kKENPTkZJR19DUllQVE9fU000X1JJU0NWNjQpICs9IHNt NC1yaXNjdjY0Lm8KK3NtNC1yaXNjdjY0LXkgOj0gc200LXJpc2N2NjQtZ2x1ZS5vIHNtNC1yaXNj djY0LXp2a3NlZC16dmtiLm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNj djY0LWdsdWUuYyBiL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNjdjY0LWdsdWUuYwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwLi5iODk5M2YxNDExZjQ1Ci0tLSAvZGV2 L251bGwKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtZ2x1ZS5jCkBAIC0wLDAg KzEsMTA5IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisvKgor ICogU000IHVzaW5nIHRoZSBSSVNDLVYgdmVjdG9yIGNyeXB0byBleHRlbnNpb25zCisgKgorICog Q29weXJpZ2h0IChDKSAyMDIzIFZSVUxMIEdtYkgKKyAqIEF1dGhvcjogSGVpa28gU3R1ZWJuZXIg PGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBTaUZp dmUsIEluYy4KKyAqIEF1dGhvcjogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgor ICovCisKKyNpbmNsdWRlIDxhc20vc2ltZC5oPgorI2luY2x1ZGUgPGFzbS92ZWN0b3IuaD4KKyNp bmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvY2lwaGVyLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVy bmFsL3NpbWQuaD4KKyNpbmNsdWRlIDxjcnlwdG8vc200Lmg+CisjaW5jbHVkZSA8bGludXgvbGlu a2FnZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorCithc21saW5rYWdlIHZvaWQgc200 X2V4cGFuZGtleV96dmtzZWRfenZrYihjb25zdCB1OCB1c2VyX2tleVtTTTRfS0VZX1NJWkVdLAor CQkJCQkgIHUzMiBya2V5X2VuY1tTTTRfUktFWV9XT1JEU10sCisJCQkJCSAgdTMyIHJrZXlfZGVj W1NNNF9SS0VZX1dPUkRTXSk7Cithc21saW5rYWdlIHZvaWQgc200X2NyeXB0X3p2a3NlZF96dmti KGNvbnN0IHUzMiBya2V5W1NNNF9SS0VZX1dPUkRTXSwKKwkJCQkgICAgICBjb25zdCB1OCBpbltT TTRfQkxPQ0tfU0laRV0sCisJCQkJICAgICAgdTggb3V0W1NNNF9CTE9DS19TSVpFXSk7CisKK3N0 YXRpYyBpbnQgcmlzY3Y2NF9zbTRfc2V0a2V5KHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0sIGNvbnN0 IHU4ICprZXksCisJCQkgICAgICB1bnNpZ25lZCBpbnQga2V5X2xlbikKK3sKKwlzdHJ1Y3Qgc200 X2N0eCAqY3R4ID0gY3J5cHRvX3RmbV9jdHgodGZtKTsKKworCWlmIChrZXlfbGVuICE9IFNNNF9L RVlfU0laRSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkp IHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOworCQlzbTRfZXhwYW5ka2V5X3p2a3NlZF96dmti KGtleSwgY3R4LT5ya2V5X2VuYywgY3R4LT5ya2V5X2RlYyk7CisJCWtlcm5lbF92ZWN0b3JfZW5k KCk7CisJfSBlbHNlIHsKKwkJc200X2V4cGFuZGtleShjdHgsIGtleSwga2V5X2xlbik7CisJfQor CXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCByaXNjdjY0X3NtNF9lbmNyeXB0KHN0cnVjdCBj cnlwdG9fdGZtICp0Zm0sIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMpCit7CisJY29uc3Qgc3RydWN0 IHNtNF9jdHggKmN0eCA9IGNyeXB0b190Zm1fY3R4KHRmbSk7CisKKwlpZiAoY3J5cHRvX3NpbWRf dXNhYmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOworCQlzbTRfY3J5cHRfenZrc2Vk X3p2a2IoY3R4LT5ya2V5X2VuYywgc3JjLCBkc3QpOworCQlrZXJuZWxfdmVjdG9yX2VuZCgpOwor CX0gZWxzZSB7CisJCXNtNF9jcnlwdF9ibG9jayhjdHgtPnJrZXlfZW5jLCBkc3QsIHNyYyk7CisJ fQorfQorCitzdGF0aWMgdm9pZCByaXNjdjY0X3NtNF9kZWNyeXB0KHN0cnVjdCBjcnlwdG9fdGZt ICp0Zm0sIHU4ICpkc3QsIGNvbnN0IHU4ICpzcmMpCit7CisJY29uc3Qgc3RydWN0IHNtNF9jdHgg KmN0eCA9IGNyeXB0b190Zm1fY3R4KHRmbSk7CisKKwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkp IHsKKwkJa2VybmVsX3ZlY3Rvcl9iZWdpbigpOworCQlzbTRfY3J5cHRfenZrc2VkX3p2a2IoY3R4 LT5ya2V5X2RlYywgc3JjLCBkc3QpOworCQlrZXJuZWxfdmVjdG9yX2VuZCgpOworCX0gZWxzZSB7 CisJCXNtNF9jcnlwdF9ibG9jayhjdHgtPnJrZXlfZGVjLCBkc3QsIHNyYyk7CisJfQorfQorCitz dGF0aWMgc3RydWN0IGNyeXB0b19hbGcgcmlzY3Y2NF9zbTRfYWxnID0geworCS5jcmFfZmxhZ3Mg PSBDUllQVE9fQUxHX1RZUEVfQ0lQSEVSLAorCS5jcmFfYmxvY2tzaXplID0gU000X0JMT0NLX1NJ WkUsCisJLmNyYV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBzbTRfY3R4KSwKKwkuY3JhX3ByaW9y aXR5ID0gMzAwLAorCS5jcmFfbmFtZSA9ICJzbTQiLAorCS5jcmFfZHJpdmVyX25hbWUgPSAic200 LXJpc2N2NjQtenZrc2VkLXp2a2IiLAorCS5jcmFfY2lwaGVyID0geworCQkuY2lhX21pbl9rZXlz aXplID0gU000X0tFWV9TSVpFLAorCQkuY2lhX21heF9rZXlzaXplID0gU000X0tFWV9TSVpFLAor CQkuY2lhX3NldGtleSA9IHJpc2N2NjRfc200X3NldGtleSwKKwkJLmNpYV9lbmNyeXB0ID0gcmlz Y3Y2NF9zbTRfZW5jcnlwdCwKKwkJLmNpYV9kZWNyeXB0ID0gcmlzY3Y2NF9zbTRfZGVjcnlwdCwK Kwl9LAorCS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUsCit9OworCitzdGF0aWMgaW50IF9faW5p dCByaXNjdjY0X3NtNF9tb2RfaW5pdCh2b2lkKQoreworCWlmIChyaXNjdl9pc2FfZXh0ZW5zaW9u X2F2YWlsYWJsZShOVUxMLCBaVktTRUQpICYmCisJICAgIHJpc2N2X2lzYV9leHRlbnNpb25fYXZh aWxhYmxlKE5VTEwsIFpWS0IpICYmCisJICAgIHJpc2N2X3ZlY3Rvcl92bGVuKCkgPj0gMTI4KQor CQlyZXR1cm4gY3J5cHRvX3JlZ2lzdGVyX2FsZygmcmlzY3Y2NF9zbTRfYWxnKTsKKworCXJldHVy biAtRU5PREVWOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgcmlzY3Y2NF9zbTRfbW9kX2Zpbmko dm9pZCkKK3sKKwljcnlwdG9fdW5yZWdpc3Rlcl9hbGcoJnJpc2N2NjRfc200X2FsZyk7Cit9CisK K21vZHVsZV9pbml0KHJpc2N2NjRfc200X21vZF9pbml0KTsKK21vZHVsZV9leGl0KHJpc2N2NjRf c200X21vZF9maW5pKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJTTTQgKFJJU0MtViBhY2NlbGVy YXRlZCkiKTsKK01PRFVMRV9BVVRIT1IoIkhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2 cnVsbC5ldT4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BTElBU19DUllQVE8o InNtNCIpOwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2Vk LXp2a2IuUyBiL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNjdjY0LXp2a3NlZC16dmtiLlMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMC4uMTQzZTYwZGRmM2ZlNAotLS0g L2Rldi9udWxsCisrKyBiL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNjdjY0LXp2a3NlZC16dmti LlMKQEAgLTAsMCArMSwxMTcgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUt Mi4wIE9SIEJTRC0yLUNsYXVzZSAqLworLy8KKy8vIFRoaXMgZmlsZSBpcyBkdWFsLWxpY2Vuc2Vk LCBtZWFuaW5nIHRoYXQgeW91IGNhbiB1c2UgaXQgdW5kZXIgeW91cgorLy8gY2hvaWNlIG9mIGVp dGhlciBvZiB0aGUgZm9sbG93aW5nIHR3byBsaWNlbnNlczoKKy8vCisvLyBDb3B5cmlnaHQgMjAy MyBUaGUgT3BlblNTTCBQcm9qZWN0IEF1dGhvcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisvLwor Ly8gTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlIDIuMCAodGhlICJMaWNlbnNlIiku IFlvdSBjYW4gb2J0YWluCisvLyBhIGNvcHkgaW4gdGhlIGZpbGUgTElDRU5TRSBpbiB0aGUgc291 cmNlIGRpc3RyaWJ1dGlvbiBvciBhdAorLy8gaHR0cHM6Ly93d3cub3BlbnNzbC5vcmcvc291cmNl L2xpY2Vuc2UuaHRtbAorLy8KKy8vIG9yCisvLworLy8gQ29weXJpZ2h0IChjKSAyMDIzLCBDaHJp c3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KKy8vIENvcHlyaWdo 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 ciAoJ1YnKSB3aXRoIFZMRU4gPj0gMTI4CisvLyAtIFJJU0MtViBWZWN0b3IgU000IEJsb2NrIENp cGhlciBleHRlbnNpb24gKCdadmtzZWQnKQorLy8gLSBSSVNDLVYgVmVjdG9yIENyeXB0b2dyYXBo eSBCaXQtbWFuaXB1bGF0aW9uIGV4dGVuc2lvbiAoJ1p2a2InKQorCisjaW5jbHVkZSA8bGludXgv bGlua2FnZS5oPgorCisudGV4dAorLm9wdGlvbiBhcmNoLCArenZrc2VkLCArenZrYgorCisvLyB2 b2lkIHNtNF9leHBhbmRrZXlfemtzZWRfenZrYihjb25zdCB1OCB1c2VyX2tleVsxNl0sIHUzMiBy a2V5X2VuY1szMl0sCisvLwkJCQkgdTMyIHJrZXlfZGVjWzMyXSk7CitTWU1fRlVOQ19TVEFSVChz bTRfZXhwYW5ka2V5X3p2a3NlZF96dmtiKQorCXZzZXRpdmxpCXplcm8sIDQsIGUzMiwgbTEsIHRh LCBtYQorCisJLy8gTG9hZCB0aGUgdXNlciBrZXkuCisJdmxlMzIudgkJdjEsIChhMCkKKwl2cmV2 OC52CQl2MSwgdjEKKworCS8vIFhPUiB0aGUgdXNlciBrZXkgd2l0aCB0aGUgZmFtaWx5IGtleS4K KwlsYQkJdDAsIEZBTUlMWV9LRVkKKwl2bGUzMi52CQl2MiwgKHQwKQorCXZ4b3IudnYJCXYxLCB2 MSwgdjIKKworCS8vIENvbXB1dGUgdGhlIHJvdW5kIGtleXMuICBTdG9yZSB0aGVtIGluIGZvcndh cmRzIG9yZGVyIGluIHJrZXlfZW5jCisJLy8gYW5kIGluIHJldmVyc2Ugb3JkZXIgaW4gcmtleV9k ZWMuCisJYWRkaQkJYTIsIGEyLCAzMSo0CisJbGkJCXQwLCAtNAorCS5zZXQJCWksIDAKKy5yZXB0 IDgKKwl2c200ay52aQl2MSwgdjEsIGkKKwl2c2UzMi52CQl2MSwgKGExKQkvLyBTdG9yZSB0byBy a2V5X2VuYy4KKwl2c3NlMzIudgl2MSwgKGEyKSwgdDAJLy8gU3RvcmUgdG8gcmtleV9kZWMuCisu aWYgaSA8IDcKKwlhZGRpCQlhMSwgYTEsIDE2CisJYWRkaQkJYTIsIGEyLCAtMTYKKy5lbmRpZgor CS5zZXQJCWksIGkgKyAxCisuZW5kcgorCisJcmV0CitTWU1fRlVOQ19FTkQoc200X2V4cGFuZGtl eV96dmtzZWRfenZrYikKKworLy8gdm9pZCBzbTRfY3J5cHRfenZrc2VkX3p2a2IoY29uc3QgdTMy IHJrZXlbMzJdLCBjb25zdCB1OCBpblsxNl0sIHU4IG91dFsxNl0pOworU1lNX0ZVTkNfU1RBUlQo c200X2NyeXB0X3p2a3NlZF96dmtiKQorCXZzZXRpdmxpCXplcm8sIDQsIGUzMiwgbTEsIHRhLCBt YQorCisJLy8gTG9hZCB0aGUgaW5wdXQgZGF0YS4KKwl2bGUzMi52CQl2MSwgKGExKQorCXZyZXY4 LnYJCXYxLCB2MQorCisJLy8gRG8gdGhlIDMyIHJvdW5kcyBvZiBTTTQsIDQgYXQgYSB0aW1lLgor CS5zZXQJCWksIDAKKy5yZXB0IDgKKwl2bGUzMi52CQl2MiwgKGEwKQorCXZzbTRyLnZzCXYxLCB2 MgorLmlmIGkgPCA3CisJYWRkaQkJYTAsIGEwLCAxNgorLmVuZGlmCisJLnNldAkJaSwgaSArIDEK Ky5lbmRyCisKKwkvLyBTdG9yZSB0aGUgb3V0cHV0IGRhdGEgKGluIHJldmVyc2UgZWxlbWVudCBv cmRlcikuCisJdnJldjgudgkJdjEsIHYxCisJbGkJCXQwLCAtNAorCWFkZGkJCWEyLCBhMiwgMTIK Kwl2c3NlMzIudgl2MSwgKGEyKSwgdDAKKworCXJldAorU1lNX0ZVTkNfRU5EKHNtNF9jcnlwdF96 dmtzZWRfenZrYikKKworLnNlY3Rpb24gIi5yb2RhdGEiCisucDJhbGlnbiAyCisudHlwZSBGQU1J TFlfS0VZLCBAb2JqZWN0CitGQU1JTFlfS0VZOgorCS53b3JkIDB4QTNCMUJBQzYsIDB4NTZBQTMz NTAsIDB4Njc3RDkxOTcsIDB4QjI3MDIyREMKKy5zaXplIEZBTUlMWV9LRVksIC4tRkFNSUxZX0tF WQotLSAKMi40My4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVh ZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1y aXNjdgo=