From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=sifive.com header.i=@sifive.com header.b="U3xghQLY" Received: from mail-pf1-x431.google.com (mail-pf1-x431.google.com [IPv6:2607:f8b0:4864:20::431]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 17D2A196 for ; Tue, 5 Dec 2023 01:28:26 -0800 (PST) Received: by mail-pf1-x431.google.com with SMTP id d2e1a72fcca58-6ce72730548so219942b3a.1 for ; Tue, 05 Dec 2023 01:28:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1701768505; x=1702373305; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=6Kmnx+Y86sgulAsiPpTedcqOMl+J6uedayIKHjFyzO8=; b=U3xghQLYFl0tgOqf8Ct+I/joKwt6P1qTzNkMTawfm3d678lUlUnK7YIC3tpymy3xqQ iRx7STl45t8kpsFpGkImvvTs1U2IHEfzVXTgaXFDdNHSnD4tY63P3nqK5zYE3IIhfOs0 DHZYxFGiUJDxcRrWrVJ9fdU/1dJca5kyvNf+3tqUg18onKm0jbAhG11FVRz0ve+MPxd5 2pHCLW6nBTSQiFuMTjdoSH8DHETwIB4wgLWXfhqxUVKy7f8qvwNSHzJOjTa8JCMTYmbb CGu1uiQomkTLa/1T/PUY85fE+BW+gI9cTGGKPrcAlfPVE6FN57sj3x7Enylzd7Scekl2 z/1Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1701768505; x=1702373305; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=6Kmnx+Y86sgulAsiPpTedcqOMl+J6uedayIKHjFyzO8=; b=FR13YUTFwNmEXSd5rLcDoUp7az0i37H4IaWdPO0OTXD4ekOAVT/F0KM/GyqAhKoBoI cBcMXJiFc9y12PZ+KJ9j9d4sTuZzhcRp5J/BWjetD9nm34h5P3JK7YTMGjlmqgboNXmS 4KpTl5MXTdsjKdXs0LRzRdIxfRU7+9iDPV2gitQhw4aJAE0zHhZnFW+AzDizelhfuUu9 5GYlB7CHu92n1zGCZHVpqp1o3BqeEI4o8lvxR0CVHhuBBw6bpTiHM7PXwvMF87C/xv/y lnPxaQNDngMVfBzw2DBfFptlKp1S6UAyrq7y/rPZgu7LgpybVK/SWapa6dFY02PlFwjr neBA== X-Gm-Message-State: AOJu0YwFDDoGZ/h5RhgU2hSV+dq7e2PANlJwC9q+ka9SFCVyiB+jQX1/ +9gMGvWpBVrTlGZXdROLiSu9pFtdabb/mz4g/s0= X-Google-Smtp-Source: AGHT+IECVZQ6+fFEHljhnLtEbUN3kwfwd7RMqPIo0WA204kiBYi99WQEK+Ma8PmyE81fPDrPGeHa7g== X-Received: by 2002:a05:6a00:2186:b0:6ce:450c:6586 with SMTP id h6-20020a056a00218600b006ce450c6586mr1230717pfi.26.1701768505304; Tue, 05 Dec 2023 01:28:25 -0800 (PST) Received: from localhost.localdomain ([101.10.93.135]) by smtp.gmail.com with ESMTPSA id l6-20020a056a00140600b006cdd723bb6fsm8858788pfu.115.2023.12.05.01.28.21 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Tue, 05 Dec 2023 01:28:24 -0800 (PST) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net, conor.dooley@microchip.com, ebiggers@kernel.org, ardb@kernel.org, conor@kernel.org Cc: heiko@sntech.de, phoebe.chen@sifive.com, hongrong.hsu@sifive.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-crypto@vger.kernel.org Subject: [PATCH v3 04/12] RISC-V: crypto: add Zvkned accelerated AES implementation Date: Tue, 5 Dec 2023 17:27:53 +0800 Message-Id: <20231205092801.1335-5-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231205092801.1335-1-jerry.shih@sifive.com> References: <20231205092801.1335-1-jerry.shih@sifive.com> 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 The AES implementation using the Zvkned vector crypto extension from OpenSSL(openssl/openssl#21923). Co-developed-by: Christoph Müllner Signed-off-by: Christoph Müllner Co-developed-by: Heiko Stuebner Signed-off-by: Heiko Stuebner Co-developed-by: Phoebe Chen Signed-off-by: Phoebe Chen Signed-off-by: Jerry Shih --- Changelog v3: - Rename aes_setkey() to aes_setkey_zvkned(). - Rename riscv64_aes_setkey() to riscv64_aes_setkey_zvkned(). - Use aes generic software key expanding everywhere. - Remove rv64i_zvkned_set_encrypt_key(). We still need to provide the decryption expanding key for the SW fallback path which is not supported directly using zvkned extension. So, we turn to use the pure generic software key expanding everywhere to simplify the set_key flow. - Use asm mnemonics for the instructions in RVV 1.0 extension. Changelog v2: - Do not turn on kconfig `AES_RISCV64` option by default. - Turn to use `crypto_aes_ctx` structure for aes key. - Use `Zvkned` extension for AES-128/256 key expanding. - Export riscv64_aes_* symbols for other modules. - Add `asmlinkage` qualifier for crypto asm function. - Reorder structure riscv64_aes_alg_zvkned members initialization in the order declared. --- arch/riscv/crypto/Kconfig | 11 + arch/riscv/crypto/Makefile | 11 + arch/riscv/crypto/aes-riscv64-glue.c | 137 +++++++ arch/riscv/crypto/aes-riscv64-glue.h | 18 + arch/riscv/crypto/aes-riscv64-zvkned.pl | 453 ++++++++++++++++++++++++ 5 files changed, 630 insertions(+) create mode 100644 arch/riscv/crypto/aes-riscv64-glue.c create mode 100644 arch/riscv/crypto/aes-riscv64-glue.h create mode 100644 arch/riscv/crypto/aes-riscv64-zvkned.pl diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index 10d60edc0110..65189d4d47b3 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -2,4 +2,15 @@ menu "Accelerated Cryptographic Algorithms for CPU (riscv)" +config CRYPTO_AES_RISCV64 + tristate "Ciphers: AES" + depends on 64BIT && RISCV_ISA_V + select CRYPTO_ALGAPI + select CRYPTO_LIB_AES + help + Block ciphers: AES cipher algorithms (FIPS-197) + + Architecture: riscv64 using: + - Zvkned vector crypto extension + endmenu diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index b3b6332c9f6d..90ca91d8df26 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -2,3 +2,14 @@ # # linux/arch/riscv/crypto/Makefile # + +obj-$(CONFIG_CRYPTO_AES_RISCV64) += aes-riscv64.o +aes-riscv64-y := aes-riscv64-glue.o aes-riscv64-zvkned.o + +quiet_cmd_perlasm = PERLASM $@ + cmd_perlasm = $(PERL) $(<) void $(@) + +$(obj)/aes-riscv64-zvkned.S: $(src)/aes-riscv64-zvkned.pl + $(call cmd,perlasm) + +clean-files += aes-riscv64-zvkned.S diff --git a/arch/riscv/crypto/aes-riscv64-glue.c b/arch/riscv/crypto/aes-riscv64-glue.c new file mode 100644 index 000000000000..f29898c25652 --- /dev/null +++ b/arch/riscv/crypto/aes-riscv64-glue.c @@ -0,0 +1,137 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Port of the OpenSSL AES implementation for RISC-V + * + * Copyright (C) 2023 VRULL GmbH + * Author: Heiko Stuebner + * + * Copyright (C) 2023 SiFive, Inc. + * Author: Jerry Shih + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "aes-riscv64-glue.h" + +/* aes cipher using zvkned vector crypto extension */ +asmlinkage void rv64i_zvkned_encrypt(const u8 *in, u8 *out, + const struct crypto_aes_ctx *key); +asmlinkage void rv64i_zvkned_decrypt(const u8 *in, u8 *out, + const struct crypto_aes_ctx *key); + +int riscv64_aes_setkey_zvkned(struct crypto_aes_ctx *ctx, const u8 *key, + unsigned int keylen) +{ + int ret; + + ret = aes_check_keylen(keylen); + if (ret < 0) + return -EINVAL; + + /* + * The RISC-V AES vector crypto key expanding doesn't support AES-192. + * So, we use the generic software key expanding here for all cases. + */ + return aes_expandkey(ctx, key, keylen); +} +EXPORT_SYMBOL(riscv64_aes_setkey_zvkned); + +void riscv64_aes_encrypt_zvkned(const struct crypto_aes_ctx *ctx, u8 *dst, + const u8 *src) +{ + if (crypto_simd_usable()) { + kernel_vector_begin(); + rv64i_zvkned_encrypt(src, dst, ctx); + kernel_vector_end(); + } else { + aes_encrypt(ctx, dst, src); + } +} +EXPORT_SYMBOL(riscv64_aes_encrypt_zvkned); + +void riscv64_aes_decrypt_zvkned(const struct crypto_aes_ctx *ctx, u8 *dst, + const u8 *src) +{ + if (crypto_simd_usable()) { + kernel_vector_begin(); + rv64i_zvkned_decrypt(src, dst, ctx); + kernel_vector_end(); + } else { + aes_decrypt(ctx, dst, src); + } +} +EXPORT_SYMBOL(riscv64_aes_decrypt_zvkned); + +static int aes_setkey_zvkned(struct crypto_tfm *tfm, const u8 *key, + unsigned int keylen) +{ + struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); + + return riscv64_aes_setkey_zvkned(ctx, key, keylen); +} + +static void aes_encrypt_zvkned(struct crypto_tfm *tfm, u8 *dst, const u8 *src) +{ + const struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); + + riscv64_aes_encrypt_zvkned(ctx, dst, src); +} + +static void aes_decrypt_zvkned(struct crypto_tfm *tfm, u8 *dst, const u8 *src) +{ + const struct crypto_aes_ctx *ctx = crypto_tfm_ctx(tfm); + + riscv64_aes_decrypt_zvkned(ctx, dst, src); +} + +static struct crypto_alg riscv64_aes_alg_zvkned = { + .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 = aes_setkey_zvkned, + .cia_encrypt = aes_encrypt_zvkned, + .cia_decrypt = aes_decrypt_zvkned, + }, + .cra_module = THIS_MODULE, +}; + +static inline bool check_aes_ext(void) +{ + return riscv_isa_extension_available(NULL, ZVKNED) && + riscv_vector_vlen() >= 128; +} + +static int __init riscv64_aes_mod_init(void) +{ + if (check_aes_ext()) + return crypto_register_alg(&riscv64_aes_alg_zvkned); + + return -ENODEV; +} + +static void __exit riscv64_aes_mod_fini(void) +{ + crypto_unregister_alg(&riscv64_aes_alg_zvkned); +} + +module_init(riscv64_aes_mod_init); +module_exit(riscv64_aes_mod_fini); + +MODULE_DESCRIPTION("AES (RISC-V accelerated)"); +MODULE_AUTHOR("Heiko Stuebner "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CRYPTO("aes"); diff --git a/arch/riscv/crypto/aes-riscv64-glue.h b/arch/riscv/crypto/aes-riscv64-glue.h new file mode 100644 index 000000000000..2b544125091e --- /dev/null +++ b/arch/riscv/crypto/aes-riscv64-glue.h @@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef AES_RISCV64_GLUE_H +#define AES_RISCV64_GLUE_H + +#include +#include + +int riscv64_aes_setkey_zvkned(struct crypto_aes_ctx *ctx, const u8 *key, + unsigned int keylen); + +void riscv64_aes_encrypt_zvkned(const struct crypto_aes_ctx *ctx, u8 *dst, + const u8 *src); + +void riscv64_aes_decrypt_zvkned(const struct crypto_aes_ctx *ctx, u8 *dst, + const u8 *src); + +#endif /* AES_RISCV64_GLUE_H */ diff --git a/arch/riscv/crypto/aes-riscv64-zvkned.pl b/arch/riscv/crypto/aes-riscv64-zvkned.pl new file mode 100644 index 000000000000..466357b4503c --- /dev/null +++ b/arch/riscv/crypto/aes-riscv64-zvkned.pl @@ -0,0 +1,453 @@ +#! /usr/bin/env perl +# 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 +# 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. + +# - RV64I +# - RISC-V Vector ('V') with VLEN >= 128 +# - RISC-V Vector AES block cipher extension ('Zvkned') + +use strict; +use warnings; + +use FindBin qw($Bin); +use lib "$Bin"; +use lib "$Bin/../../perlasm"; +use riscv; + +# $output is the last argument if it looks like a file (it has an extension) +# $flavour is the first argument if it doesn't look like a file +my $output = $#ARGV >= 0 && $ARGV[$#ARGV] =~ m|\.\w+$| ? pop : undef; +my $flavour = $#ARGV >= 0 && $ARGV[0] !~ m|\.| ? shift : undef; + +$output and open STDOUT,">$output"; + +my $code=<<___; +.text +___ + +my ($V0, $V1, $V2, $V3, $V4, $V5, $V6, $V7, + $V8, $V9, $V10, $V11, $V12, $V13, $V14, $V15, + $V16, $V17, $V18, $V19, $V20, $V21, $V22, $V23, + $V24, $V25, $V26, $V27, $V28, $V29, $V30, $V31, +) = map("v$_",(0..31)); + +{ +################################################################################ +# void rv64i_zvkned_encrypt(const unsigned char *in, unsigned char *out, +# const AES_KEY *key); +my ($INP, $OUTP, $KEYP) = ("a0", "a1", "a2"); +my ($T0) = ("t0"); +my ($KEY_LEN) = ("a3"); + +$code .= <<___; +.p2align 3 +.globl rv64i_zvkned_encrypt +.type rv64i_zvkned_encrypt,\@function +rv64i_zvkned_encrypt: + # Load key length. + lwu $KEY_LEN, 480($KEYP) + + # Get proper routine for key length. + li $T0, 32 + beq $KEY_LEN, $T0, L_enc_256 + li $T0, 24 + beq $KEY_LEN, $T0, L_enc_192 + li $T0, 16 + beq $KEY_LEN, $T0, L_enc_128 + + j L_fail_m2 +.size rv64i_zvkned_encrypt,.-rv64i_zvkned_encrypt +___ + +$code .= <<___; +.p2align 3 +L_enc_128: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + vle32.v $V10, ($KEYP) + @{[vaesz_vs $V1, $V10]} # with round key w[ 0, 3] + addi $KEYP, $KEYP, 16 + vle32.v $V11, ($KEYP) + @{[vaesem_vs $V1, $V11]} # with round key w[ 4, 7] + addi $KEYP, $KEYP, 16 + vle32.v $V12, ($KEYP) + @{[vaesem_vs $V1, $V12]} # with round key w[ 8,11] + addi $KEYP, $KEYP, 16 + vle32.v $V13, ($KEYP) + @{[vaesem_vs $V1, $V13]} # with round key w[12,15] + addi $KEYP, $KEYP, 16 + vle32.v $V14, ($KEYP) + @{[vaesem_vs $V1, $V14]} # with round key w[16,19] + addi $KEYP, $KEYP, 16 + vle32.v $V15, ($KEYP) + @{[vaesem_vs $V1, $V15]} # with round key w[20,23] + addi $KEYP, $KEYP, 16 + vle32.v $V16, ($KEYP) + @{[vaesem_vs $V1, $V16]} # with round key w[24,27] + addi $KEYP, $KEYP, 16 + vle32.v $V17, ($KEYP) + @{[vaesem_vs $V1, $V17]} # with round key w[28,31] + addi $KEYP, $KEYP, 16 + vle32.v $V18, ($KEYP) + @{[vaesem_vs $V1, $V18]} # with round key w[32,35] + addi $KEYP, $KEYP, 16 + vle32.v $V19, ($KEYP) + @{[vaesem_vs $V1, $V19]} # with round key w[36,39] + addi $KEYP, $KEYP, 16 + vle32.v $V20, ($KEYP) + @{[vaesef_vs $V1, $V20]} # with round key w[40,43] + + vse32.v $V1, ($OUTP) + + ret +.size L_enc_128,.-L_enc_128 +___ + +$code .= <<___; +.p2align 3 +L_enc_192: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + vle32.v $V10, ($KEYP) + @{[vaesz_vs $V1, $V10]} + addi $KEYP, $KEYP, 16 + vle32.v $V11, ($KEYP) + @{[vaesem_vs $V1, $V11]} + addi $KEYP, $KEYP, 16 + vle32.v $V12, ($KEYP) + @{[vaesem_vs $V1, $V12]} + addi $KEYP, $KEYP, 16 + vle32.v $V13, ($KEYP) + @{[vaesem_vs $V1, $V13]} + addi $KEYP, $KEYP, 16 + vle32.v $V14, ($KEYP) + @{[vaesem_vs $V1, $V14]} + addi $KEYP, $KEYP, 16 + vle32.v $V15, ($KEYP) + @{[vaesem_vs $V1, $V15]} + addi $KEYP, $KEYP, 16 + vle32.v $V16, ($KEYP) + @{[vaesem_vs $V1, $V16]} + addi $KEYP, $KEYP, 16 + vle32.v $V17, ($KEYP) + @{[vaesem_vs $V1, $V17]} + addi $KEYP, $KEYP, 16 + vle32.v $V18, ($KEYP) + @{[vaesem_vs $V1, $V18]} + addi $KEYP, $KEYP, 16 + vle32.v $V19, ($KEYP) + @{[vaesem_vs $V1, $V19]} + addi $KEYP, $KEYP, 16 + vle32.v $V20, ($KEYP) + @{[vaesem_vs $V1, $V20]} + addi $KEYP, $KEYP, 16 + vle32.v $V21, ($KEYP) + @{[vaesem_vs $V1, $V21]} + addi $KEYP, $KEYP, 16 + vle32.v $V22, ($KEYP) + @{[vaesef_vs $V1, $V22]} + + vse32.v $V1, ($OUTP) + ret +.size L_enc_192,.-L_enc_192 +___ + +$code .= <<___; +.p2align 3 +L_enc_256: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + vle32.v $V10, ($KEYP) + @{[vaesz_vs $V1, $V10]} + addi $KEYP, $KEYP, 16 + vle32.v $V11, ($KEYP) + @{[vaesem_vs $V1, $V11]} + addi $KEYP, $KEYP, 16 + vle32.v $V12, ($KEYP) + @{[vaesem_vs $V1, $V12]} + addi $KEYP, $KEYP, 16 + vle32.v $V13, ($KEYP) + @{[vaesem_vs $V1, $V13]} + addi $KEYP, $KEYP, 16 + vle32.v $V14, ($KEYP) + @{[vaesem_vs $V1, $V14]} + addi $KEYP, $KEYP, 16 + vle32.v $V15, ($KEYP) + @{[vaesem_vs $V1, $V15]} + addi $KEYP, $KEYP, 16 + vle32.v $V16, ($KEYP) + @{[vaesem_vs $V1, $V16]} + addi $KEYP, $KEYP, 16 + vle32.v $V17, ($KEYP) + @{[vaesem_vs $V1, $V17]} + addi $KEYP, $KEYP, 16 + vle32.v $V18, ($KEYP) + @{[vaesem_vs $V1, $V18]} + addi $KEYP, $KEYP, 16 + vle32.v $V19, ($KEYP) + @{[vaesem_vs $V1, $V19]} + addi $KEYP, $KEYP, 16 + vle32.v $V20, ($KEYP) + @{[vaesem_vs $V1, $V20]} + addi $KEYP, $KEYP, 16 + vle32.v $V21, ($KEYP) + @{[vaesem_vs $V1, $V21]} + addi $KEYP, $KEYP, 16 + vle32.v $V22, ($KEYP) + @{[vaesem_vs $V1, $V22]} + addi $KEYP, $KEYP, 16 + vle32.v $V23, ($KEYP) + @{[vaesem_vs $V1, $V23]} + addi $KEYP, $KEYP, 16 + vle32.v $V24, ($KEYP) + @{[vaesef_vs $V1, $V24]} + + vse32.v $V1, ($OUTP) + ret +.size L_enc_256,.-L_enc_256 +___ + +################################################################################ +# void rv64i_zvkned_decrypt(const unsigned char *in, unsigned char *out, +# const AES_KEY *key); +$code .= <<___; +.p2align 3 +.globl rv64i_zvkned_decrypt +.type rv64i_zvkned_decrypt,\@function +rv64i_zvkned_decrypt: + # Load key length. + lwu $KEY_LEN, 480($KEYP) + + # Get proper routine for key length. + li $T0, 32 + beq $KEY_LEN, $T0, L_dec_256 + li $T0, 24 + beq $KEY_LEN, $T0, L_dec_192 + li $T0, 16 + beq $KEY_LEN, $T0, L_dec_128 + + j L_fail_m2 +.size rv64i_zvkned_decrypt,.-rv64i_zvkned_decrypt +___ + +$code .= <<___; +.p2align 3 +L_dec_128: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + addi $KEYP, $KEYP, 160 + vle32.v $V20, ($KEYP) + @{[vaesz_vs $V1, $V20]} # with round key w[40,43] + addi $KEYP, $KEYP, -16 + vle32.v $V19, ($KEYP) + @{[vaesdm_vs $V1, $V19]} # with round key w[36,39] + addi $KEYP, $KEYP, -16 + vle32.v $V18, ($KEYP) + @{[vaesdm_vs $V1, $V18]} # with round key w[32,35] + addi $KEYP, $KEYP, -16 + vle32.v $V17, ($KEYP) + @{[vaesdm_vs $V1, $V17]} # with round key w[28,31] + addi $KEYP, $KEYP, -16 + vle32.v $V16, ($KEYP) + @{[vaesdm_vs $V1, $V16]} # with round key w[24,27] + addi $KEYP, $KEYP, -16 + vle32.v $V15, ($KEYP) + @{[vaesdm_vs $V1, $V15]} # with round key w[20,23] + addi $KEYP, $KEYP, -16 + vle32.v $V14, ($KEYP) + @{[vaesdm_vs $V1, $V14]} # with round key w[16,19] + addi $KEYP, $KEYP, -16 + vle32.v $V13, ($KEYP) + @{[vaesdm_vs $V1, $V13]} # with round key w[12,15] + addi $KEYP, $KEYP, -16 + vle32.v $V12, ($KEYP) + @{[vaesdm_vs $V1, $V12]} # with round key w[ 8,11] + addi $KEYP, $KEYP, -16 + vle32.v $V11, ($KEYP) + @{[vaesdm_vs $V1, $V11]} # with round key w[ 4, 7] + addi $KEYP, $KEYP, -16 + vle32.v $V10, ($KEYP) + @{[vaesdf_vs $V1, $V10]} # with round key w[ 0, 3] + + vse32.v $V1, ($OUTP) + + ret +.size L_dec_128,.-L_dec_128 +___ + +$code .= <<___; +.p2align 3 +L_dec_192: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + addi $KEYP, $KEYP, 192 + vle32.v $V22, ($KEYP) + @{[vaesz_vs $V1, $V22]} # with round key w[48,51] + addi $KEYP, $KEYP, -16 + vle32.v $V21, ($KEYP) + @{[vaesdm_vs $V1, $V21]} # with round key w[44,47] + addi $KEYP, $KEYP, -16 + vle32.v $V20, ($KEYP) + @{[vaesdm_vs $V1, $V20]} # with round key w[40,43] + addi $KEYP, $KEYP, -16 + vle32.v $V19, ($KEYP) + @{[vaesdm_vs $V1, $V19]} # with round key w[36,39] + addi $KEYP, $KEYP, -16 + vle32.v $V18, ($KEYP) + @{[vaesdm_vs $V1, $V18]} # with round key w[32,35] + addi $KEYP, $KEYP, -16 + vle32.v $V17, ($KEYP) + @{[vaesdm_vs $V1, $V17]} # with round key w[28,31] + addi $KEYP, $KEYP, -16 + vle32.v $V16, ($KEYP) + @{[vaesdm_vs $V1, $V16]} # with round key w[24,27] + addi $KEYP, $KEYP, -16 + vle32.v $V15, ($KEYP) + @{[vaesdm_vs $V1, $V15]} # with round key w[20,23] + addi $KEYP, $KEYP, -16 + vle32.v $V14, ($KEYP) + @{[vaesdm_vs $V1, $V14]} # with round key w[16,19] + addi $KEYP, $KEYP, -16 + vle32.v $V13, ($KEYP) + @{[vaesdm_vs $V1, $V13]} # with round key w[12,15] + addi $KEYP, $KEYP, -16 + vle32.v $V12, ($KEYP) + @{[vaesdm_vs $V1, $V12]} # with round key w[ 8,11] + addi $KEYP, $KEYP, -16 + vle32.v $V11, ($KEYP) + @{[vaesdm_vs $V1, $V11]} # with round key w[ 4, 7] + addi $KEYP, $KEYP, -16 + vle32.v $V10, ($KEYP) + @{[vaesdf_vs $V1, $V10]} # with round key w[ 0, 3] + + vse32.v $V1, ($OUTP) + + ret +.size L_dec_192,.-L_dec_192 +___ + +$code .= <<___; +.p2align 3 +L_dec_256: + vsetivli zero, 4, e32, m1, ta, ma + + vle32.v $V1, ($INP) + + addi $KEYP, $KEYP, 224 + vle32.v $V24, ($KEYP) + @{[vaesz_vs $V1, $V24]} # with round key w[56,59] + addi $KEYP, $KEYP, -16 + vle32.v $V23, ($KEYP) + @{[vaesdm_vs $V1, $V23]} # with round key w[52,55] + addi $KEYP, $KEYP, -16 + vle32.v $V22, ($KEYP) + @{[vaesdm_vs $V1, $V22]} # with round key w[48,51] + addi $KEYP, $KEYP, -16 + vle32.v $V21, ($KEYP) + @{[vaesdm_vs $V1, $V21]} # with round key w[44,47] + addi $KEYP, $KEYP, -16 + vle32.v $V20, ($KEYP) + @{[vaesdm_vs $V1, $V20]} # with round key w[40,43] + addi $KEYP, $KEYP, -16 + vle32.v $V19, ($KEYP) + @{[vaesdm_vs $V1, $V19]} # with round key w[36,39] + addi $KEYP, $KEYP, -16 + vle32.v $V18, ($KEYP) + @{[vaesdm_vs $V1, $V18]} # with round key w[32,35] + addi $KEYP, $KEYP, -16 + vle32.v $V17, ($KEYP) + @{[vaesdm_vs $V1, $V17]} # with round key w[28,31] + addi $KEYP, $KEYP, -16 + vle32.v $V16, ($KEYP) + @{[vaesdm_vs $V1, $V16]} # with round key w[24,27] + addi $KEYP, $KEYP, -16 + vle32.v $V15, ($KEYP) + @{[vaesdm_vs $V1, $V15]} # with round key w[20,23] + addi $KEYP, $KEYP, -16 + vle32.v $V14, ($KEYP) + @{[vaesdm_vs $V1, $V14]} # with round key w[16,19] + addi $KEYP, $KEYP, -16 + vle32.v $V13, ($KEYP) + @{[vaesdm_vs $V1, $V13]} # with round key w[12,15] + addi $KEYP, $KEYP, -16 + vle32.v $V12, ($KEYP) + @{[vaesdm_vs $V1, $V12]} # with round key w[ 8,11] + addi $KEYP, $KEYP, -16 + vle32.v $V11, ($KEYP) + @{[vaesdm_vs $V1, $V11]} # with round key w[ 4, 7] + addi $KEYP, $KEYP, -16 + vle32.v $V10, ($KEYP) + @{[vaesdf_vs $V1, $V10]} # with round key w[ 0, 3] + + vse32.v $V1, ($OUTP) + + ret +.size L_dec_256,.-L_dec_256 +___ +} + +$code .= <<___; +L_fail_m1: + li a0, -1 + ret +.size L_fail_m1,.-L_fail_m1 + +L_fail_m2: + li a0, -2 + ret +.size L_fail_m2,.-L_fail_m2 + +L_end: + ret +.size L_end,.-L_end +___ + +print $code; + +close STDOUT or die "error closing STDOUT: $!"; -- 2.28.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 57061C4167B for ; Tue, 5 Dec 2023 09:28:36 +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=hjL5S7OjtkGRJBwx8Dfthrt1W2SEmn/hw3vPuskWxR8=; b=NIBAIiBQC9ZrWu ubz3x89t5GF2RVE093raU08Vv9+qL6nfQJD96iGSZSFEejjcUcAefp9sqByhxW1iI3xufH92ib/My 5Va0XuWCw5MrDv3XfXFgsQkJ4kmU3Dva6VQtBzP4Ap7BFWov60uMjYMiki3mGInKsOQaDgi966Fgx cN8/AMyS/+VsZ7Ags3OQPC8exCapXVYwcaPmTn114vDd1x+l1TRUW34q/c8qxgxKYtI0t2laS1Shr VQ04CvA7YsJRZHFug28wGbMVvfd2+DqeGCQrdySh82skX6oVia/SiaJbjhTRU3Kxn1LG1edEJtjUf 1Q5veoVSI1EyB9ZKWV5g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rARjD-006ngn-0P; Tue, 05 Dec 2023 09:28:31 +0000 Received: from mail-pf1-x42b.google.com ([2607:f8b0:4864:20::42b]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rARj8-006ndk-2Z for linux-riscv@lists.infradead.org; Tue, 05 Dec 2023 09:28:29 +0000 Received: by mail-pf1-x42b.google.com with SMTP id d2e1a72fcca58-6cdd214bce1so5722499b3a.3 for ; Tue, 05 Dec 2023 01:28:25 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1701768505; x=1702373305; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=6Kmnx+Y86sgulAsiPpTedcqOMl+J6uedayIKHjFyzO8=; b=YjzCrXUgI2KmJ6GJHPX9ZPdooNP1k+4u58YTSPo5K5k18EVd/i9ib4U2g65fePwCPU lInOz0hjuxuXMRWuIHoFSrYKH+caAUtYZKfn2uVwJxcT7lxNvz5UYkZ0hjE9YYOTa8Mf iiCXB3+s+z9j1pj6UbnzSBGgVW4Wt37caDjg57/IsrYiJxSLLGhErStQKnNchCcEf/C6 pDMGj5WTfHPZ5DJTtVzLtQYZAWFVgdzyqhMvWbyXEOYuMIIdsYE9OnWUxCCE/8L0rrvn mQhp1gf3xfcGvOVLn5cADmAne2RmL3VLPGbHCavFEACS8fxipgJLWAly0W8yDWnr8k/1 t0Xw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1701768505; x=1702373305; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=6Kmnx+Y86sgulAsiPpTedcqOMl+J6uedayIKHjFyzO8=; b=gBZQrzkbzvWCcOxy9ImP5IjPttgIM8JM8/rakyCzFd6lxJZeNUBb6wxAx5Q5cfagM5 xBR7yk4WsQ4NaVvFETfY6xhXZSA8LkbXX+oI7J10IzHoxp85fhyK0HxnStxKQ1vOt6UU s8VVBf8IuxvNhhpKy7NpYDxKoDJcVuJ9UNSLYnvCk8SeZTjE3wO9QsulSqHGJ312PmRr Ymbfen98L+btrajA1S7WwvCUIEQNbZ0pG/yECklLeQ7Y4GuhtDSAmTZuQtuzIults8Kc ZHkYDwLc1oiBW2X1mrnuziF9tuKxt8kFozYCgZRn6YYKox1NLBGry8ub0m1ybunb1Xa/ lIDw== X-Gm-Message-State: AOJu0YwdYXHJa+lGxhPd9zs1OJJ9s3MvWLWwzixC9mEZRtqtLHMR8cuw qEFtIqhfN7GP6YmrdrhN7b+LSw== X-Google-Smtp-Source: AGHT+IECVZQ6+fFEHljhnLtEbUN3kwfwd7RMqPIo0WA204kiBYi99WQEK+Ma8PmyE81fPDrPGeHa7g== X-Received: by 2002:a05:6a00:2186:b0:6ce:450c:6586 with SMTP id h6-20020a056a00218600b006ce450c6586mr1230717pfi.26.1701768505304; Tue, 05 Dec 2023 01:28:25 -0800 (PST) Received: from localhost.localdomain ([101.10.93.135]) by smtp.gmail.com with ESMTPSA id l6-20020a056a00140600b006cdd723bb6fsm8858788pfu.115.2023.12.05.01.28.21 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Tue, 05 Dec 2023 01:28:24 -0800 (PST) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net, conor.dooley@microchip.com, ebiggers@kernel.org, ardb@kernel.org, conor@kernel.org Cc: heiko@sntech.de, phoebe.chen@sifive.com, hongrong.hsu@sifive.com, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-crypto@vger.kernel.org Subject: [PATCH v3 04/12] RISC-V: crypto: add Zvkned accelerated AES implementation Date: Tue, 5 Dec 2023 17:27:53 +0800 Message-Id: <20231205092801.1335-5-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231205092801.1335-1-jerry.shih@sifive.com> References: <20231205092801.1335-1-jerry.shih@sifive.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231205_012826_838055_93BF8BB1 X-CRM114-Status: GOOD ( 29.50 ) 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 VGhlIEFFUyBpbXBsZW1lbnRhdGlvbiB1c2luZyB0aGUgWnZrbmVkIHZlY3RvciBjcnlwdG8gZXh0 ZW5zaW9uIGZyb20KT3BlblNTTChvcGVuc3NsL29wZW5zc2wjMjE5MjMpLgoKQ28tZGV2ZWxvcGVk LWJ5OiBDaHJpc3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KU2ln bmVkLW9mZi1ieTogQ2hyaXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwu ZXU+CkNvLWRldmVsb3BlZC1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxs LmV1PgpTaWduZWQtb2ZmLWJ5OiBIZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJAdnJ1bGwu ZXU+CkNvLWRldmVsb3BlZC1ieTogUGhvZWJlIENoZW4gPHBob2ViZS5jaGVuQHNpZml2ZS5jb20+ ClNpZ25lZC1vZmYtYnk6IFBob2ViZSBDaGVuIDxwaG9lYmUuY2hlbkBzaWZpdmUuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBKZXJyeSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+Ci0tLQpDaGFuZ2Vs b2cgdjM6CiAtIFJlbmFtZSBhZXNfc2V0a2V5KCkgdG8gYWVzX3NldGtleV96dmtuZWQoKS4KIC0g UmVuYW1lIHJpc2N2NjRfYWVzX3NldGtleSgpIHRvIHJpc2N2NjRfYWVzX3NldGtleV96dmtuZWQo KS4KIC0gVXNlIGFlcyBnZW5lcmljIHNvZnR3YXJlIGtleSBleHBhbmRpbmcgZXZlcnl3aGVyZS4K IC0gUmVtb3ZlIHJ2NjRpX3p2a25lZF9zZXRfZW5jcnlwdF9rZXkoKS4KIFdlIHN0aWxsIG5lZWQg dG8gcHJvdmlkZSB0aGUgZGVjcnlwdGlvbiBleHBhbmRpbmcga2V5IGZvciB0aGUgU1cgZmFsbGJh Y2sKIHBhdGggd2hpY2ggaXMgbm90IHN1cHBvcnRlZCBkaXJlY3RseSB1c2luZyB6dmtuZWQgZXh0 ZW5zaW9uLiBTbywgd2UgdHVybgogdG8gdXNlIHRoZSBwdXJlIGdlbmVyaWMgc29mdHdhcmUga2V5 IGV4cGFuZGluZyBldmVyeXdoZXJlIHRvIHNpbXBsaWZ5IHRoZQogc2V0X2tleSBmbG93LgogLSBV c2UgYXNtIG1uZW1vbmljcyBmb3IgdGhlIGluc3RydWN0aW9ucyBpbiBSVlYgMS4wIGV4dGVuc2lv bi4KCkNoYW5nZWxvZyB2MjoKIC0gRG8gbm90IHR1cm4gb24ga2NvbmZpZyBgQUVTX1JJU0NWNjRg IG9wdGlvbiBieSBkZWZhdWx0LgogLSBUdXJuIHRvIHVzZSBgY3J5cHRvX2Flc19jdHhgIHN0cnVj dHVyZSBmb3IgYWVzIGtleS4KIC0gVXNlIGBadmtuZWRgIGV4dGVuc2lvbiBmb3IgQUVTLTEyOC8y NTYga2V5IGV4cGFuZGluZy4KIC0gRXhwb3J0IHJpc2N2NjRfYWVzXyogc3ltYm9scyBmb3Igb3Ro ZXIgbW9kdWxlcy4KIC0gQWRkIGBhc21saW5rYWdlYCBxdWFsaWZpZXIgZm9yIGNyeXB0byBhc20g ZnVuY3Rpb24uCiAtIFJlb3JkZXIgc3RydWN0dXJlIHJpc2N2NjRfYWVzX2FsZ196dmtuZWQgbWVt YmVycyBpbml0aWFsaXphdGlvbiBpbgogICB0aGUgb3JkZXIgZGVjbGFyZWQuCi0tLQogYXJjaC9y aXNjdi9jcnlwdG8vS2NvbmZpZyAgICAgICAgICAgICAgIHwgIDExICsKIGFyY2gvcmlzY3YvY3J5 cHRvL01ha2VmaWxlICAgICAgICAgICAgICB8ICAxMSArCiBhcmNoL3Jpc2N2L2NyeXB0by9hZXMt cmlzY3Y2NC1nbHVlLmMgICAgfCAxMzcgKysrKysrKwogYXJjaC9yaXNjdi9jcnlwdG8vYWVzLXJp c2N2NjQtZ2x1ZS5oICAgIHwgIDE4ICsKIGFyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LXp2 a25lZC5wbCB8IDQ1MyArKysrKysrKysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwg NjMwIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2NyeXB0by9h ZXMtcmlzY3Y2NC1nbHVlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2NyeXB0by9h ZXMtcmlzY3Y2NC1nbHVlLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3Jpc2N2L2NyeXB0by9h ZXMtcmlzY3Y2NC16dmtuZWQucGwKCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9LY29u ZmlnIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZwppbmRleCAxMGQ2MGVkYzAxMTAuLjY1MTg5 ZDRkNDdiMyAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZworKysgYi9hcmNo L3Jpc2N2L2NyeXB0by9LY29uZmlnCkBAIC0yLDQgKzIsMTUgQEAKIAogbWVudSAiQWNjZWxlcmF0 ZWQgQ3J5cHRvZ3JhcGhpYyBBbGdvcml0aG1zIGZvciBDUFUgKHJpc2N2KSIKIAorY29uZmlnIENS WVBUT19BRVNfUklTQ1Y2NAorCXRyaXN0YXRlICJDaXBoZXJzOiBBRVMiCisJZGVwZW5kcyBvbiA2 NEJJVCAmJiBSSVNDVl9JU0FfVgorCXNlbGVjdCBDUllQVE9fQUxHQVBJCisJc2VsZWN0IENSWVBU T19MSUJfQUVTCisJaGVscAorCSAgQmxvY2sgY2lwaGVyczogQUVTIGNpcGhlciBhbGdvcml0aG1z IChGSVBTLTE5NykKKworCSAgQXJjaGl0ZWN0dXJlOiByaXNjdjY0IHVzaW5nOgorCSAgLSBadmtu ZWQgdmVjdG9yIGNyeXB0byBleHRlbnNpb24KKwogZW5kbWVudQpkaWZmIC0tZ2l0IGEvYXJjaC9y aXNjdi9jcnlwdG8vTWFrZWZpbGUgYi9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmlsZQppbmRleCBi M2I2MzMyYzlmNmQuLjkwY2E5MWQ4ZGYyNiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8v TWFrZWZpbGUKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUKQEAgLTIsMyArMiwxNCBA QAogIwogIyBsaW51eC9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmlsZQogIworCitvYmotJChDT05G SUdfQ1JZUFRPX0FFU19SSVNDVjY0KSArPSBhZXMtcmlzY3Y2NC5vCithZXMtcmlzY3Y2NC15IDo9 IGFlcy1yaXNjdjY0LWdsdWUubyBhZXMtcmlzY3Y2NC16dmtuZWQubworCitxdWlldF9jbWRfcGVy bGFzbSA9IFBFUkxBU00gJEAKKyAgICAgIGNtZF9wZXJsYXNtID0gJChQRVJMKSAkKDwpIHZvaWQg JChAKQorCiskKG9iaikvYWVzLXJpc2N2NjQtenZrbmVkLlM6ICQoc3JjKS9hZXMtcmlzY3Y2NC16 dmtuZWQucGwKKwkkKGNhbGwgY21kLHBlcmxhc20pCisKK2NsZWFuLWZpbGVzICs9IGFlcy1yaXNj djY0LXp2a25lZC5TCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlzY3Y2NC1n bHVlLmMgYi9hcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlzY3Y2NC1nbHVlLmMKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5mMjk4OThjMjU2NTIKLS0tIC9kZXYvbnVsbAor KysgYi9hcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlzY3Y2NC1nbHVlLmMKQEAgLTAsMCArMSwxMzcg QEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKKy8qCisgKiBQb3J0 IG9mIHRoZSBPcGVuU1NMIEFFUyBpbXBsZW1lbnRhdGlvbiBmb3IgUklTQy1WCisgKgorICogQ29w eXJpZ2h0IChDKSAyMDIzIFZSVUxMIEdtYkgKKyAqIEF1dGhvcjogSGVpa28gU3R1ZWJuZXIgPGhl aWtvLnN0dWVibmVyQHZydWxsLmV1PgorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMyBTaUZpdmUs IEluYy4KKyAqIEF1dGhvcjogSmVycnkgU2hpaCA8amVycnkuc2hpaEBzaWZpdmUuY29tPgorICov CisKKyNpbmNsdWRlIDxhc20vc2ltZC5oPgorI2luY2x1ZGUgPGFzbS92ZWN0b3IuaD4KKyNpbmNs dWRlIDxjcnlwdG8vYWVzLmg+CisjaW5jbHVkZSA8Y3J5cHRvL2ludGVybmFsL2NpcGhlci5oPgor I2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9zaW1kLmg+CisjaW5jbHVkZSA8bGludXgvY3J5cHRv Lmg+CisjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5o PgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNpbmNsdWRlICJhZXMtcmlzY3Y2NC1nbHVl LmgiCisKKy8qIGFlcyBjaXBoZXIgdXNpbmcgenZrbmVkIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9u ICovCithc21saW5rYWdlIHZvaWQgcnY2NGlfenZrbmVkX2VuY3J5cHQoY29uc3QgdTggKmluLCB1 OCAqb3V0LAorCQkJCSAgICAgY29uc3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4ICprZXkpOworYXNt bGlua2FnZSB2b2lkIHJ2NjRpX3p2a25lZF9kZWNyeXB0KGNvbnN0IHU4ICppbiwgdTggKm91dCwK KwkJCQkgICAgIGNvbnN0IHN0cnVjdCBjcnlwdG9fYWVzX2N0eCAqa2V5KTsKKworaW50IHJpc2N2 NjRfYWVzX3NldGtleV96dmtuZWQoc3RydWN0IGNyeXB0b19hZXNfY3R4ICpjdHgsIGNvbnN0IHU4 ICprZXksCisJCQkgICAgICB1bnNpZ25lZCBpbnQga2V5bGVuKQoreworCWludCByZXQ7CisKKwly ZXQgPSBhZXNfY2hlY2tfa2V5bGVuKGtleWxlbik7CisJaWYgKHJldCA8IDApCisJCXJldHVybiAt RUlOVkFMOworCisJLyoKKwkgKiBUaGUgUklTQy1WIEFFUyB2ZWN0b3IgY3J5cHRvIGtleSBleHBh bmRpbmcgZG9lc24ndCBzdXBwb3J0IEFFUy0xOTIuCisJICogU28sIHdlIHVzZSB0aGUgZ2VuZXJp YyBzb2Z0d2FyZSBrZXkgZXhwYW5kaW5nIGhlcmUgZm9yIGFsbCBjYXNlcy4KKwkgKi8KKwlyZXR1 cm4gYWVzX2V4cGFuZGtleShjdHgsIGtleSwga2V5bGVuKTsKK30KK0VYUE9SVF9TWU1CT0wocmlz Y3Y2NF9hZXNfc2V0a2V5X3p2a25lZCk7CisKK3ZvaWQgcmlzY3Y2NF9hZXNfZW5jcnlwdF96dmtu ZWQoY29uc3Qgc3RydWN0IGNyeXB0b19hZXNfY3R4ICpjdHgsIHU4ICpkc3QsCisJCQkJY29uc3Qg dTggKnNyYykKK3sKKwlpZiAoY3J5cHRvX3NpbWRfdXNhYmxlKCkpIHsKKwkJa2VybmVsX3ZlY3Rv cl9iZWdpbigpOworCQlydjY0aV96dmtuZWRfZW5jcnlwdChzcmMsIGRzdCwgY3R4KTsKKwkJa2Vy bmVsX3ZlY3Rvcl9lbmQoKTsKKwl9IGVsc2UgeworCQlhZXNfZW5jcnlwdChjdHgsIGRzdCwgc3Jj KTsKKwl9Cit9CitFWFBPUlRfU1lNQk9MKHJpc2N2NjRfYWVzX2VuY3J5cHRfenZrbmVkKTsKKwor dm9pZCByaXNjdjY0X2Flc19kZWNyeXB0X3p2a25lZChjb25zdCBzdHJ1Y3QgY3J5cHRvX2Flc19j dHggKmN0eCwgdTggKmRzdCwKKwkJCQljb25zdCB1OCAqc3JjKQoreworCWlmIChjcnlwdG9fc2lt ZF91c2FibGUoKSkgeworCQlrZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJCXJ2NjRpX3p2a25lZF9k ZWNyeXB0KHNyYywgZHN0LCBjdHgpOworCQlrZXJuZWxfdmVjdG9yX2VuZCgpOworCX0gZWxzZSB7 CisJCWFlc19kZWNyeXB0KGN0eCwgZHN0LCBzcmMpOworCX0KK30KK0VYUE9SVF9TWU1CT0wocmlz Y3Y2NF9hZXNfZGVjcnlwdF96dmtuZWQpOworCitzdGF0aWMgaW50IGFlc19zZXRrZXlfenZrbmVk KHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0sIGNvbnN0IHU4ICprZXksCisJCQkgICAgIHVuc2lnbmVk IGludCBrZXlsZW4pCit7CisJc3RydWN0IGNyeXB0b19hZXNfY3R4ICpjdHggPSBjcnlwdG9fdGZt X2N0eCh0Zm0pOworCisJcmV0dXJuIHJpc2N2NjRfYWVzX3NldGtleV96dmtuZWQoY3R4LCBrZXks IGtleWxlbik7Cit9CisKK3N0YXRpYyB2b2lkIGFlc19lbmNyeXB0X3p2a25lZChzdHJ1Y3QgY3J5 cHRvX3RmbSAqdGZtLCB1OCAqZHN0LCBjb25zdCB1OCAqc3JjKQoreworCWNvbnN0IHN0cnVjdCBj cnlwdG9fYWVzX2N0eCAqY3R4ID0gY3J5cHRvX3RmbV9jdHgodGZtKTsKKworCXJpc2N2NjRfYWVz X2VuY3J5cHRfenZrbmVkKGN0eCwgZHN0LCBzcmMpOworfQorCitzdGF0aWMgdm9pZCBhZXNfZGVj cnlwdF96dmtuZWQoc3RydWN0IGNyeXB0b190Zm0gKnRmbSwgdTggKmRzdCwgY29uc3QgdTggKnNy YykKK3sKKwljb25zdCBzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmN0eCA9IGNyeXB0b190Zm1fY3R4 KHRmbSk7CisKKwlyaXNjdjY0X2Flc19kZWNyeXB0X3p2a25lZChjdHgsIGRzdCwgc3JjKTsKK30K Kworc3RhdGljIHN0cnVjdCBjcnlwdG9fYWxnIHJpc2N2NjRfYWVzX2FsZ196dmtuZWQgPSB7CisJ LmNyYV9mbGFncyA9IENSWVBUT19BTEdfVFlQRV9DSVBIRVIsCisJLmNyYV9ibG9ja3NpemUgPSBB RVNfQkxPQ0tfU0laRSwKKwkuY3JhX2N0eHNpemUgPSBzaXplb2Yoc3RydWN0IGNyeXB0b19hZXNf Y3R4KSwKKwkuY3JhX3ByaW9yaXR5ID0gMzAwLAorCS5jcmFfbmFtZSA9ICJhZXMiLAorCS5jcmFf ZHJpdmVyX25hbWUgPSAiYWVzLXJpc2N2NjQtenZrbmVkIiwKKwkuY3JhX2NpcGhlciA9IHsKKwkJ LmNpYV9taW5fa2V5c2l6ZSA9IEFFU19NSU5fS0VZX1NJWkUsCisJCS5jaWFfbWF4X2tleXNpemUg PSBBRVNfTUFYX0tFWV9TSVpFLAorCQkuY2lhX3NldGtleSA9IGFlc19zZXRrZXlfenZrbmVkLAor CQkuY2lhX2VuY3J5cHQgPSBhZXNfZW5jcnlwdF96dmtuZWQsCisJCS5jaWFfZGVjcnlwdCA9IGFl c19kZWNyeXB0X3p2a25lZCwKKwl9LAorCS5jcmFfbW9kdWxlID0gVEhJU19NT0RVTEUsCit9Owor CitzdGF0aWMgaW5saW5lIGJvb2wgY2hlY2tfYWVzX2V4dCh2b2lkKQoreworCXJldHVybiByaXNj dl9pc2FfZXh0ZW5zaW9uX2F2YWlsYWJsZShOVUxMLCBaVktORUQpICYmCisJICAgICAgIHJpc2N2 X3ZlY3Rvcl92bGVuKCkgPj0gMTI4OworfQorCitzdGF0aWMgaW50IF9faW5pdCByaXNjdjY0X2Fl c19tb2RfaW5pdCh2b2lkKQoreworCWlmIChjaGVja19hZXNfZXh0KCkpCisJCXJldHVybiBjcnlw dG9fcmVnaXN0ZXJfYWxnKCZyaXNjdjY0X2Flc19hbGdfenZrbmVkKTsKKworCXJldHVybiAtRU5P REVWOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgcmlzY3Y2NF9hZXNfbW9kX2Zpbmkodm9pZCkK K3sKKwljcnlwdG9fdW5yZWdpc3Rlcl9hbGcoJnJpc2N2NjRfYWVzX2FsZ196dmtuZWQpOworfQor Cittb2R1bGVfaW5pdChyaXNjdjY0X2Flc19tb2RfaW5pdCk7Cittb2R1bGVfZXhpdChyaXNjdjY0 X2Flc19tb2RfZmluaSk7CisKK01PRFVMRV9ERVNDUklQVElPTigiQUVTIChSSVNDLVYgYWNjZWxl cmF0ZWQpIik7CitNT0RVTEVfQVVUSE9SKCJIZWlrbyBTdHVlYm5lciA8aGVpa28uc3R1ZWJuZXJA dnJ1bGwuZXU+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CitNT0RVTEVfQUxJQVNfQ1JZUFRP KCJhZXMiKTsKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUu aCBiL2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjJiNTQ0MTI1MDkxZQotLS0gL2Rldi9udWxsCisrKyBi L2FyY2gvcmlzY3YvY3J5cHRvL2Flcy1yaXNjdjY0LWdsdWUuaApAQCAtMCwwICsxLDE4IEBACisv KiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLworCisjaWZuZGVmIEFFU19SSVND VjY0X0dMVUVfSAorI2RlZmluZSBBRVNfUklTQ1Y2NF9HTFVFX0gKKworI2luY2x1ZGUgPGNyeXB0 by9hZXMuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCitpbnQgcmlzY3Y2NF9hZXNfc2V0 a2V5X3p2a25lZChzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmN0eCwgY29uc3QgdTggKmtleSwKKwkJ CSAgICAgIHVuc2lnbmVkIGludCBrZXlsZW4pOworCit2b2lkIHJpc2N2NjRfYWVzX2VuY3J5cHRf enZrbmVkKGNvbnN0IHN0cnVjdCBjcnlwdG9fYWVzX2N0eCAqY3R4LCB1OCAqZHN0LAorCQkJCWNv bnN0IHU4ICpzcmMpOworCit2b2lkIHJpc2N2NjRfYWVzX2RlY3J5cHRfenZrbmVkKGNvbnN0IHN0 cnVjdCBjcnlwdG9fYWVzX2N0eCAqY3R4LCB1OCAqZHN0LAorCQkJCWNvbnN0IHU4ICpzcmMpOwor CisjZW5kaWYgLyogQUVTX1JJU0NWNjRfR0xVRV9IICovCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2 L2NyeXB0by9hZXMtcmlzY3Y2NC16dmtuZWQucGwgYi9hcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlz Y3Y2NC16dmtuZWQucGwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40 NjYzNTdiNDUwM2MKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3Jpc2N2L2NyeXB0by9hZXMtcmlz Y3Y2NC16dmtuZWQucGwKQEAgLTAsMCArMSw0NTMgQEAKKyMhIC91c3IvYmluL2VudiBwZXJsCisj IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wIE9SIEJTRC0yLUNsYXVzZQorIwor IyBUaGlzIGZpbGUgaXMgZHVhbC1saWNlbnNlZCwgbWVhbmluZyB0aGF0IHlvdSBjYW4gdXNlIGl0 IHVuZGVyIHlvdXIKKyMgY2hvaWNlIG9mIGVpdGhlciBvZiB0aGUgZm9sbG93aW5nIHR3byBsaWNl bnNlczoKKyMKKyMgQ29weXJpZ2h0IDIwMjMgVGhlIE9wZW5TU0wgUHJvamVjdCBBdXRob3JzLiBB bGwgUmlnaHRzIFJlc2VydmVkLgorIworIyBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vu c2UgMi4wICh0aGUgIkxpY2Vuc2UiKS4gWW91IGNhbiBvYnRhaW4KKyMgYSBjb3B5IGluIHRoZSBm aWxlIExJQ0VOU0UgaW4gdGhlIHNvdXJjZSBkaXN0cmlidXRpb24gb3IgYXQKKyMgaHR0cHM6Ly93 d3cub3BlbnNzbC5vcmcvc291cmNlL2xpY2Vuc2UuaHRtbAorIworIyBvcgorIworIyBDb3B5cmln aHQgKGMpIDIwMjMsIENocmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxs LmV1PgorIyBDb3B5cmlnaHQgKGMpIDIwMjMsIFBob2ViZSBDaGVuIDxwaG9lYmUuY2hlbkBzaWZp dmUuY29tPgorIyBDb3B5cmlnaHQgKGMpIDIwMjMsIEplcnJ5IFNoaWggPGplcnJ5LnNoaWhAc2lm aXZlLmNvbT4KKyMgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworIyBhcmUgbWV0OgorIyAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisj ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyMgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMg SVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisjIC0gUlY2NEkKKyMgLSBSSVNDLVYgVmVjdG9y ICgnVicpIHdpdGggVkxFTiA+PSAxMjgKKyMgLSBSSVNDLVYgVmVjdG9yIEFFUyBibG9jayBjaXBo ZXIgZXh0ZW5zaW9uICgnWnZrbmVkJykKKwordXNlIHN0cmljdDsKK3VzZSB3YXJuaW5nczsKKwor dXNlIEZpbmRCaW4gcXcoJEJpbik7Cit1c2UgbGliICIkQmluIjsKK3VzZSBsaWIgIiRCaW4vLi4v Li4vcGVybGFzbSI7Cit1c2UgcmlzY3Y7CisKKyMgJG91dHB1dCBpcyB0aGUgbGFzdCBhcmd1bWVu dCBpZiBpdCBsb29rcyBsaWtlIGEgZmlsZSAoaXQgaGFzIGFuIGV4dGVuc2lvbikKKyMgJGZsYXZv dXIgaXMgdGhlIGZpcnN0IGFyZ3VtZW50IGlmIGl0IGRvZXNuJ3QgbG9vayBsaWtlIGEgZmlsZQor bXkgJG91dHB1dCA9ICQjQVJHViA+PSAwICYmICRBUkdWWyQjQVJHVl0gPX4gbXxcLlx3KyR8ID8g cG9wIDogdW5kZWY7CitteSAkZmxhdm91ciA9ICQjQVJHViA+PSAwICYmICRBUkdWWzBdICF+IG18 XC58ID8gc2hpZnQgOiB1bmRlZjsKKworJG91dHB1dCBhbmQgb3BlbiBTVERPVVQsIj4kb3V0cHV0 IjsKKworbXkgJGNvZGU9PDxfX187CisudGV4dAorX19fCisKK215ICgkVjAsICRWMSwgJFYyLCAk VjMsICRWNCwgJFY1LCAkVjYsICRWNywKKyAgICAkVjgsICRWOSwgJFYxMCwgJFYxMSwgJFYxMiwg JFYxMywgJFYxNCwgJFYxNSwKKyAgICAkVjE2LCAkVjE3LCAkVjE4LCAkVjE5LCAkVjIwLCAkVjIx LCAkVjIyLCAkVjIzLAorICAgICRWMjQsICRWMjUsICRWMjYsICRWMjcsICRWMjgsICRWMjksICRW MzAsICRWMzEsCispID0gbWFwKCJ2JF8iLCgwLi4zMSkpOworCit7CisjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIworIyB2b2lkIHJ2NjRpX3p2a25lZF9lbmNyeXB0KGNvbnN0IHVuc2lnbmVkIGNoYXIg KmluLCB1bnNpZ25lZCBjaGFyICpvdXQsCisjICAgICAgICAgICAgICAgICAgICAgICAgICAgY29u c3QgQUVTX0tFWSAqa2V5KTsKK215ICgkSU5QLCAkT1VUUCwgJEtFWVApID0gKCJhMCIsICJhMSIs ICJhMiIpOworbXkgKCRUMCkgPSAoInQwIik7CitteSAoJEtFWV9MRU4pID0gKCJhMyIpOworCisk Y29kZSAuPSA8PF9fXzsKKy5wMmFsaWduIDMKKy5nbG9ibCBydjY0aV96dmtuZWRfZW5jcnlwdAor LnR5cGUgcnY2NGlfenZrbmVkX2VuY3J5cHQsXEBmdW5jdGlvbgorcnY2NGlfenZrbmVkX2VuY3J5 cHQ6CisgICAgIyBMb2FkIGtleSBsZW5ndGguCisgICAgbHd1ICRLRVlfTEVOLCA0ODAoJEtFWVAp CisKKyAgICAjIEdldCBwcm9wZXIgcm91dGluZSBmb3Iga2V5IGxlbmd0aC4KKyAgICBsaSAkVDAs IDMyCisgICAgYmVxICRLRVlfTEVOLCAkVDAsIExfZW5jXzI1NgorICAgIGxpICRUMCwgMjQKKyAg ICBiZXEgJEtFWV9MRU4sICRUMCwgTF9lbmNfMTkyCisgICAgbGkgJFQwLCAxNgorICAgIGJlcSAk S0VZX0xFTiwgJFQwLCBMX2VuY18xMjgKKworICAgIGogTF9mYWlsX20yCisuc2l6ZSBydjY0aV96 dmtuZWRfZW5jcnlwdCwuLXJ2NjRpX3p2a25lZF9lbmNyeXB0CitfX18KKworJGNvZGUgLj0gPDxf X187CisucDJhbGlnbiAzCitMX2VuY18xMjg6CisgICAgdnNldGl2bGkgemVybywgNCwgZTMyLCBt MSwgdGEsIG1hCisKKyAgICB2bGUzMi52ICRWMSwgKCRJTlApCisKKyAgICB2bGUzMi52ICRWMTAs ICgkS0VZUCkKKyAgICBAe1t2YWVzel92cyAkVjEsICRWMTBdfSAgICAjIHdpdGggcm91bmQga2V5 IHdbIDAsIDNdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIDE2CisgICAgdmxlMzIudiAkVjExLCAo JEtFWVApCisgICAgQHtbdmFlc2VtX3ZzICRWMSwgJFYxMV19ICAgIyB3aXRoIHJvdW5kIGtleSB3 WyA0LCA3XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxMiwgKCRL RVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTJdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sg OCwxMV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTMsICgkS0VZ UCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjEzXX0gICAjIHdpdGggcm91bmQga2V5IHdbMTIs MTVdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIDE2CisgICAgdmxlMzIudiAkVjE0LCAoJEtFWVAp CisgICAgQHtbdmFlc2VtX3ZzICRWMSwgJFYxNF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzE2LDE5 XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxNSwgKCRLRVlQKQor ICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTVdfSAgICMgd2l0aCByb3VuZCBrZXkgd1syMCwyM10K KyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTYsICgkS0VZUCkKKyAg ICBAe1t2YWVzZW1fdnMgJFYxLCAkVjE2XX0gICAjIHdpdGggcm91bmQga2V5IHdbMjQsMjddCisg ICAgYWRkaSAkS0VZUCwgJEtFWVAsIDE2CisgICAgdmxlMzIudiAkVjE3LCAoJEtFWVApCisgICAg QHtbdmFlc2VtX3ZzICRWMSwgJFYxN119ICAgIyB3aXRoIHJvdW5kIGtleSB3WzI4LDMxXQorICAg IGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxOCwgKCRLRVlQKQorICAgIEB7 W3ZhZXNlbV92cyAkVjEsICRWMThdfSAgICMgd2l0aCByb3VuZCBrZXkgd1szMiwzNV0KKyAgICBh ZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTksICgkS0VZUCkKKyAgICBAe1t2 YWVzZW1fdnMgJFYxLCAkVjE5XX0gICAjIHdpdGggcm91bmQga2V5IHdbMzYsMzldCisgICAgYWRk aSAkS0VZUCwgJEtFWVAsIDE2CisgICAgdmxlMzIudiAkVjIwLCAoJEtFWVApCisgICAgQHtbdmFl c2VmX3ZzICRWMSwgJFYyMF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzQwLDQzXQorCisgICAgdnNl MzIudiAkVjEsICgkT1VUUCkKKworICAgIHJldAorLnNpemUgTF9lbmNfMTI4LC4tTF9lbmNfMTI4 CitfX18KKworJGNvZGUgLj0gPDxfX187CisucDJhbGlnbiAzCitMX2VuY18xOTI6CisgICAgdnNl dGl2bGkgemVybywgNCwgZTMyLCBtMSwgdGEsIG1hCisKKyAgICB2bGUzMi52ICRWMSwgKCRJTlAp CisKKyAgICB2bGUzMi52ICRWMTAsICgkS0VZUCkKKyAgICBAe1t2YWVzel92cyAkVjEsICRWMTBd fQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxMSwgKCRLRVlQKQor ICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTFdfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgor ICAgIHZsZTMyLnYgJFYxMiwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTJdfQor ICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxMywgKCRLRVlQKQorICAg IEB7W3ZhZXNlbV92cyAkVjEsICRWMTNdfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAg IHZsZTMyLnYgJFYxNCwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTRdfQorICAg IGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxNSwgKCRLRVlQKQorICAgIEB7 W3ZhZXNlbV92cyAkVjEsICRWMTVdfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZs ZTMyLnYgJFYxNiwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMTZdfQorICAgIGFk ZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxNywgKCRLRVlQKQorICAgIEB7W3Zh ZXNlbV92cyAkVjEsICRWMTddfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMy LnYgJFYxOCwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMThdfQorICAgIGFkZGkg JEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYxOSwgKCRLRVlQKQorICAgIEB7W3ZhZXNl bV92cyAkVjEsICRWMTldfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYg JFYyMCwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92cyAkVjEsICRWMjBdfQorICAgIGFkZGkgJEtF WVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYyMSwgKCRLRVlQKQorICAgIEB7W3ZhZXNlbV92 cyAkVjEsICRWMjFdfQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNgorICAgIHZsZTMyLnYgJFYy MiwgKCRLRVlQKQorICAgIEB7W3ZhZXNlZl92cyAkVjEsICRWMjJdfQorCisgICAgdnNlMzIudiAk VjEsICgkT1VUUCkKKyAgICByZXQKKy5zaXplIExfZW5jXzE5MiwuLUxfZW5jXzE5MgorX19fCisK KyRjb2RlIC49IDw8X19fOworLnAyYWxpZ24gMworTF9lbmNfMjU2OgorICAgIHZzZXRpdmxpIHpl cm8sIDQsIGUzMiwgbTEsIHRhLCBtYQorCisgICAgdmxlMzIudiAkVjEsICgkSU5QKQorCisgICAg dmxlMzIudiAkVjEwLCAoJEtFWVApCisgICAgQHtbdmFlc3pfdnMgJFYxLCAkVjEwXX0KKyAgICBh ZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTEsICgkS0VZUCkKKyAgICBAe1t2 YWVzZW1fdnMgJFYxLCAkVjExXX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUz Mi52ICRWMTIsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjEyXX0KKyAgICBhZGRp ICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTMsICgkS0VZUCkKKyAgICBAe1t2YWVz ZW1fdnMgJFYxLCAkVjEzXX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52 ICRWMTQsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjE0XX0KKyAgICBhZGRpICRL RVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTUsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1f dnMgJFYxLCAkVjE1XX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRW MTYsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjE2XX0KKyAgICBhZGRpICRLRVlQ LCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTcsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMg JFYxLCAkVjE3XX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTgs ICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjE4XX0KKyAgICBhZGRpICRLRVlQLCAk S0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMTksICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYx LCAkVjE5XX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMjAsICgk S0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjIwXX0KKyAgICBhZGRpICRLRVlQLCAkS0VZ UCwgMTYKKyAgICB2bGUzMi52ICRWMjEsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAk VjIxXX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMjIsICgkS0VZ UCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjIyXX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwg MTYKKyAgICB2bGUzMi52ICRWMjMsICgkS0VZUCkKKyAgICBAe1t2YWVzZW1fdnMgJFYxLCAkVjIz XX0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgMTYKKyAgICB2bGUzMi52ICRWMjQsICgkS0VZUCkK KyAgICBAe1t2YWVzZWZfdnMgJFYxLCAkVjI0XX0KKworICAgIHZzZTMyLnYgJFYxLCAoJE9VVFAp CisgICAgcmV0Cisuc2l6ZSBMX2VuY18yNTYsLi1MX2VuY18yNTYKK19fXworCisjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIworIyB2b2lkIHJ2NjRpX3p2a25lZF9kZWNyeXB0KGNvbnN0IHVuc2lnbmVk IGNoYXIgKmluLCB1bnNpZ25lZCBjaGFyICpvdXQsCisjICAgICAgICAgICAgICAgICAgICAgICAg ICAgY29uc3QgQUVTX0tFWSAqa2V5KTsKKyRjb2RlIC49IDw8X19fOworLnAyYWxpZ24gMworLmds b2JsIHJ2NjRpX3p2a25lZF9kZWNyeXB0CisudHlwZSBydjY0aV96dmtuZWRfZGVjcnlwdCxcQGZ1 bmN0aW9uCitydjY0aV96dmtuZWRfZGVjcnlwdDoKKyAgICAjIExvYWQga2V5IGxlbmd0aC4KKyAg ICBsd3UgJEtFWV9MRU4sIDQ4MCgkS0VZUCkKKworICAgICMgR2V0IHByb3BlciByb3V0aW5lIGZv ciBrZXkgbGVuZ3RoLgorICAgIGxpICRUMCwgMzIKKyAgICBiZXEgJEtFWV9MRU4sICRUMCwgTF9k ZWNfMjU2CisgICAgbGkgJFQwLCAyNAorICAgIGJlcSAkS0VZX0xFTiwgJFQwLCBMX2RlY18xOTIK KyAgICBsaSAkVDAsIDE2CisgICAgYmVxICRLRVlfTEVOLCAkVDAsIExfZGVjXzEyOAorCisgICAg aiBMX2ZhaWxfbTIKKy5zaXplIHJ2NjRpX3p2a25lZF9kZWNyeXB0LC4tcnY2NGlfenZrbmVkX2Rl Y3J5cHQKK19fXworCiskY29kZSAuPSA8PF9fXzsKKy5wMmFsaWduIDMKK0xfZGVjXzEyODoKKyAg ICB2c2V0aXZsaSB6ZXJvLCA0LCBlMzIsIG0xLCB0YSwgbWEKKworICAgIHZsZTMyLnYgJFYxLCAo JElOUCkKKworICAgIGFkZGkgJEtFWVAsICRLRVlQLCAxNjAKKyAgICB2bGUzMi52ICRWMjAsICgk S0VZUCkKKyAgICBAe1t2YWVzel92cyAkVjEsICRWMjBdfSAgICAjIHdpdGggcm91bmQga2V5IHdb NDAsNDNdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxOSwgKCRL RVlQKQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTldfSAgICMgd2l0aCByb3VuZCBrZXkgd1sz NiwzOV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE4LCAoJEtF WVApCisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxOF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzMy LDM1XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTcsICgkS0VZ UCkKKyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE3XX0gICAjIHdpdGggcm91bmQga2V5IHdbMjgs MzFdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxNiwgKCRLRVlQ KQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTZdfSAgICMgd2l0aCByb3VuZCBrZXkgd1syNCwy N10KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE1LCAoJEtFWVAp CisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxNV19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzIwLDIz XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTQsICgkS0VZUCkK KyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE0XX0gICAjIHdpdGggcm91bmQga2V5IHdbMTYsMTld CisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxMywgKCRLRVlQKQor ICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTNdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sxMiwxNV0K KyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjEyLCAoJEtFWVApCisg ICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxMl19ICAgIyB3aXRoIHJvdW5kIGtleSB3WyA4LDExXQor ICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTEsICgkS0VZUCkKKyAg ICBAe1t2YWVzZG1fdnMgJFYxLCAkVjExXX0gICAjIHdpdGggcm91bmQga2V5IHdbIDQsIDddCisg ICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxMCwgKCRLRVlQKQorICAg IEB7W3ZhZXNkZl92cyAkVjEsICRWMTBdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sgMCwgM10KKwor ICAgIHZzZTMyLnYgJFYxLCAoJE9VVFApCisKKyAgICByZXQKKy5zaXplIExfZGVjXzEyOCwuLUxf ZGVjXzEyOAorX19fCisKKyRjb2RlIC49IDw8X19fOworLnAyYWxpZ24gMworTF9kZWNfMTkyOgor ICAgIHZzZXRpdmxpIHplcm8sIDQsIGUzMiwgbTEsIHRhLCBtYQorCisgICAgdmxlMzIudiAkVjEs ICgkSU5QKQorCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIDE5MgorICAgIHZsZTMyLnYgJFYyMiwg KCRLRVlQKQorICAgIEB7W3ZhZXN6X3ZzICRWMSwgJFYyMl19ICAgICMgd2l0aCByb3VuZCBrZXkg d1s0OCw1MV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjIxLCAo JEtFWVApCisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYyMV19ICAgIyB3aXRoIHJvdW5kIGtleSB3 WzQ0LDQ3XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMjAsICgk S0VZUCkKKyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjIwXX0gICAjIHdpdGggcm91bmQga2V5IHdb NDAsNDNdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxOSwgKCRL RVlQKQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTldfSAgICMgd2l0aCByb3VuZCBrZXkgd1sz NiwzOV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE4LCAoJEtF WVApCisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxOF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzMy LDM1XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTcsICgkS0VZ UCkKKyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE3XX0gICAjIHdpdGggcm91bmQga2V5IHdbMjgs MzFdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxNiwgKCRLRVlQ KQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTZdfSAgICMgd2l0aCByb3VuZCBrZXkgd1syNCwy N10KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE1LCAoJEtFWVAp CisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxNV19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzIwLDIz XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTQsICgkS0VZUCkK KyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE0XX0gICAjIHdpdGggcm91bmQga2V5IHdbMTYsMTld CisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxMywgKCRLRVlQKQor ICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTNdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sxMiwxNV0K KyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjEyLCAoJEtFWVApCisg ICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxMl19ICAgIyB3aXRoIHJvdW5kIGtleSB3WyA4LDExXQor ICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTEsICgkS0VZUCkKKyAg ICBAe1t2YWVzZG1fdnMgJFYxLCAkVjExXX0gICAjIHdpdGggcm91bmQga2V5IHdbIDQsIDddCisg ICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxMCwgKCRLRVlQKQorICAg IEB7W3ZhZXNkZl92cyAkVjEsICRWMTBdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sgMCwgM10KKwor ICAgIHZzZTMyLnYgJFYxLCAoJE9VVFApCisKKyAgICByZXQKKy5zaXplIExfZGVjXzE5MiwuLUxf ZGVjXzE5MgorX19fCisKKyRjb2RlIC49IDw8X19fOworLnAyYWxpZ24gMworTF9kZWNfMjU2Ogor ICAgIHZzZXRpdmxpIHplcm8sIDQsIGUzMiwgbTEsIHRhLCBtYQorCisgICAgdmxlMzIudiAkVjEs ICgkSU5QKQorCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIDIyNAorICAgIHZsZTMyLnYgJFYyNCwg KCRLRVlQKQorICAgIEB7W3ZhZXN6X3ZzICRWMSwgJFYyNF19ICAgICMgd2l0aCByb3VuZCBrZXkg d1s1Niw1OV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjIzLCAo JEtFWVApCisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYyM119ICAgIyB3aXRoIHJvdW5kIGtleSB3 WzUyLDU1XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMjIsICgk S0VZUCkKKyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjIyXX0gICAjIHdpdGggcm91bmQga2V5IHdb NDgsNTFdCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYyMSwgKCRL RVlQKQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMjFdfSAgICMgd2l0aCByb3VuZCBrZXkgd1s0 NCw0N10KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjIwLCAoJEtF WVApCisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYyMF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzQw LDQzXQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTksICgkS0VZ UCkKKyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE5XX0gICAjIHdpdGggcm91bmQga2V5IHdbMzYs MzldCisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxOCwgKCRLRVlQ KQorICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMThdfSAgICMgd2l0aCByb3VuZCBrZXkgd1szMiwz NV0KKyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE3LCAoJEtFWVAp CisgICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxN119ICAgIyB3aXRoIHJvdW5kIGtleSB3WzI4LDMx XQorICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTYsICgkS0VZUCkK KyAgICBAe1t2YWVzZG1fdnMgJFYxLCAkVjE2XX0gICAjIHdpdGggcm91bmQga2V5IHdbMjQsMjdd CisgICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxNSwgKCRLRVlQKQor ICAgIEB7W3ZhZXNkbV92cyAkVjEsICRWMTVdfSAgICMgd2l0aCByb3VuZCBrZXkgd1syMCwyM10K KyAgICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjE0LCAoJEtFWVApCisg ICAgQHtbdmFlc2RtX3ZzICRWMSwgJFYxNF19ICAgIyB3aXRoIHJvdW5kIGtleSB3WzE2LDE5XQor ICAgIGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTMsICgkS0VZUCkKKyAg ICBAe1t2YWVzZG1fdnMgJFYxLCAkVjEzXX0gICAjIHdpdGggcm91bmQga2V5IHdbMTIsMTVdCisg ICAgYWRkaSAkS0VZUCwgJEtFWVAsIC0xNgorICAgIHZsZTMyLnYgJFYxMiwgKCRLRVlQKQorICAg IEB7W3ZhZXNkbV92cyAkVjEsICRWMTJdfSAgICMgd2l0aCByb3VuZCBrZXkgd1sgOCwxMV0KKyAg ICBhZGRpICRLRVlQLCAkS0VZUCwgLTE2CisgICAgdmxlMzIudiAkVjExLCAoJEtFWVApCisgICAg QHtbdmFlc2RtX3ZzICRWMSwgJFYxMV19ICAgIyB3aXRoIHJvdW5kIGtleSB3WyA0LCA3XQorICAg IGFkZGkgJEtFWVAsICRLRVlQLCAtMTYKKyAgICB2bGUzMi52ICRWMTAsICgkS0VZUCkKKyAgICBA e1t2YWVzZGZfdnMgJFYxLCAkVjEwXX0gICAjIHdpdGggcm91bmQga2V5IHdbIDAsIDNdCisKKyAg ICB2c2UzMi52ICRWMSwgKCRPVVRQKQorCisgICAgcmV0Cisuc2l6ZSBMX2RlY18yNTYsLi1MX2Rl Y18yNTYKK19fXworfQorCiskY29kZSAuPSA8PF9fXzsKK0xfZmFpbF9tMToKKyAgICBsaSBhMCwg LTEKKyAgICByZXQKKy5zaXplIExfZmFpbF9tMSwuLUxfZmFpbF9tMQorCitMX2ZhaWxfbTI6Cisg ICAgbGkgYTAsIC0yCisgICAgcmV0Cisuc2l6ZSBMX2ZhaWxfbTIsLi1MX2ZhaWxfbTIKKworTF9l bmQ6CisgIHJldAorLnNpemUgTF9lbmQsLi1MX2VuZAorX19fCisKK3ByaW50ICRjb2RlOworCitj bG9zZSBTVERPVVQgb3IgZGllICJlcnJvciBjbG9zaW5nIFNURE9VVDogJCEiOwotLSAKMi4yOC4w CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt cmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo=