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 994AF38DDE; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lkwT4I9Y" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 075CFC433C9; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704480694; bh=RbiLylQKIxRy+32CHHmxbyI0KMha2EwUuHCFleL8qb0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lkwT4I9YIv6VIDwMcBeb+tx5IUWOLKM0uwsIFscQDEPJN+34HMPeW9I9Lei0MIOE0 9Z1tKAccnvwvuPWD4pqRae1mrOkwpykEoz29Q7mDU4Lpm6oQVhOzz5ptuuGKZnafVc thv/9zo1N+AzamdwxA0hbRH4xGa2JU7otnNn9yVLIO5BIlc91Tle+GbJ3jf1njHKsR cCBUZPRlR0X4OwpCVDcEkqWc46I8/UDA10pLNM+XtGJBvICUnartRBPT1L5Mkk0dDy fATz+2kQuVCvewz6VadiaTzG767nM3bCJ9xRlAhUmJr7rvNL2M1ipP5lmDcs8b0hTi ttMbY0LkHEFgg== 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: [PATCH v2 12/12] crypto: riscv - add vector crypto accelerated SM4 Date: Fri, 5 Jan 2024 10:49:48 -0800 Message-ID: <20240105184950.43181-13-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240105184950.43181-1-ebiggers@kernel.org> References: <20240105184950.43181-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 | 107 ++++++++++++++++++ arch/riscv/crypto/sm4-riscv64-zvksed-zvkb.S | 117 ++++++++++++++++++++ 4 files changed, 244 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 179d09df8e0ca..2ad44e1d464af 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -66,11 +66,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 3b154f893e6e2..e74d64bfd6083 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -14,10 +14,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..47fb84ebe577d --- /dev/null +++ b/arch/riscv/crypto/sm4-riscv64-glue.c @@ -0,0 +1,107 @@ +// 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 keylen) +{ + struct sm4_ctx *ctx = crypto_tfm_ctx(tfm); + + if (crypto_simd_usable()) { + if (keylen != SM4_KEY_SIZE) + return -EINVAL; + kernel_vector_begin(); + sm4_expandkey_zvksed_zvkb(key, ctx->rkey_enc, ctx->rkey_dec); + kernel_vector_end(); + return 0; + } + return sm4_expandkey(ctx, key, keylen); +} + +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_exit(void) +{ + crypto_unregister_alg(&riscv64_sm4_alg); +} + +module_init(riscv64_sm4_mod_init); +module_exit(riscv64_sm4_mod_exit); + +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..fae62179a4a3d --- /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 855C6C47DAC for ; Fri, 5 Jan 2024 18:51:54 +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=t8LEaiylb1kcQkMxNay3h9kbnKjH4KEmwv/42ToPu3Y=; b=OcZDpXKrvWkCG6 q1kWTpnx6xzdWGqL6sMVsFOq8OGJWJPhE8mMARTDTHW/FsxTthGIBOxKpnGZH9aarENh3UcM/dvXI BAyOtu08i6u67cLIZk8P/GUwyOesiszc/Aph2A9OKeIko3UzHVj4xFUUtb62x02pO894bqXAOmXpJ /DmB2JgHdV8VjqLNa3V/tIJN3AM+shf8NemEQWcX3PaQnDgSrc0MD1A7DGRKSQwNH+o2DYR9kjlGN whH9D/bToCdNsmy0dpSIu7iV0shwITpFRpSazJCGjKinlQSPjEAagSJqatdiMkthvtQK0EumCauKl wgtBiWLgy0FkFn7RTycg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rLpIH-0001Qy-1t; Fri, 05 Jan 2024 18:51:45 +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 1rLpI8-0001Kj-2v for linux-riscv@lists.infradead.org; Fri, 05 Jan 2024 18:51:40 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by dfw.source.kernel.org (Postfix) with ESMTP id A51DA61BEF; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 075CFC433C9; Fri, 5 Jan 2024 18:51:34 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1704480694; bh=RbiLylQKIxRy+32CHHmxbyI0KMha2EwUuHCFleL8qb0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lkwT4I9YIv6VIDwMcBeb+tx5IUWOLKM0uwsIFscQDEPJN+34HMPeW9I9Lei0MIOE0 9Z1tKAccnvwvuPWD4pqRae1mrOkwpykEoz29Q7mDU4Lpm6oQVhOzz5ptuuGKZnafVc thv/9zo1N+AzamdwxA0hbRH4xGa2JU7otnNn9yVLIO5BIlc91Tle+GbJ3jf1njHKsR cCBUZPRlR0X4OwpCVDcEkqWc46I8/UDA10pLNM+XtGJBvICUnartRBPT1L5Mkk0dDy fATz+2kQuVCvewz6VadiaTzG767nM3bCJ9xRlAhUmJr7rvNL2M1ipP5lmDcs8b0hTi ttMbY0LkHEFgg== 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: [PATCH v2 12/12] crypto: riscv - add vector crypto accelerated SM4 Date: Fri, 5 Jan 2024 10:49:48 -0800 Message-ID: <20240105184950.43181-13-ebiggers@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240105184950.43181-1-ebiggers@kernel.org> References: <20240105184950.43181-1-ebiggers@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240105_105137_045333_5DE9D43B X-CRM114-Status: GOOD ( 27.21 ) 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 Z2x1ZS5jICAgICAgICB8IDEwNyArKysrKysrKysrKysrKysrKysKIGFyY2gvcmlzY3YvY3J5cHRv L3NtNC1yaXNjdjY0LXp2a3NlZC16dmtiLlMgfCAxMTcgKysrKysrKysrKysrKysrKysrKysKIDQg ZmlsZXMgY2hhbmdlZCwgMjQ0IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNo L3Jpc2N2L2NyeXB0by9zbTQtcmlzY3Y2NC1nbHVlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNo L3Jpc2N2L2NyeXB0by9zbTQtcmlzY3Y2NC16dmtzZWQtenZrYi5TCgpkaWZmIC0tZ2l0IGEvYXJj aC9yaXNjdi9jcnlwdG8vS2NvbmZpZyBiL2FyY2gvcmlzY3YvY3J5cHRvL0tjb25maWcKaW5kZXgg MTc5ZDA5ZGY4ZTBjYS4uMmFkNDRlMWQ0NjRhZiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlw dG8vS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9LY29uZmlnCkBAIC02NiwxMSArNjYs MjggQEAgY29uZmlnIENSWVBUT19TTTNfUklTQ1Y2NAogCWRlcGVuZHMgb24gNjRCSVQgJiYgUklT Q1ZfSVNBX1YgJiYgVE9PTENIQUlOX0hBU19WRUNUT1JfQ1JZUFRPCiAJc2VsZWN0IENSWVBUT19I QVNICiAJc2VsZWN0IENSWVBUT19TTTMKIAloZWxwCiAJICBTTTMgKFNoYW5nTWkgMykgc2VjdXJl IGhhc2ggZnVuY3Rpb24gKE9TQ0NBIEdNL1QgMDAwNC0yMDEyKQogCiAJICBBcmNoaXRlY3R1cmU6 IHJpc2N2NjQgdXNpbmc6CiAJICAtIFp2a3NoIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9uCiAJICAt IFp2a2IgdmVjdG9yIGNyeXB0byBleHRlbnNpb24KIAorY29uZmlnIENSWVBUT19TTTRfUklTQ1Y2 NAorCXRyaXN0YXRlICJDaXBoZXJzOiBTTTQgKFNoYW5nTWkgNCkiCisJZGVwZW5kcyBvbiA2NEJJ VCAmJiBSSVNDVl9JU0FfViAmJiBUT09MQ0hBSU5fSEFTX1ZFQ1RPUl9DUllQVE8KKwlzZWxlY3Qg Q1JZUFRPX0FMR0FQSQorCXNlbGVjdCBDUllQVE9fU000CisJaGVscAorCSAgU000IGJsb2NrIGNp cGhlciBhbGdvcml0aG0gKE9TQ0NBIEdCL1QgMzI5MDctMjAxNiwKKwkgIElTTy9JRUMgMTgwMzMt MzoyMDEwL0FtZCAxOjIwMjEpCisKKwkgIFNNNCAoR0JULjMyOTA3LTIwMTYpIGlzIGEgY3J5cHRv Z3JhcGhpYyBzdGFuZGFyZCBpc3N1ZWQgYnkgdGhlCisJICBPcmdhbml6YXRpb24gb2YgU3RhdGUg Q29tbWVyY2lhbCBBZG1pbmlzdHJhdGlvbiBvZiBDaGluYSAoT1NDQ0EpCisJICBhcyBhbiBhdXRo b3JpemVkIGNyeXB0b2dyYXBoaWMgYWxnb3JpdGhtIGZvciB1c2Ugd2l0aGluIENoaW5hLgorCisJ ICBBcmNoaXRlY3R1cmU6IHJpc2N2NjQgdXNpbmc6CisJICAtIFp2a3NlZCB2ZWN0b3IgY3J5cHRv IGV4dGVuc2lvbgorCSAgLSBadmtiIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9uCisKIGVuZG1lbnUK ZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL01ha2VmaWxlIGIvYXJjaC9yaXNjdi9jcnlw dG8vTWFrZWZpbGUKaW5kZXggM2IxNTRmODkzZTZlMi4uZTc0ZDY0YmZkNjA4MyAxMDA2NDQKLS0t IGEvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vTWFr ZWZpbGUKQEAgLTE0LDEwICsxNCwxMyBAQCBvYmotJChDT05GSUdfQ1JZUFRPX0dIQVNIX1JJU0NW NjQpICs9IGdoYXNoLXJpc2N2NjQubwogZ2hhc2gtcmlzY3Y2NC15IDo9IGdoYXNoLXJpc2N2NjQt Z2x1ZS5vIGdoYXNoLXJpc2N2NjQtenZrZy5vCiAKIG9iai0kKENPTkZJR19DUllQVE9fU0hBMjU2 X1JJU0NWNjQpICs9IHNoYTI1Ni1yaXNjdjY0Lm8KIHNoYTI1Ni1yaXNjdjY0LXkgOj0gc2hhMjU2 LXJpc2N2NjQtZ2x1ZS5vIHNoYTI1Ni1yaXNjdjY0LXp2a25oYV9vcl96dmtuaGItenZrYi5vCiAK IG9iai0kKENPTkZJR19DUllQVE9fU0hBNTEyX1JJU0NWNjQpICs9IHNoYTUxMi1yaXNjdjY0Lm8K IHNoYTUxMi1yaXNjdjY0LXkgOj0gc2hhNTEyLXJpc2N2NjQtZ2x1ZS5vIHNoYTUxMi1yaXNjdjY0 LXp2a25oYi16dmtiLm8KIAogb2JqLSQoQ09ORklHX0NSWVBUT19TTTNfUklTQ1Y2NCkgKz0gc20z LXJpc2N2NjQubwogc20zLXJpc2N2NjQteSA6PSBzbTMtcmlzY3Y2NC1nbHVlLm8gc20zLXJpc2N2 NjQtenZrc2gtenZrYi5vCisKK29iai0kKENPTkZJR19DUllQVE9fU000X1JJU0NWNjQpICs9IHNt NC1yaXNjdjY0Lm8KK3NtNC1yaXNjdjY0LXkgOj0gc200LXJpc2N2NjQtZ2x1ZS5vIHNtNC1yaXNj djY0LXp2a3NlZC16dmtiLm8KZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNj djY0LWdsdWUuYyBiL2FyY2gvcmlzY3YvY3J5cHRvL3NtNC1yaXNjdjY0LWdsdWUuYwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwLi40N2ZiODRlYmU1NzdkCi0tLSAvZGV2 L251bGwKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtZ2x1ZS5jCkBAIC0wLDAg KzEsMTA3IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisvKgor ICogU000IHVzaW5nIHRoZSBSSVNDLVYgdmVjdG9yIGNyeXB0byBleHRlbnNpb25zCisgKgorICog Q29weXJpZ2h0IChDKSAyMDIzIFZSVUxMIEdtYkgKKyAqIEF1dGhvcjogSGVpa28gU3R1ZWJuZXIg PGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBTaUZp dmUsIEluYy4KKyAqIEF1dGhvcjogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgor ICovCisKKyNpbmNsdWRlIDxhc20vc2ltZC5oPgorI2luY2x1ZGUgPGFzbS92ZWN0b3IuaD4KKyNp bmNsdWRlIDxjcnlwdG8vaW50ZXJuYWwvY2lwaGVyLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVy bmFsL3NpbWQuaD4KKyNpbmNsdWRlIDxjcnlwdG8vc200Lmg+CisjaW5jbHVkZSA8bGludXgvbGlu a2FnZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorCithc21saW5rYWdlIHZvaWQgc200 X2V4cGFuZGtleV96dmtzZWRfenZrYihjb25zdCB1OCB1c2VyX2tleVtTTTRfS0VZX1NJWkVdLAor CQkJCQkgIHUzMiBya2V5X2VuY1tTTTRfUktFWV9XT1JEU10sCisJCQkJCSAgdTMyIHJrZXlfZGVj W1NNNF9SS0VZX1dPUkRTXSk7Cithc21saW5rYWdlIHZvaWQgc200X2NyeXB0X3p2a3NlZF96dmti KGNvbnN0IHUzMiBya2V5W1NNNF9SS0VZX1dPUkRTXSwKKwkJCQkgICAgICBjb25zdCB1OCBpbltT TTRfQkxPQ0tfU0laRV0sCisJCQkJICAgICAgdTggb3V0W1NNNF9CTE9DS19TSVpFXSk7CisKK3N0 YXRpYyBpbnQgcmlzY3Y2NF9zbTRfc2V0a2V5KHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0sIGNvbnN0 IHU4ICprZXksCisJCQkgICAgICB1bnNpZ25lZCBpbnQga2V5bGVuKQoreworCXN0cnVjdCBzbTRf Y3R4ICpjdHggPSBjcnlwdG9fdGZtX2N0eCh0Zm0pOworCisJaWYgKGNyeXB0b19zaW1kX3VzYWJs ZSgpKSB7CisJCWlmIChrZXlsZW4gIT0gU000X0tFWV9TSVpFKQorCQkJcmV0dXJuIC1FSU5WQUw7 CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJc200X2V4cGFuZGtleV96dmtzZWRfenZrYihr ZXksIGN0eC0+cmtleV9lbmMsIGN0eC0+cmtleV9kZWMpOworCQlrZXJuZWxfdmVjdG9yX2VuZCgp OworCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIHNtNF9leHBhbmRrZXkoY3R4LCBrZXksIGtleWxl bik7Cit9CisKK3N0YXRpYyB2b2lkIHJpc2N2NjRfc200X2VuY3J5cHQoc3RydWN0IGNyeXB0b190 Zm0gKnRmbSwgdTggKmRzdCwgY29uc3QgdTggKnNyYykKK3sKKwljb25zdCBzdHJ1Y3Qgc200X2N0 eCAqY3R4ID0gY3J5cHRvX3RmbV9jdHgodGZtKTsKKworCWlmIChjcnlwdG9fc2ltZF91c2FibGUo KSkgeworCQlrZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJCXNtNF9jcnlwdF96dmtzZWRfenZrYihj dHgtPnJrZXlfZW5jLCBzcmMsIGRzdCk7CisJCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJfSBlbHNl IHsKKwkJc200X2NyeXB0X2Jsb2NrKGN0eC0+cmtleV9lbmMsIGRzdCwgc3JjKTsKKwl9Cit9CisK K3N0YXRpYyB2b2lkIHJpc2N2NjRfc200X2RlY3J5cHQoc3RydWN0IGNyeXB0b190Zm0gKnRmbSwg dTggKmRzdCwgY29uc3QgdTggKnNyYykKK3sKKwljb25zdCBzdHJ1Y3Qgc200X2N0eCAqY3R4ID0g Y3J5cHRvX3RmbV9jdHgodGZtKTsKKworCWlmIChjcnlwdG9fc2ltZF91c2FibGUoKSkgeworCQlr ZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJCXNtNF9jcnlwdF96dmtzZWRfenZrYihjdHgtPnJrZXlf ZGVjLCBzcmMsIGRzdCk7CisJCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJfSBlbHNlIHsKKwkJc200 X2NyeXB0X2Jsb2NrKGN0eC0+cmtleV9kZWMsIGRzdCwgc3JjKTsKKwl9Cit9CisKK3N0YXRpYyBz dHJ1Y3QgY3J5cHRvX2FsZyByaXNjdjY0X3NtNF9hbGcgPSB7CisJLmNyYV9mbGFncyA9IENSWVBU T19BTEdfVFlQRV9DSVBIRVIsCisJLmNyYV9ibG9ja3NpemUgPSBTTTRfQkxPQ0tfU0laRSwKKwku Y3JhX2N0eHNpemUgPSBzaXplb2Yoc3RydWN0IHNtNF9jdHgpLAorCS5jcmFfcHJpb3JpdHkgPSAz MDAsCisJLmNyYV9uYW1lID0gInNtNCIsCisJLmNyYV9kcml2ZXJfbmFtZSA9ICJzbTQtcmlzY3Y2 NC16dmtzZWQtenZrYiIsCisJLmNyYV9jaXBoZXIgPSB7CisJCS5jaWFfbWluX2tleXNpemUgPSBT TTRfS0VZX1NJWkUsCisJCS5jaWFfbWF4X2tleXNpemUgPSBTTTRfS0VZX1NJWkUsCisJCS5jaWFf c2V0a2V5ID0gcmlzY3Y2NF9zbTRfc2V0a2V5LAorCQkuY2lhX2VuY3J5cHQgPSByaXNjdjY0X3Nt NF9lbmNyeXB0LAorCQkuY2lhX2RlY3J5cHQgPSByaXNjdjY0X3NtNF9kZWNyeXB0LAorCX0sCisJ LmNyYV9tb2R1bGUgPSBUSElTX01PRFVMRSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IHJpc2N2 NjRfc200X21vZF9pbml0KHZvaWQpCit7CisJaWYgKHJpc2N2X2lzYV9leHRlbnNpb25fYXZhaWxh YmxlKE5VTEwsIFpWS1NFRCkgJiYKKwkgICAgcmlzY3ZfaXNhX2V4dGVuc2lvbl9hdmFpbGFibGUo TlVMTCwgWlZLQikgJiYKKwkgICAgcmlzY3ZfdmVjdG9yX3ZsZW4oKSA+PSAxMjgpCisJCXJldHVy biBjcnlwdG9fcmVnaXN0ZXJfYWxnKCZyaXNjdjY0X3NtNF9hbGcpOworCisJcmV0dXJuIC1FTk9E RVY7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCByaXNjdjY0X3NtNF9tb2RfZXhpdCh2b2lkKQor eworCWNyeXB0b191bnJlZ2lzdGVyX2FsZygmcmlzY3Y2NF9zbTRfYWxnKTsKK30KKworbW9kdWxl X2luaXQocmlzY3Y2NF9zbTRfbW9kX2luaXQpOworbW9kdWxlX2V4aXQocmlzY3Y2NF9zbTRfbW9k X2V4aXQpOworCitNT0RVTEVfREVTQ1JJUFRJT04oIlNNNCAoUklTQy1WIGFjY2VsZXJhdGVkKSIp OworTU9EVUxFX0FVVEhPUigiSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1 PiIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTX0NSWVBUTygic200Iik7 CmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9zbTQtcmlzY3Y2NC16dmtzZWQtenZrYi5T IGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2VkLXp2a2IuUwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwLi5mYWU2MjE3OWE0YTNkCi0tLSAvZGV2L251 bGwKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2VkLXp2a2IuUwpAQCAt MCwwICsxLDExNyBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjAgT1Ig QlNELTItQ2xhdXNlICovCisvLworLy8gVGhpcyBmaWxlIGlzIGR1YWwtbGljZW5zZWQsIG1lYW5p bmcgdGhhdCB5b3UgY2FuIHVzZSBpdCB1bmRlciB5b3VyCisvLyBjaG9pY2Ugb2YgZWl0aGVyIG9m IHRoZSBmb2xsb3dpbmcgdHdvIGxpY2Vuc2VzOgorLy8KKy8vIENvcHlyaWdodCAyMDIzIFRoZSBP cGVuU1NMIFByb2plY3QgQXV0aG9ycy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKy8vCisvLyBMaWNl bnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UgMi4wICh0aGUgIkxpY2Vuc2UiKS4gWW91IGNh biBvYnRhaW4KKy8vIGEgY29weSBpbiB0aGUgZmlsZSBMSUNFTlNFIGluIHRoZSBzb3VyY2UgZGlz dHJpYnV0aW9uIG9yIGF0CisvLyBodHRwczovL3d3dy5vcGVuc3NsLm9yZy9zb3VyY2UvbGljZW5z ZS5odG1sCisvLworLy8gb3IKKy8vCisvLyBDb3B5cmlnaHQgKGMpIDIwMjMsIENocmlzdG9waCBN w7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxsLmV1PgorLy8gQ29weXJpZ2h0IChjKSAy MDIzLCBKZXJyeSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+CisvLyBDb3B5cmlnaHQgMjAy NCBHb29nbGUgTExDCisvLyBBbGwgcmlnaHRzIHJlc2VydmVkLgorLy8KKy8vIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor Ly8gbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zCisvLyBhcmUgbWV0OgorLy8gMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKy8vICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKy8vIDIu IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisvLyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisvLyAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorLy8KKy8vIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05U UklCVVRPUlMKKy8vICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UCisvLyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKy8vIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisv LyBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwKKy8vIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKy8vIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorLy8gREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZCisvLyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisvLyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKy8vIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKy8v IFRoZSBnZW5lcmF0ZWQgY29kZSBvZiB0aGlzIGZpbGUgZGVwZW5kcyBvbiB0aGUgZm9sbG93aW5n IFJJU0MtViBleHRlbnNpb25zOgorLy8gLSBSVjY0SQorLy8gLSBSSVNDLVYgVmVjdG9yICgnVicp IHdpdGggVkxFTiA+PSAxMjgKKy8vIC0gUklTQy1WIFZlY3RvciBTTTQgQmxvY2sgQ2lwaGVyIGV4 dGVuc2lvbiAoJ1p2a3NlZCcpCisvLyAtIFJJU0MtViBWZWN0b3IgQ3J5cHRvZ3JhcGh5IEJpdC1t YW5pcHVsYXRpb24gZXh0ZW5zaW9uICgnWnZrYicpCisKKyNpbmNsdWRlIDxsaW51eC9saW5rYWdl Lmg+CisKKy50ZXh0Cisub3B0aW9uIGFyY2gsICt6dmtzZWQsICt6dmtiCisKKy8vIHZvaWQgc200 X2V4cGFuZGtleV96a3NlZF96dmtiKGNvbnN0IHU4IHVzZXJfa2V5WzE2XSwgdTMyIHJrZXlfZW5j WzMyXSwKKy8vCQkJCSB1MzIgcmtleV9kZWNbMzJdKTsKK1NZTV9GVU5DX1NUQVJUKHNtNF9leHBh bmRrZXlfenZrc2VkX3p2a2IpCisJdnNldGl2bGkJemVybywgNCwgZTMyLCBtMSwgdGEsIG1hCisK KwkvLyBMb2FkIHRoZSB1c2VyIGtleS4KKwl2bGUzMi52CQl2MSwgKGEwKQorCXZyZXY4LnYJCXYx LCB2MQorCisJLy8gWE9SIHRoZSB1c2VyIGtleSB3aXRoIHRoZSBmYW1pbHkga2V5LgorCWxhCQl0 MCwgRkFNSUxZX0tFWQorCXZsZTMyLnYJCXYyLCAodDApCisJdnhvci52dgkJdjEsIHYxLCB2Mgor CisJLy8gQ29tcHV0ZSB0aGUgcm91bmQga2V5cy4gIFN0b3JlIHRoZW0gaW4gZm9yd2FyZHMgb3Jk ZXIgaW4gcmtleV9lbmMKKwkvLyBhbmQgaW4gcmV2ZXJzZSBvcmRlciBpbiBya2V5X2RlYy4KKwlh ZGRpCQlhMiwgYTIsIDMxKjQKKwlsaQkJdDAsIC00CisJLnNldAkJaSwgMAorLnJlcHQgOAorCXZz bTRrLnZpCXYxLCB2MSwgaQorCXZzZTMyLnYJCXYxLCAoYTEpCS8vIFN0b3JlIHRvIHJrZXlfZW5j LgorCXZzc2UzMi52CXYxLCAoYTIpLCB0MAkvLyBTdG9yZSB0byBya2V5X2RlYy4KKy5pZiBpIDwg NworCWFkZGkJCWExLCBhMSwgMTYKKwlhZGRpCQlhMiwgYTIsIC0xNgorLmVuZGlmCisJLnNldAkJ aSwgaSArIDEKKy5lbmRyCisKKwlyZXQKK1NZTV9GVU5DX0VORChzbTRfZXhwYW5ka2V5X3p2a3Nl ZF96dmtiKQorCisvLyB2b2lkIHNtNF9jcnlwdF96dmtzZWRfenZrYihjb25zdCB1MzIgcmtleVsz Ml0sIGNvbnN0IHU4IGluWzE2XSwgdTggb3V0WzE2XSk7CitTWU1fRlVOQ19TVEFSVChzbTRfY3J5 cHRfenZrc2VkX3p2a2IpCisJdnNldGl2bGkJemVybywgNCwgZTMyLCBtMSwgdGEsIG1hCisKKwkv LyBMb2FkIHRoZSBpbnB1dCBkYXRhLgorCXZsZTMyLnYJCXYxLCAoYTEpCisJdnJldjgudgkJdjEs IHYxCisKKwkvLyBEbyB0aGUgMzIgcm91bmRzIG9mIFNNNCwgNCBhdCBhIHRpbWUuCisJLnNldAkJ aSwgMAorLnJlcHQgOAorCXZsZTMyLnYJCXYyLCAoYTApCisJdnNtNHIudnMJdjEsIHYyCisuaWYg aSA8IDcKKwlhZGRpCQlhMCwgYTAsIDE2CisuZW5kaWYKKwkuc2V0CQlpLCBpICsgMQorLmVuZHIK KworCS8vIFN0b3JlIHRoZSBvdXRwdXQgZGF0YSAoaW4gcmV2ZXJzZSBlbGVtZW50IG9yZGVyKS4K Kwl2cmV2OC52CQl2MSwgdjEKKwlsaQkJdDAsIC00CisJYWRkaQkJYTIsIGEyLCAxMgorCXZzc2Uz Mi52CXYxLCAoYTIpLCB0MAorCisJcmV0CitTWU1fRlVOQ19FTkQoc200X2NyeXB0X3p2a3NlZF96 dmtiKQorCisuc2VjdGlvbiAiLnJvZGF0YSIKKy5wMmFsaWduIDIKKy50eXBlIEZBTUlMWV9LRVks IEBvYmplY3QKK0ZBTUlMWV9LRVk6CisJLndvcmQgMHhBM0IxQkFDNiwgMHg1NkFBMzM1MCwgMHg2 NzdEOTE5NywgMHhCMjcwMjJEQworLnNpemUgRkFNSUxZX0tFWSwgLiAtIEZBTUlMWV9LRVkKLS0g CjIuNDMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK