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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7B563C07545 for ; Wed, 25 Oct 2023 18:38:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234969AbjJYSif (ORCPT ); Wed, 25 Oct 2023 14:38:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55492 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235044AbjJYSiA (ORCPT ); Wed, 25 Oct 2023 14:38:00 -0400 Received: from mail-pj1-x1032.google.com (mail-pj1-x1032.google.com [IPv6:2607:f8b0:4864:20::1032]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2469C10F2 for ; Wed, 25 Oct 2023 11:37:37 -0700 (PDT) Received: by mail-pj1-x1032.google.com with SMTP id 98e67ed59e1d1-27d4b280e4eso25209a91.1 for ; Wed, 25 Oct 2023 11:37:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1698259056; x=1698863856; 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=HmLKITkx1eSP8gqJH+WnAeHuaVXFpzAB9w+G6AVIsu4=; b=iyJEFLwpQMIymHKm5MfRobOYyLy3KRrZa4dQD/GwYe8SNCcdS/DZ4aMduqc/ZcbALi sUtSh9NQKaM+LFSQDiGJ2nK7TtMcO7MfrEjlF5JrNTWrzNL6X2MrSjZRdI59gGfY2+4g 2dkMW7huuXUgfU33aCbk5SSUfwZmbirob2aara/mHcrAXTCokkB38PGODuXY/t0dIwr+ Jk280ei59QPG6BLETCSLQoKM2Xk00gMfLxqTozM4WrISQGcZI+DPpyITfe7ySGF2GWN6 8WyG4wHN1bgVhYJgCBlbGu/ee1OQh2Er5wZeszDP50k+bU+F+KrCUL2ycKqqM77P7kjR cc8A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698259056; x=1698863856; 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=HmLKITkx1eSP8gqJH+WnAeHuaVXFpzAB9w+G6AVIsu4=; b=N41QtLjEfpDv9nZWcusIrcyZDN906ihyNlOWULV9NWjnOV7TlrdbHwyhnqof9x2wgx UJBvLORJNYN2LmzX+MQJ8IcbqlHnxTFmMO90rbZEDxtR+nqRaD+DpUL3ZAJciGxqOyqW GNnvaota5nczX4nKYWoXXk4zqBM3S3WJEOjex1/O8FXa9p7YFQDXdqDpWEAuKxXwmRmK rvtB9wQ84kOeiugf8MAyk+LrPBDprXeYFKyf1JoDfFDWpjbZScd78qYIHKxUFaD2/5cC GV7mMjTSCdJYSAaOqyScZl8YGPYzTMshHziAjjDjXFtYkx17uEqvqA/M9P1DeXHYPMWl SapA== X-Gm-Message-State: AOJu0Yy5cJRJhqwV8dT/3x8JbMbq9Ji5F3S7XxfYF43JinPAlNJC6E+J rKsYN/Mah4Ncu7odoF6Vhq/5EQ== X-Google-Smtp-Source: AGHT+IHzBlS+B5URuxLTQ8oBJy/h5hlYy7abyTtFnLBrnHWfXXOjXLi3op7KwlrM0zcS/751EbwnpQ== X-Received: by 2002:a17:90b:1652:b0:27d:1126:1ff6 with SMTP id il18-20020a17090b165200b0027d11261ff6mr536600pjb.8.1698259056268; Wed, 25 Oct 2023 11:37:36 -0700 (PDT) Received: from localhost.localdomain ([49.216.222.119]) by smtp.gmail.com with ESMTPSA id g3-20020a17090adb0300b00278f1512dd9sm212367pjv.32.2023.10.25.11.37.32 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Wed, 25 Oct 2023 11:37:35 -0700 (PDT) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net Cc: andy.chiu@sifive.com, greentime.hu@sifive.com, conor.dooley@microchip.com, guoren@kernel.org, bjorn@rivosinc.com, heiko@sntech.de, ebiggers@kernel.org, ardb@kernel.org, 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 10/12] RISC-V: crypto: add Zvksed accelerated SM4 implementation Date: Thu, 26 Oct 2023 02:36:42 +0800 Message-Id: <20231025183644.8735-11-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231025183644.8735-1-jerry.shih@sifive.com> References: <20231025183644.8735-1-jerry.shih@sifive.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org Add SM4 implementation using Zvksed vector crypto extension from OpenSSL (openssl/openssl#21923). The perlasm here is different from the original implementation in OpenSSL. In OpenSSL, SM4 has the separated set_encrypt_key and set_decrypt_key functions. In kernel, these set_key functions are merged into a single one in order to skip the redundant key expanding instructions. 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 --- arch/riscv/crypto/Kconfig | 19 ++ arch/riscv/crypto/Makefile | 7 + arch/riscv/crypto/sm4-riscv64-glue.c | 120 +++++++++++ arch/riscv/crypto/sm4-riscv64-zvksed.pl | 268 ++++++++++++++++++++++++ 4 files changed, 414 insertions(+) create mode 100644 arch/riscv/crypto/sm4-riscv64-glue.c create mode 100644 arch/riscv/crypto/sm4-riscv64-zvksed.pl diff --git a/arch/riscv/crypto/Kconfig b/arch/riscv/crypto/Kconfig index a5a34777d9c3..ff004afa2874 100644 --- a/arch/riscv/crypto/Kconfig +++ b/arch/riscv/crypto/Kconfig @@ -75,4 +75,23 @@ config CRYPTO_SHA512_RISCV64 - Zvkb vector crypto extension - Zvknhb vector crypto extension +config CRYPTO_SM4_RISCV64 + default y if RISCV_ISA_V + tristate "Ciphers: SM4 (ShangMi 4)" + depends on 64BIT && RISCV_ISA_V + select CRYPTO_ALGAPI + select CRYPTO_SM4 + select CRYPTO_SM4_GENERIC + help + SM4 cipher algorithms (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 algorithms for the use within China. + + Architecture: riscv64 using: + - Zvkb vector crypto extension + - Zvksed vector crypto extension + endmenu diff --git a/arch/riscv/crypto/Makefile b/arch/riscv/crypto/Makefile index ebb4e861ebdc..ffad095e531f 100644 --- a/arch/riscv/crypto/Makefile +++ b/arch/riscv/crypto/Makefile @@ -18,6 +18,9 @@ sha256-riscv64-y := sha256-riscv64-glue.o sha256-riscv64-zvkb-zvknha_or_zvknhb.o obj-$(CONFIG_CRYPTO_SHA512_RISCV64) += sha512-riscv64.o sha512-riscv64-y := sha512-riscv64-glue.o sha512-riscv64-zvkb-zvknhb.o +obj-$(CONFIG_CRYPTO_SM4_RISCV64) += sm4-riscv64.o +sm4-riscv64-y := sm4-riscv64-glue.o sm4-riscv64-zvksed.o + quiet_cmd_perlasm = PERLASM $@ cmd_perlasm = $(PERL) $(<) void $(@) @@ -39,9 +42,13 @@ $(obj)/sha256-riscv64-zvkb-zvknha_or_zvknhb.S: $(src)/sha256-riscv64-zvkb-zvknha $(obj)/sha512-riscv64-zvkb-zvknhb.S: $(src)/sha512-riscv64-zvkb-zvknhb.pl $(call cmd,perlasm) +$(obj)/sm4-riscv64-zvksed.S: $(src)/sm4-riscv64-zvksed.pl + $(call cmd,perlasm) + clean-files += aes-riscv64-zvkned.S clean-files += aes-riscv64-zvbb-zvkg-zvkned.S clean-files += aes-riscv64-zvkb-zvkned.S clean-files += ghash-riscv64-zvkg.S clean-files += sha256-riscv64-zvkb-zvknha_or_zvknhb.S clean-files += sha512-riscv64-zvkb-zvknhb.S +clean-files += sm4-riscv64-zvksed.S diff --git a/arch/riscv/crypto/sm4-riscv64-glue.c b/arch/riscv/crypto/sm4-riscv64-glue.c new file mode 100644 index 000000000000..2d9983a4b1ee --- /dev/null +++ b/arch/riscv/crypto/sm4-riscv64-glue.c @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Linux/riscv64 port of the OpenSSL SM4 implementation for RISC-V 64 + * + * 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 + +/* sm4 using zvksed vector crypto extension */ +void rv64i_zvksed_sm4_encrypt(const u8 *in, u8 *out, const u32 *key); +void rv64i_zvksed_sm4_decrypt(const u8 *in, u8 *out, const u32 *key); +int rv64i_zvksed_sm4_set_key(const u8 *userKey, unsigned int key_len, + u32 *enc_key, u32 *dec_key); + +static int riscv64_sm4_setkey_zvksed(struct crypto_tfm *tfm, const u8 *key, + unsigned int key_len) +{ + struct sm4_ctx *ctx = crypto_tfm_ctx(tfm); + int ret = 0; + + if (crypto_simd_usable()) { + kernel_vector_begin(); + if (rv64i_zvksed_sm4_set_key(key, key_len, ctx->rkey_enc, + ctx->rkey_dec)) + ret = -EINVAL; + kernel_vector_end(); + } else { + ret = sm4_expandkey(ctx, key, key_len); + } + + return ret; +} + +static void riscv64_sm4_encrypt_zvksed(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(); + rv64i_zvksed_sm4_encrypt(src, dst, ctx->rkey_enc); + kernel_vector_end(); + } else { + sm4_crypt_block(ctx->rkey_enc, dst, src); + } +} + +static void riscv64_sm4_decrypt_zvksed(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(); + rv64i_zvksed_sm4_decrypt(src, dst, ctx->rkey_dec); + kernel_vector_end(); + } else { + sm4_crypt_block(ctx->rkey_dec, dst, src); + } +} + +struct crypto_alg riscv64_sm4_zvksed_alg = { + .cra_name = "sm4", + .cra_driver_name = "sm4-riscv64-zvkb-zvksed", + .cra_module = THIS_MODULE, + .cra_priority = 300, + .cra_flags = CRYPTO_ALG_TYPE_CIPHER, + .cra_blocksize = SM4_BLOCK_SIZE, + .cra_ctxsize = sizeof(struct sm4_ctx), + .cra_cipher = { + .cia_min_keysize = SM4_KEY_SIZE, + .cia_max_keysize = SM4_KEY_SIZE, + .cia_setkey = riscv64_sm4_setkey_zvksed, + .cia_encrypt = riscv64_sm4_encrypt_zvksed, + .cia_decrypt = riscv64_sm4_decrypt_zvksed, + }, +}; + +static inline bool check_sm4_ext(void) +{ + return riscv_isa_extension_available(NULL, ZVKSED) && + riscv_isa_extension_available(NULL, ZVKB) && + riscv_vector_vlen() >= 128; +} + +static int __init riscv64_sm4_mod_init(void) +{ + if (check_sm4_ext()) + return crypto_register_alg(&riscv64_sm4_zvksed_alg); + + return -ENODEV; +} + +static void __exit riscv64_sm4_mod_fini(void) +{ + if (check_sm4_ext()) + crypto_unregister_alg(&riscv64_sm4_zvksed_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.pl b/arch/riscv/crypto/sm4-riscv64-zvksed.pl new file mode 100644 index 000000000000..a764668c8398 --- /dev/null +++ b/arch/riscv/crypto/sm4-riscv64-zvksed.pl @@ -0,0 +1,268 @@ +#! /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, 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. + +# The generated code of this file depends on the following RISC-V extensions: +# - RV64I +# - RISC-V Vector ('V') with VLEN >= 128 +# - RISC-V Vector Cryptography Bit-manipulation extension ('Zvkb') +# - RISC-V Vector SM4 Block Cipher extension ('Zvksed') + +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 +___ + +#### +# int rv64i_zvksed_sm4_set_key(const u8 *userKey, unsigned int key_len, +# u32 *enc_key, u32 *dec_key); +# +{ +my ($ukey,$key_len,$enc_key,$dec_key)=("a0","a1","a2","a3"); +my ($fk,$stride)=("a4","a5"); +my ($t0,$t1)=("t0","t1"); +my ($vukey,$vfk,$vk0,$vk1,$vk2,$vk3,$vk4,$vk5,$vk6,$vk7)=("v1","v2","v3","v4","v5","v6","v7","v8","v9","v10"); +$code .= <<___; +.p2align 3 +.globl rv64i_zvksed_sm4_set_key +.type rv64i_zvksed_sm4_set_key,\@function +rv64i_zvksed_sm4_set_key: + li $t0, 16 + beq $t0, $key_len, 1f + li a0, 1 + ret +1: + + @{[vsetivli "zero", 4, "e32", "m1", "ta", "ma"]} + + # Load the user key + @{[vle32_v $vukey, $ukey]} + @{[vrev8_v $vukey, $vukey]} + + # Load the FK. + la $fk, FK + @{[vle32_v $vfk, $fk]} + + # Generate round keys. + @{[vxor_vv $vukey, $vukey, $vfk]} + @{[vsm4k_vi $vk0, $vukey, 0]} # rk[0:3] + @{[vsm4k_vi $vk1, $vk0, 1]} # rk[4:7] + @{[vsm4k_vi $vk2, $vk1, 2]} # rk[8:11] + @{[vsm4k_vi $vk3, $vk2, 3]} # rk[12:15] + @{[vsm4k_vi $vk4, $vk3, 4]} # rk[16:19] + @{[vsm4k_vi $vk5, $vk4, 5]} # rk[20:23] + @{[vsm4k_vi $vk6, $vk5, 6]} # rk[24:27] + @{[vsm4k_vi $vk7, $vk6, 7]} # rk[28:31] + + # Store enc round keys + @{[vse32_v $vk0, $enc_key]} # rk[0:3] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk1, $enc_key]} # rk[4:7] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk2, $enc_key]} # rk[8:11] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk3, $enc_key]} # rk[12:15] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk4, $enc_key]} # rk[16:19] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk5, $enc_key]} # rk[20:23] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk6, $enc_key]} # rk[24:27] + addi $enc_key, $enc_key, 16 + @{[vse32_v $vk7, $enc_key]} # rk[28:31] + + # Store dec round keys in reverse order + addi $dec_key, $dec_key, 12 + li $stride, -4 + @{[vsse32_v $vk7, $dec_key, $stride]} # rk[31:28] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk6, $dec_key, $stride]} # rk[27:24] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk5, $dec_key, $stride]} # rk[23:20] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk4, $dec_key, $stride]} # rk[19:16] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk3, $dec_key, $stride]} # rk[15:12] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk2, $dec_key, $stride]} # rk[11:8] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk1, $dec_key, $stride]} # rk[7:4] + addi $dec_key, $dec_key, 16 + @{[vsse32_v $vk0, $dec_key, $stride]} # rk[3:0] + + li a0, 0 + ret +.size rv64i_zvksed_sm4_set_key,.-rv64i_zvksed_sm4_set_key +___ +} + +#### +# void rv64i_zvksed_sm4_encrypt(const unsigned char *in, unsigned char *out, +# const SM4_KEY *key); +# +{ +my ($in,$out,$keys,$stride)=("a0","a1","a2","t0"); +my ($vdata,$vk0,$vk1,$vk2,$vk3,$vk4,$vk5,$vk6,$vk7,$vgen)=("v1","v2","v3","v4","v5","v6","v7","v8","v9","v10"); +$code .= <<___; +.p2align 3 +.globl rv64i_zvksed_sm4_encrypt +.type rv64i_zvksed_sm4_encrypt,\@function +rv64i_zvksed_sm4_encrypt: + @{[vsetivli "zero", 4, "e32", "m1", "ta", "ma"]} + + # Load input data + @{[vle32_v $vdata, $in]} + @{[vrev8_v $vdata, $vdata]} + + # Order of elements was adjusted in sm4_set_key() + # Encrypt with all keys + @{[vle32_v $vk0, $keys]} # rk[0:3] + @{[vsm4r_vs $vdata, $vk0]} + addi $keys, $keys, 16 + @{[vle32_v $vk1, $keys]} # rk[4:7] + @{[vsm4r_vs $vdata, $vk1]} + addi $keys, $keys, 16 + @{[vle32_v $vk2, $keys]} # rk[8:11] + @{[vsm4r_vs $vdata, $vk2]} + addi $keys, $keys, 16 + @{[vle32_v $vk3, $keys]} # rk[12:15] + @{[vsm4r_vs $vdata, $vk3]} + addi $keys, $keys, 16 + @{[vle32_v $vk4, $keys]} # rk[16:19] + @{[vsm4r_vs $vdata, $vk4]} + addi $keys, $keys, 16 + @{[vle32_v $vk5, $keys]} # rk[20:23] + @{[vsm4r_vs $vdata, $vk5]} + addi $keys, $keys, 16 + @{[vle32_v $vk6, $keys]} # rk[24:27] + @{[vsm4r_vs $vdata, $vk6]} + addi $keys, $keys, 16 + @{[vle32_v $vk7, $keys]} # rk[28:31] + @{[vsm4r_vs $vdata, $vk7]} + + # Save the ciphertext (in reverse element order) + @{[vrev8_v $vdata, $vdata]} + li $stride, -4 + addi $out, $out, 12 + @{[vsse32_v $vdata, $out, $stride]} + + ret +.size rv64i_zvksed_sm4_encrypt,.-rv64i_zvksed_sm4_encrypt +___ +} + +#### +# void rv64i_zvksed_sm4_decrypt(const unsigned char *in, unsigned char *out, +# const SM4_KEY *key); +# +{ +my ($in,$out,$keys,$stride)=("a0","a1","a2","t0"); +my ($vdata,$vk0,$vk1,$vk2,$vk3,$vk4,$vk5,$vk6,$vk7,$vgen)=("v1","v2","v3","v4","v5","v6","v7","v8","v9","v10"); +$code .= <<___; +.p2align 3 +.globl rv64i_zvksed_sm4_decrypt +.type rv64i_zvksed_sm4_decrypt,\@function +rv64i_zvksed_sm4_decrypt: + @{[vsetivli "zero", 4, "e32", "m1", "ta", "ma"]} + + # Load input data + @{[vle32_v $vdata, $in]} + @{[vrev8_v $vdata, $vdata]} + + # Order of key elements was adjusted in sm4_set_key() + # Decrypt with all keys + @{[vle32_v $vk7, $keys]} # rk[31:28] + @{[vsm4r_vs $vdata, $vk7]} + addi $keys, $keys, 16 + @{[vle32_v $vk6, $keys]} # rk[27:24] + @{[vsm4r_vs $vdata, $vk6]} + addi $keys, $keys, 16 + @{[vle32_v $vk5, $keys]} # rk[23:20] + @{[vsm4r_vs $vdata, $vk5]} + addi $keys, $keys, 16 + @{[vle32_v $vk4, $keys]} # rk[19:16] + @{[vsm4r_vs $vdata, $vk4]} + addi $keys, $keys, 16 + @{[vle32_v $vk3, $keys]} # rk[15:11] + @{[vsm4r_vs $vdata, $vk3]} + addi $keys, $keys, 16 + @{[vle32_v $vk2, $keys]} # rk[11:8] + @{[vsm4r_vs $vdata, $vk2]} + addi $keys, $keys, 16 + @{[vle32_v $vk1, $keys]} # rk[7:4] + @{[vsm4r_vs $vdata, $vk1]} + addi $keys, $keys, 16 + @{[vle32_v $vk0, $keys]} # rk[3:0] + @{[vsm4r_vs $vdata, $vk0]} + + # Save the ciphertext (in reverse element order) + @{[vrev8_v $vdata, $vdata]} + li $stride, -4 + addi $out, $out, 12 + @{[vsse32_v $vdata, $out, $stride]} + + ret +.size rv64i_zvksed_sm4_decrypt,.-rv64i_zvksed_sm4_decrypt +___ +} + +$code .= <<___; +# Family Key (little-endian 32-bit chunks) +.p2align 3 +FK: + .word 0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC +.size FK,.-FK +___ + +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 74873C0032E for ; Wed, 25 Oct 2023 18:37:47 +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=T70wbUpkBgPz+7OpuuscG4I8rUSlIaevqjzA9vBYbH4=; b=2h9qkE55RVqCu9 AhC8L2LkQduJPRIkYw1ZhP1WMEFfMdIcQ3N5Lb6DMhQfGg75VCQyYRa0UUKqHj1b817Xv/NJ//OUa aa2dF1xJ44wWcEAvJ+Aqon2czIi7rk05tvKtwmqAkzaJ2v8qfkAhRF9qObmz7pdYpduLqILEnsrRq k1Fnr0r9M4ZBQ7lnDtykZ76YglSz9DBA3oclf39v4ldSr4+9fNNbZl77JP7EWRrTb12HnuBjmupiB jZ+EJ3tKDGJQ4GYZOmyPySdzrlTG6V/zYValh/d744qiDdx7JWM8msMeg+v73Mm2EgSpCOFmZqjrc 9xiwywZEVDggMUAxm1wA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qvilC-00CsVr-1j; Wed, 25 Oct 2023 18:37:42 +0000 Received: from mail-pj1-x102b.google.com ([2607:f8b0:4864:20::102b]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qvil6-00CsQo-34 for linux-riscv@lists.infradead.org; Wed, 25 Oct 2023 18:37:40 +0000 Received: by mail-pj1-x102b.google.com with SMTP id 98e67ed59e1d1-27d1aee5aa1so38849a91.0 for ; Wed, 25 Oct 2023 11:37:36 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1698259056; x=1698863856; 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=HmLKITkx1eSP8gqJH+WnAeHuaVXFpzAB9w+G6AVIsu4=; b=k5x/p9C8Hae1JfB2ct4/K/ucmQsZJf/1DkoKfdV1X9eTCuG7g2o9eH4KMnvyphgw2W Z1P1uZULwMp7fcZea8KEp2MRqx4Qs9GB5d/HzEc7vzUanvAtIGtohALC8nyG/nF4xjfB QwJ1I2Yqx/ispLh4MJQO87rt/nb9jzeVzKWF2D2zPk8ScGfsfzKF9z/QO16tc3lqCvO3 TGqpYU8YLv3RHJyfU1lH0ENntToTiJTZaz3xA2E1qxjggje369JuZKlExB/fqp1gFDd/ v1NlCvIfqnA7FMAdEY608URCh4GZbFL+s1+cuxM26K9qNawsu4W5u9g2IbdeH9fReq68 33Qw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698259056; x=1698863856; 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=HmLKITkx1eSP8gqJH+WnAeHuaVXFpzAB9w+G6AVIsu4=; b=oKRU1wmZQj/Kxwn3yEwr8V8UNQiNMArn7zl9veE3v+GrsHdM7vQWefW1i/uWaXs8/F 5aXf0yW4O8vBOV7gNmSkJWKmbwmAurykHDZMGcvnQRxzjjQez2CrObuFkK4ciATa19/Q 2AFXyo4HRe4abeZsMmPpP8Mi89ymmUfkqV/oXnSFgjV4mXrbHCEhedXghyRrleKInaz4 AyCNFUNFrKrihxui9f9+F+44n1Md1IDAWBEllZSE8AVHchKLkBTEFwPoct7Kr3HAH+LK HVwaf742tLPSpncPi350Yoy2kLFwYSi7JCbHwoL9VdhAstfEMyYxrra0eLcZqgMwHq34 E6Nw== X-Gm-Message-State: AOJu0YwkxxuMAPnyzYIOCzhsdy6If4B5NrgLgLCUtq6BLvAKH0HfwBW7 dqNEtKXhgqTY72ih1M7Ltupd9g== X-Google-Smtp-Source: AGHT+IHzBlS+B5URuxLTQ8oBJy/h5hlYy7abyTtFnLBrnHWfXXOjXLi3op7KwlrM0zcS/751EbwnpQ== X-Received: by 2002:a17:90b:1652:b0:27d:1126:1ff6 with SMTP id il18-20020a17090b165200b0027d11261ff6mr536600pjb.8.1698259056268; Wed, 25 Oct 2023 11:37:36 -0700 (PDT) Received: from localhost.localdomain ([49.216.222.119]) by smtp.gmail.com with ESMTPSA id g3-20020a17090adb0300b00278f1512dd9sm212367pjv.32.2023.10.25.11.37.32 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Wed, 25 Oct 2023 11:37:35 -0700 (PDT) From: Jerry Shih To: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, herbert@gondor.apana.org.au, davem@davemloft.net Cc: andy.chiu@sifive.com, greentime.hu@sifive.com, conor.dooley@microchip.com, guoren@kernel.org, bjorn@rivosinc.com, heiko@sntech.de, ebiggers@kernel.org, ardb@kernel.org, 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 10/12] RISC-V: crypto: add Zvksed accelerated SM4 implementation Date: Thu, 26 Oct 2023 02:36:42 +0800 Message-Id: <20231025183644.8735-11-jerry.shih@sifive.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20231025183644.8735-1-jerry.shih@sifive.com> References: <20231025183644.8735-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-20231025_113736_993311_E23E622F X-CRM114-Status: GOOD ( 28.18 ) 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 QWRkIFNNNCBpbXBsZW1lbnRhdGlvbiB1c2luZyBadmtzZWQgdmVjdG9yIGNyeXB0byBleHRlbnNp b24gZnJvbSBPcGVuU1NMCihvcGVuc3NsL29wZW5zc2wjMjE5MjMpLgoKVGhlIHBlcmxhc20gaGVy ZSBpcyBkaWZmZXJlbnQgZnJvbSB0aGUgb3JpZ2luYWwgaW1wbGVtZW50YXRpb24gaW4gT3BlblNT TC4KSW4gT3BlblNTTCwgU000IGhhcyB0aGUgc2VwYXJhdGVkIHNldF9lbmNyeXB0X2tleSBhbmQg c2V0X2RlY3J5cHRfa2V5CmZ1bmN0aW9ucy4gSW4ga2VybmVsLCB0aGVzZSBzZXRfa2V5IGZ1bmN0 aW9ucyBhcmUgbWVyZ2VkIGludG8gYSBzaW5nbGUKb25lIGluIG9yZGVyIHRvIHNraXAgdGhlIHJl ZHVuZGFudCBrZXkgZXhwYW5kaW5nIGluc3RydWN0aW9ucy4KCkNvLWRldmVsb3BlZC1ieTogQ2hy aXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwuZXU+ClNpZ25lZC1vZmYt Ynk6IENocmlzdG9waCBNw7xsbG5lciA8Y2hyaXN0b3BoLm11ZWxsbmVyQHZydWxsLmV1PgpDby1k ZXZlbG9wZWQtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlrby5zdHVlYm5lckB2cnVsbC5ldT4KU2ln bmVkLW9mZi1ieTogSGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgpTaWdu ZWQtb2ZmLWJ5OiBKZXJyeSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+Ci0tLQogYXJjaC9y aXNjdi9jcnlwdG8vS2NvbmZpZyAgICAgICAgICAgICAgIHwgIDE5ICsrCiBhcmNoL3Jpc2N2L2Ny eXB0by9NYWtlZmlsZSAgICAgICAgICAgICAgfCAgIDcgKwogYXJjaC9yaXNjdi9jcnlwdG8vc200 LXJpc2N2NjQtZ2x1ZS5jICAgIHwgMTIwICsrKysrKysrKysrCiBhcmNoL3Jpc2N2L2NyeXB0by9z bTQtcmlzY3Y2NC16dmtzZWQucGwgfCAyNjggKysrKysrKysrKysrKysrKysrKysrKysrCiA0IGZp bGVzIGNoYW5nZWQsIDQxNCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9y aXNjdi9jcnlwdG8vc200LXJpc2N2NjQtZ2x1ZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9y aXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2VkLnBsCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNj di9jcnlwdG8vS2NvbmZpZyBiL2FyY2gvcmlzY3YvY3J5cHRvL0tjb25maWcKaW5kZXggYTVhMzQ3 NzdkOWMzLi5mZjAwNGFmYTI4NzQgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3YvY3J5cHRvL0tjb25m aWcKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vS2NvbmZpZwpAQCAtNzUsNCArNzUsMjMgQEAgY29u ZmlnIENSWVBUT19TSEE1MTJfUklTQ1Y2NAogCSAgLSBadmtiIHZlY3RvciBjcnlwdG8gZXh0ZW5z aW9uCiAJICAtIFp2a25oYiB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbgogCitjb25maWcgQ1JZUFRP X1NNNF9SSVNDVjY0CisJZGVmYXVsdCB5IGlmIFJJU0NWX0lTQV9WCisJdHJpc3RhdGUgIkNpcGhl cnM6IFNNNCAoU2hhbmdNaSA0KSIKKwlkZXBlbmRzIG9uIDY0QklUICYmIFJJU0NWX0lTQV9WCisJ c2VsZWN0IENSWVBUT19BTEdBUEkKKwlzZWxlY3QgQ1JZUFRPX1NNNAorCXNlbGVjdCBDUllQVE9f U000X0dFTkVSSUMKKwloZWxwCisJICBTTTQgY2lwaGVyIGFsZ29yaXRobXMgKE9TQ0NBIEdCL1Qg MzI5MDctMjAxNiwKKwkgIElTTy9JRUMgMTgwMzMtMzoyMDEwL0FtZCAxOjIwMjEpCisKKwkgIFNN NCAoR0JULjMyOTA3LTIwMTYpIGlzIGEgY3J5cHRvZ3JhcGhpYyBzdGFuZGFyZCBpc3N1ZWQgYnkg dGhlCisJICBPcmdhbml6YXRpb24gb2YgU3RhdGUgQ29tbWVyY2lhbCBBZG1pbmlzdHJhdGlvbiBv ZiBDaGluYSAoT1NDQ0EpCisJICBhcyBhbiBhdXRob3JpemVkIGNyeXB0b2dyYXBoaWMgYWxnb3Jp dGhtcyBmb3IgdGhlIHVzZSB3aXRoaW4gQ2hpbmEuCisKKwkgIEFyY2hpdGVjdHVyZTogcmlzY3Y2 NCB1c2luZzoKKwkgIC0gWnZrYiB2ZWN0b3IgY3J5cHRvIGV4dGVuc2lvbgorCSAgLSBadmtzZWQg dmVjdG9yIGNyeXB0byBleHRlbnNpb24KKwogZW5kbWVudQpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNj di9jcnlwdG8vTWFrZWZpbGUgYi9hcmNoL3Jpc2N2L2NyeXB0by9NYWtlZmlsZQppbmRleCBlYmI0 ZTg2MWViZGMuLmZmYWQwOTVlNTMxZiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9jcnlwdG8vTWFr ZWZpbGUKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vTWFrZWZpbGUKQEAgLTE4LDYgKzE4LDkgQEAg c2hhMjU2LXJpc2N2NjQteSA6PSBzaGEyNTYtcmlzY3Y2NC1nbHVlLm8gc2hhMjU2LXJpc2N2NjQt enZrYi16dmtuaGFfb3JfenZrbmhiLm8KIG9iai0kKENPTkZJR19DUllQVE9fU0hBNTEyX1JJU0NW NjQpICs9IHNoYTUxMi1yaXNjdjY0Lm8KIHNoYTUxMi1yaXNjdjY0LXkgOj0gc2hhNTEyLXJpc2N2 NjQtZ2x1ZS5vIHNoYTUxMi1yaXNjdjY0LXp2a2ItenZrbmhiLm8KIAorb2JqLSQoQ09ORklHX0NS WVBUT19TTTRfUklTQ1Y2NCkgKz0gc200LXJpc2N2NjQubworc200LXJpc2N2NjQteSA6PSBzbTQt cmlzY3Y2NC1nbHVlLm8gc200LXJpc2N2NjQtenZrc2VkLm8KKwogcXVpZXRfY21kX3Blcmxhc20g PSBQRVJMQVNNICRACiAgICAgICBjbWRfcGVybGFzbSA9ICQoUEVSTCkgJCg8KSB2b2lkICQoQCkK IApAQCAtMzksOSArNDIsMTMgQEAgJChvYmopL3NoYTI1Ni1yaXNjdjY0LXp2a2ItenZrbmhhX29y X3p2a25oYi5TOiAkKHNyYykvc2hhMjU2LXJpc2N2NjQtenZrYi16dmtuaGEKICQob2JqKS9zaGE1 MTItcmlzY3Y2NC16dmtiLXp2a25oYi5TOiAkKHNyYykvc2hhNTEyLXJpc2N2NjQtenZrYi16dmtu aGIucGwKIAkkKGNhbGwgY21kLHBlcmxhc20pCiAKKyQob2JqKS9zbTQtcmlzY3Y2NC16dmtzZWQu UzogJChzcmMpL3NtNC1yaXNjdjY0LXp2a3NlZC5wbAorCSQoY2FsbCBjbWQscGVybGFzbSkKKwog Y2xlYW4tZmlsZXMgKz0gYWVzLXJpc2N2NjQtenZrbmVkLlMKIGNsZWFuLWZpbGVzICs9IGFlcy1y aXNjdjY0LXp2YmItenZrZy16dmtuZWQuUwogY2xlYW4tZmlsZXMgKz0gYWVzLXJpc2N2NjQtenZr Yi16dmtuZWQuUwogY2xlYW4tZmlsZXMgKz0gZ2hhc2gtcmlzY3Y2NC16dmtnLlMKIGNsZWFuLWZp bGVzICs9IHNoYTI1Ni1yaXNjdjY0LXp2a2ItenZrbmhhX29yX3p2a25oYi5TCiBjbGVhbi1maWxl cyArPSBzaGE1MTItcmlzY3Y2NC16dmtiLXp2a25oYi5TCitjbGVhbi1maWxlcyArPSBzbTQtcmlz Y3Y2NC16dmtzZWQuUwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQt Z2x1ZS5jIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtZ2x1ZS5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMmQ5OTgzYTRiMWVlCi0tLSAvZGV2L251bGwK KysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtZ2x1ZS5jCkBAIC0wLDAgKzEsMTIw IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisvKgorICogTGlu dXgvcmlzY3Y2NCBwb3J0IG9mIHRoZSBPcGVuU1NMIFNNNCBpbXBsZW1lbnRhdGlvbiBmb3IgUklT Qy1WIDY0CisgKgorICogQ29weXJpZ2h0IChDKSAyMDIzIFZSVUxMIEdtYkgKKyAqIEF1dGhvcjog SGVpa28gU3R1ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgorICoKKyAqIENvcHlyaWdo dCAoQykgMjAyMyBTaUZpdmUsIEluYy4KKyAqIEF1dGhvcjogSmVycnkgU2hpaCA8amVycnkuc2hp aEBzaWZpdmUuY29tPgorICovCisKKyNpbmNsdWRlIDxhc20vc2ltZC5oPgorI2luY2x1ZGUgPGFz bS92ZWN0b3IuaD4KKyNpbmNsdWRlIDxjcnlwdG8vc200Lmg+CisjaW5jbHVkZSA8Y3J5cHRvL2lu dGVybmFsL2NpcGhlci5oPgorI2luY2x1ZGUgPGNyeXB0by9pbnRlcm5hbC9zaW1kLmg+CisjaW5j bHVkZSA8bGludXgvY3J5cHRvLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRl IDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgorCisvKiBzbTQgdXNpbmcgenZrc2VkIHZlY3RvciBjcnlwdG8gZXh0ZW5zaW9u ICovCit2b2lkIHJ2NjRpX3p2a3NlZF9zbTRfZW5jcnlwdChjb25zdCB1OCAqaW4sIHU4ICpvdXQs IGNvbnN0IHUzMiAqa2V5KTsKK3ZvaWQgcnY2NGlfenZrc2VkX3NtNF9kZWNyeXB0KGNvbnN0IHU4 ICppbiwgdTggKm91dCwgY29uc3QgdTMyICprZXkpOworaW50IHJ2NjRpX3p2a3NlZF9zbTRfc2V0 X2tleShjb25zdCB1OCAqdXNlcktleSwgdW5zaWduZWQgaW50IGtleV9sZW4sCisJCQkgICAgIHUz MiAqZW5jX2tleSwgdTMyICpkZWNfa2V5KTsKKworc3RhdGljIGludCByaXNjdjY0X3NtNF9zZXRr ZXlfenZrc2VkKHN0cnVjdCBjcnlwdG9fdGZtICp0Zm0sIGNvbnN0IHU4ICprZXksCisJCQkJICAg ICB1bnNpZ25lZCBpbnQga2V5X2xlbikKK3sKKwlzdHJ1Y3Qgc200X2N0eCAqY3R4ID0gY3J5cHRv X3RmbV9jdHgodGZtKTsKKwlpbnQgcmV0ID0gMDsKKworCWlmIChjcnlwdG9fc2ltZF91c2FibGUo KSkgeworCQlrZXJuZWxfdmVjdG9yX2JlZ2luKCk7CisJCWlmIChydjY0aV96dmtzZWRfc200X3Nl dF9rZXkoa2V5LCBrZXlfbGVuLCBjdHgtPnJrZXlfZW5jLAorCQkJCQkgICAgIGN0eC0+cmtleV9k ZWMpKQorCQkJcmV0ID0gLUVJTlZBTDsKKwkJa2VybmVsX3ZlY3Rvcl9lbmQoKTsKKwl9IGVsc2Ug eworCQlyZXQgPSBzbTRfZXhwYW5ka2V5KGN0eCwga2V5LCBrZXlfbGVuKTsKKwl9CisKKwlyZXR1 cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCByaXNjdjY0X3NtNF9lbmNyeXB0X3p2a3NlZChzdHJ1 Y3QgY3J5cHRvX3RmbSAqdGZtLCB1OCAqZHN0LAorCQkJCSAgICAgICBjb25zdCB1OCAqc3JjKQor eworCWNvbnN0IHN0cnVjdCBzbTRfY3R4ICpjdHggPSBjcnlwdG9fdGZtX2N0eCh0Zm0pOworCisJ aWYgKGNyeXB0b19zaW1kX3VzYWJsZSgpKSB7CisJCWtlcm5lbF92ZWN0b3JfYmVnaW4oKTsKKwkJ cnY2NGlfenZrc2VkX3NtNF9lbmNyeXB0KHNyYywgZHN0LCBjdHgtPnJrZXlfZW5jKTsKKwkJa2Vy bmVsX3ZlY3Rvcl9lbmQoKTsKKwl9IGVsc2UgeworCQlzbTRfY3J5cHRfYmxvY2soY3R4LT5ya2V5 X2VuYywgZHN0LCBzcmMpOworCX0KK30KKworc3RhdGljIHZvaWQgcmlzY3Y2NF9zbTRfZGVjcnlw dF96dmtzZWQoc3RydWN0IGNyeXB0b190Zm0gKnRmbSwgdTggKmRzdCwKKwkJCQkgICAgICAgY29u c3QgdTggKnNyYykKK3sKKwljb25zdCBzdHJ1Y3Qgc200X2N0eCAqY3R4ID0gY3J5cHRvX3RmbV9j dHgodGZtKTsKKworCWlmIChjcnlwdG9fc2ltZF91c2FibGUoKSkgeworCQlrZXJuZWxfdmVjdG9y X2JlZ2luKCk7CisJCXJ2NjRpX3p2a3NlZF9zbTRfZGVjcnlwdChzcmMsIGRzdCwgY3R4LT5ya2V5 X2RlYyk7CisJCWtlcm5lbF92ZWN0b3JfZW5kKCk7CisJfSBlbHNlIHsKKwkJc200X2NyeXB0X2Js b2NrKGN0eC0+cmtleV9kZWMsIGRzdCwgc3JjKTsKKwl9Cit9CisKK3N0cnVjdCBjcnlwdG9fYWxn IHJpc2N2NjRfc200X3p2a3NlZF9hbGcgPSB7CisJLmNyYV9uYW1lID0gInNtNCIsCisJLmNyYV9k cml2ZXJfbmFtZSA9ICJzbTQtcmlzY3Y2NC16dmtiLXp2a3NlZCIsCisJLmNyYV9tb2R1bGUgPSBU SElTX01PRFVMRSwKKwkuY3JhX3ByaW9yaXR5ID0gMzAwLAorCS5jcmFfZmxhZ3MgPSBDUllQVE9f QUxHX1RZUEVfQ0lQSEVSLAorCS5jcmFfYmxvY2tzaXplID0gU000X0JMT0NLX1NJWkUsCisJLmNy YV9jdHhzaXplID0gc2l6ZW9mKHN0cnVjdCBzbTRfY3R4KSwKKwkuY3JhX2NpcGhlciA9IHsKKwkJ LmNpYV9taW5fa2V5c2l6ZSA9IFNNNF9LRVlfU0laRSwKKwkJLmNpYV9tYXhfa2V5c2l6ZSA9IFNN NF9LRVlfU0laRSwKKwkJLmNpYV9zZXRrZXkgPSByaXNjdjY0X3NtNF9zZXRrZXlfenZrc2VkLAor CQkuY2lhX2VuY3J5cHQgPSByaXNjdjY0X3NtNF9lbmNyeXB0X3p2a3NlZCwKKwkJLmNpYV9kZWNy eXB0ID0gcmlzY3Y2NF9zbTRfZGVjcnlwdF96dmtzZWQsCisJfSwKK307CisKK3N0YXRpYyBpbmxp bmUgYm9vbCBjaGVja19zbTRfZXh0KHZvaWQpCit7CisJcmV0dXJuIHJpc2N2X2lzYV9leHRlbnNp b25fYXZhaWxhYmxlKE5VTEwsIFpWS1NFRCkgJiYKKwkgICAgICAgcmlzY3ZfaXNhX2V4dGVuc2lv bl9hdmFpbGFibGUoTlVMTCwgWlZLQikgJiYKKwkgICAgICAgcmlzY3ZfdmVjdG9yX3ZsZW4oKSA+ PSAxMjg7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IHJpc2N2NjRfc200X21vZF9pbml0KHZvaWQp Cit7CisJaWYgKGNoZWNrX3NtNF9leHQoKSkKKwkJcmV0dXJuIGNyeXB0b19yZWdpc3Rlcl9hbGco JnJpc2N2NjRfc200X3p2a3NlZF9hbGcpOworCisJcmV0dXJuIC1FTk9ERVY7Cit9CisKK3N0YXRp YyB2b2lkIF9fZXhpdCByaXNjdjY0X3NtNF9tb2RfZmluaSh2b2lkKQoreworCWlmIChjaGVja19z bTRfZXh0KCkpCisJCWNyeXB0b191bnJlZ2lzdGVyX2FsZygmcmlzY3Y2NF9zbTRfenZrc2VkX2Fs Zyk7Cit9CisKK21vZHVsZV9pbml0KHJpc2N2NjRfc200X21vZF9pbml0KTsKK21vZHVsZV9leGl0 KHJpc2N2NjRfc200X21vZF9maW5pKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJTTTQgKFJJU0Mt ViBhY2NlbGVyYXRlZCkiKTsKK01PRFVMRV9BVVRIT1IoIkhlaWtvIFN0dWVibmVyIDxoZWlrby5z dHVlYm5lckB2cnVsbC5ldT4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BTElB U19DUllQVE8oInNtNCIpOwpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2 NjQtenZrc2VkLnBsIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2VkLnBsCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYTc2NDY2OGM4Mzk4Ci0tLSAv ZGV2L251bGwKKysrIGIvYXJjaC9yaXNjdi9jcnlwdG8vc200LXJpc2N2NjQtenZrc2VkLnBsCkBA IC0wLDAgKzEsMjY4IEBACisjISAvdXNyL2Jpbi9lbnYgcGVybAorIyBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogQXBhY2hlLTIuMCBPUiBCU0QtMi1DbGF1c2UKKyMKKyMgVGhpcyBmaWxlIGlzIGR1 YWwtbGljZW5zZWQsIG1lYW5pbmcgdGhhdCB5b3UgY2FuIHVzZSBpdCB1bmRlciB5b3VyCisjIGNo b2ljZSBvZiBlaXRoZXIgb2YgdGhlIGZvbGxvd2luZyB0d28gbGljZW5zZXM6CisjCisjIENvcHly aWdodCAyMDIzIFRoZSBPcGVuU1NMIFByb2plY3QgQXV0aG9ycy4gQWxsIFJpZ2h0cyBSZXNlcnZl ZC4KKyMKKyMgTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlIDIuMCAodGhlICJMaWNl bnNlIikuIFlvdSBjYW4gb2J0YWluCisjIGEgY29weSBpbiB0aGUgZmlsZSBMSUNFTlNFIGluIHRo ZSBzb3VyY2UgZGlzdHJpYnV0aW9uIG9yIGF0CisjIGh0dHBzOi8vd3d3Lm9wZW5zc2wub3JnL3Nv dXJjZS9saWNlbnNlLmh0bWwKKyMKKyMgb3IKKyMKKyMgQ29weXJpZ2h0IChjKSAyMDIzLCBDaHJp c3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KKyMgQ29weXJpZ2h0 IChjKSAyMDIzLCBKZXJyeSBTaGloIDxqZXJyeS5zaGloQHNpZml2ZS5jb20+CisjIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyMgYXJlIG1ldDoKKyMg MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyMgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorIyAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisjICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlS SUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKworIyBUaGUgZ2VuZXJhdGVkIGNvZGUgb2YgdGhpcyBmaWxlIGRlcGVuZHMgb24gdGhl IGZvbGxvd2luZyBSSVNDLVYgZXh0ZW5zaW9uczoKKyMgLSBSVjY0SQorIyAtIFJJU0MtViBWZWN0 b3IgKCdWJykgd2l0aCBWTEVOID49IDEyOAorIyAtIFJJU0MtViBWZWN0b3IgQ3J5cHRvZ3JhcGh5 IEJpdC1tYW5pcHVsYXRpb24gZXh0ZW5zaW9uICgnWnZrYicpCisjIC0gUklTQy1WIFZlY3RvciBT TTQgQmxvY2sgQ2lwaGVyIGV4dGVuc2lvbiAoJ1p2a3NlZCcpCisKK3VzZSBzdHJpY3Q7Cit1c2Ug d2FybmluZ3M7CisKK3VzZSBGaW5kQmluIHF3KCRCaW4pOwordXNlIGxpYiAiJEJpbiI7Cit1c2Ug bGliICIkQmluLy4uLy4uL3Blcmxhc20iOwordXNlIHJpc2N2OworCisjICRvdXRwdXQgaXMgdGhl IGxhc3QgYXJndW1lbnQgaWYgaXQgbG9va3MgbGlrZSBhIGZpbGUgKGl0IGhhcyBhbiBleHRlbnNp b24pCisjICRmbGF2b3VyIGlzIHRoZSBmaXJzdCBhcmd1bWVudCBpZiBpdCBkb2Vzbid0IGxvb2sg bGlrZSBhIGZpbGUKK215ICRvdXRwdXQgPSAkI0FSR1YgPj0gMCAmJiAkQVJHVlskI0FSR1ZdID1+ IG18XC5cdyskfCA/IHBvcCA6IHVuZGVmOworbXkgJGZsYXZvdXIgPSAkI0FSR1YgPj0gMCAmJiAk QVJHVlswXSAhfiBtfFwufCA/IHNoaWZ0IDogdW5kZWY7CisKKyRvdXRwdXQgYW5kIG9wZW4gU1RE T1VULCI+JG91dHB1dCI7CisKK215ICRjb2RlPTw8X19fOworLnRleHQKK19fXworCisjIyMjCisj IGludCBydjY0aV96dmtzZWRfc200X3NldF9rZXkoY29uc3QgdTggKnVzZXJLZXksIHVuc2lnbmVk IGludCBrZXlfbGVuLAorIwkJCSAgICAgICAgICAgICAgICAgICAgICAgICB1MzIgKmVuY19rZXks IHUzMiAqZGVjX2tleSk7CisjCit7CitteSAoJHVrZXksJGtleV9sZW4sJGVuY19rZXksJGRlY19r ZXkpPSgiYTAiLCJhMSIsImEyIiwiYTMiKTsKK215ICgkZmssJHN0cmlkZSk9KCJhNCIsImE1Iik7 CitteSAoJHQwLCR0MSk9KCJ0MCIsInQxIik7CitteSAoJHZ1a2V5LCR2ZmssJHZrMCwkdmsxLCR2 azIsJHZrMywkdms0LCR2azUsJHZrNiwkdms3KT0oInYxIiwidjIiLCJ2MyIsInY0IiwidjUiLCJ2 NiIsInY3IiwidjgiLCJ2OSIsInYxMCIpOworJGNvZGUgLj0gPDxfX187CisucDJhbGlnbiAzCisu Z2xvYmwgcnY2NGlfenZrc2VkX3NtNF9zZXRfa2V5CisudHlwZSBydjY0aV96dmtzZWRfc200X3Nl dF9rZXksXEBmdW5jdGlvbgorcnY2NGlfenZrc2VkX3NtNF9zZXRfa2V5OgorICAgIGxpICR0MCwg MTYKKyAgICBiZXEgJHQwLCAka2V5X2xlbiwgMWYKKyAgICBsaSBhMCwgMQorICAgIHJldAorMToK KworICAgIEB7W3ZzZXRpdmxpICJ6ZXJvIiwgNCwgImUzMiIsICJtMSIsICJ0YSIsICJtYSJdfQor CisgICAgIyBMb2FkIHRoZSB1c2VyIGtleQorICAgIEB7W3ZsZTMyX3YgJHZ1a2V5LCAkdWtleV19 CisgICAgQHtbdnJldjhfdiAkdnVrZXksICR2dWtleV19CisKKyAgICAjIExvYWQgdGhlIEZLLgor ICAgIGxhICRmaywgRksKKyAgICBAe1t2bGUzMl92ICR2ZmssICRma119CisKKyAgICAjIEdlbmVy YXRlIHJvdW5kIGtleXMuCisgICAgQHtbdnhvcl92diAkdnVrZXksICR2dWtleSwgJHZma119Cisg ICAgQHtbdnNtNGtfdmkgJHZrMCwgJHZ1a2V5LCAwXX0gIyBya1swOjNdCisgICAgQHtbdnNtNGtf dmkgJHZrMSwgJHZrMCwgMV19ICMgcmtbNDo3XQorICAgIEB7W3ZzbTRrX3ZpICR2azIsICR2azEs IDJdfSAjIHJrWzg6MTFdCisgICAgQHtbdnNtNGtfdmkgJHZrMywgJHZrMiwgM119ICMgcmtbMTI6 MTVdCisgICAgQHtbdnNtNGtfdmkgJHZrNCwgJHZrMywgNF19ICMgcmtbMTY6MTldCisgICAgQHtb dnNtNGtfdmkgJHZrNSwgJHZrNCwgNV19ICMgcmtbMjA6MjNdCisgICAgQHtbdnNtNGtfdmkgJHZr NiwgJHZrNSwgNl19ICMgcmtbMjQ6MjddCisgICAgQHtbdnNtNGtfdmkgJHZrNywgJHZrNiwgN119 ICMgcmtbMjg6MzFdCisKKyAgICAjIFN0b3JlIGVuYyByb3VuZCBrZXlzCisgICAgQHtbdnNlMzJf diAkdmswLCAkZW5jX2tleV19ICMgcmtbMDozXQorICAgIGFkZGkgJGVuY19rZXksICRlbmNfa2V5 LCAxNgorICAgIEB7W3ZzZTMyX3YgJHZrMSwgJGVuY19rZXldfSAjIHJrWzQ6N10KKyAgICBhZGRp ICRlbmNfa2V5LCAkZW5jX2tleSwgMTYKKyAgICBAe1t2c2UzMl92ICR2azIsICRlbmNfa2V5XX0g IyBya1s4OjExXQorICAgIGFkZGkgJGVuY19rZXksICRlbmNfa2V5LCAxNgorICAgIEB7W3ZzZTMy X3YgJHZrMywgJGVuY19rZXldfSAjIHJrWzEyOjE1XQorICAgIGFkZGkgJGVuY19rZXksICRlbmNf a2V5LCAxNgorICAgIEB7W3ZzZTMyX3YgJHZrNCwgJGVuY19rZXldfSAjIHJrWzE2OjE5XQorICAg IGFkZGkgJGVuY19rZXksICRlbmNfa2V5LCAxNgorICAgIEB7W3ZzZTMyX3YgJHZrNSwgJGVuY19r ZXldfSAjIHJrWzIwOjIzXQorICAgIGFkZGkgJGVuY19rZXksICRlbmNfa2V5LCAxNgorICAgIEB7 W3ZzZTMyX3YgJHZrNiwgJGVuY19rZXldfSAjIHJrWzI0OjI3XQorICAgIGFkZGkgJGVuY19rZXks ICRlbmNfa2V5LCAxNgorICAgIEB7W3ZzZTMyX3YgJHZrNywgJGVuY19rZXldfSAjIHJrWzI4OjMx XQorCisgICAgIyBTdG9yZSBkZWMgcm91bmQga2V5cyBpbiByZXZlcnNlIG9yZGVyCisgICAgYWRk aSAkZGVjX2tleSwgJGRlY19rZXksIDEyCisgICAgbGkgJHN0cmlkZSwgLTQKKyAgICBAe1t2c3Nl MzJfdiAkdms3LCAkZGVjX2tleSwgJHN0cmlkZV19ICMgcmtbMzE6MjhdCisgICAgYWRkaSAkZGVj X2tleSwgJGRlY19rZXksIDE2CisgICAgQHtbdnNzZTMyX3YgJHZrNiwgJGRlY19rZXksICRzdHJp ZGVdfSAjIHJrWzI3OjI0XQorICAgIGFkZGkgJGRlY19rZXksICRkZWNfa2V5LCAxNgorICAgIEB7 W3Zzc2UzMl92ICR2azUsICRkZWNfa2V5LCAkc3RyaWRlXX0gIyBya1syMzoyMF0KKyAgICBhZGRp ICRkZWNfa2V5LCAkZGVjX2tleSwgMTYKKyAgICBAe1t2c3NlMzJfdiAkdms0LCAkZGVjX2tleSwg JHN0cmlkZV19ICMgcmtbMTk6MTZdCisgICAgYWRkaSAkZGVjX2tleSwgJGRlY19rZXksIDE2Cisg ICAgQHtbdnNzZTMyX3YgJHZrMywgJGRlY19rZXksICRzdHJpZGVdfSAjIHJrWzE1OjEyXQorICAg IGFkZGkgJGRlY19rZXksICRkZWNfa2V5LCAxNgorICAgIEB7W3Zzc2UzMl92ICR2azIsICRkZWNf a2V5LCAkc3RyaWRlXX0gIyBya1sxMTo4XQorICAgIGFkZGkgJGRlY19rZXksICRkZWNfa2V5LCAx NgorICAgIEB7W3Zzc2UzMl92ICR2azEsICRkZWNfa2V5LCAkc3RyaWRlXX0gIyBya1s3OjRdCisg ICAgYWRkaSAkZGVjX2tleSwgJGRlY19rZXksIDE2CisgICAgQHtbdnNzZTMyX3YgJHZrMCwgJGRl Y19rZXksICRzdHJpZGVdfSAjIHJrWzM6MF0KKworICAgIGxpIGEwLCAwCisgICAgcmV0Cisuc2l6 ZSBydjY0aV96dmtzZWRfc200X3NldF9rZXksLi1ydjY0aV96dmtzZWRfc200X3NldF9rZXkKK19f XworfQorCisjIyMjCisjIHZvaWQgcnY2NGlfenZrc2VkX3NtNF9lbmNyeXB0KGNvbnN0IHVuc2ln bmVkIGNoYXIgKmluLCB1bnNpZ25lZCBjaGFyICpvdXQsCisjICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IFNNNF9LRVkgKmtleSk7CisjCit7CitteSAoJGluLCRvdXQsJGtleXMs JHN0cmlkZSk9KCJhMCIsImExIiwiYTIiLCJ0MCIpOworbXkgKCR2ZGF0YSwkdmswLCR2azEsJHZr MiwkdmszLCR2azQsJHZrNSwkdms2LCR2azcsJHZnZW4pPSgidjEiLCJ2MiIsInYzIiwidjQiLCJ2 NSIsInY2IiwidjciLCJ2OCIsInY5IiwidjEwIik7CiskY29kZSAuPSA8PF9fXzsKKy5wMmFsaWdu IDMKKy5nbG9ibCBydjY0aV96dmtzZWRfc200X2VuY3J5cHQKKy50eXBlIHJ2NjRpX3p2a3NlZF9z bTRfZW5jcnlwdCxcQGZ1bmN0aW9uCitydjY0aV96dmtzZWRfc200X2VuY3J5cHQ6CisgICAgQHtb dnNldGl2bGkgInplcm8iLCA0LCAiZTMyIiwgIm0xIiwgInRhIiwgIm1hIl19CisKKyAgICAjIExv YWQgaW5wdXQgZGF0YQorICAgIEB7W3ZsZTMyX3YgJHZkYXRhLCAkaW5dfQorICAgIEB7W3ZyZXY4 X3YgJHZkYXRhLCAkdmRhdGFdfQorCisgICAgIyBPcmRlciBvZiBlbGVtZW50cyB3YXMgYWRqdXN0 ZWQgaW4gc200X3NldF9rZXkoKQorICAgICMgRW5jcnlwdCB3aXRoIGFsbCBrZXlzCisgICAgQHtb dmxlMzJfdiAkdmswLCAka2V5c119ICMgcmtbMDozXQorICAgIEB7W3ZzbTRyX3ZzICR2ZGF0YSwg JHZrMF19CisgICAgYWRkaSAka2V5cywgJGtleXMsIDE2CisgICAgQHtbdmxlMzJfdiAkdmsxLCAk a2V5c119ICMgcmtbNDo3XQorICAgIEB7W3ZzbTRyX3ZzICR2ZGF0YSwgJHZrMV19CisgICAgYWRk aSAka2V5cywgJGtleXMsIDE2CisgICAgQHtbdmxlMzJfdiAkdmsyLCAka2V5c119ICMgcmtbODox MV0KKyAgICBAe1t2c200cl92cyAkdmRhdGEsICR2azJdfQorICAgIGFkZGkgJGtleXMsICRrZXlz LCAxNgorICAgIEB7W3ZsZTMyX3YgJHZrMywgJGtleXNdfSAjIHJrWzEyOjE1XQorICAgIEB7W3Zz bTRyX3ZzICR2ZGF0YSwgJHZrM119CisgICAgYWRkaSAka2V5cywgJGtleXMsIDE2CisgICAgQHtb dmxlMzJfdiAkdms0LCAka2V5c119ICMgcmtbMTY6MTldCisgICAgQHtbdnNtNHJfdnMgJHZkYXRh LCAkdms0XX0KKyAgICBhZGRpICRrZXlzLCAka2V5cywgMTYKKyAgICBAe1t2bGUzMl92ICR2azUs ICRrZXlzXX0gIyBya1syMDoyM10KKyAgICBAe1t2c200cl92cyAkdmRhdGEsICR2azVdfQorICAg IGFkZGkgJGtleXMsICRrZXlzLCAxNgorICAgIEB7W3ZsZTMyX3YgJHZrNiwgJGtleXNdfSAjIHJr WzI0OjI3XQorICAgIEB7W3ZzbTRyX3ZzICR2ZGF0YSwgJHZrNl19CisgICAgYWRkaSAka2V5cywg JGtleXMsIDE2CisgICAgQHtbdmxlMzJfdiAkdms3LCAka2V5c119ICMgcmtbMjg6MzFdCisgICAg QHtbdnNtNHJfdnMgJHZkYXRhLCAkdms3XX0KKworICAgICMgU2F2ZSB0aGUgY2lwaGVydGV4dCAo aW4gcmV2ZXJzZSBlbGVtZW50IG9yZGVyKQorICAgIEB7W3ZyZXY4X3YgJHZkYXRhLCAkdmRhdGFd fQorICAgIGxpICRzdHJpZGUsIC00CisgICAgYWRkaSAkb3V0LCAkb3V0LCAxMgorICAgIEB7W3Zz c2UzMl92ICR2ZGF0YSwgJG91dCwgJHN0cmlkZV19CisKKyAgICByZXQKKy5zaXplIHJ2NjRpX3p2 a3NlZF9zbTRfZW5jcnlwdCwuLXJ2NjRpX3p2a3NlZF9zbTRfZW5jcnlwdAorX19fCit9CisKKyMj IyMKKyMgdm9pZCBydjY0aV96dmtzZWRfc200X2RlY3J5cHQoY29uc3QgdW5zaWduZWQgY2hhciAq aW4sIHVuc2lnbmVkIGNoYXIgKm91dCwKKyMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3QgU000X0tFWSAqa2V5KTsKKyMKK3sKK215ICgkaW4sJG91dCwka2V5cywkc3RyaWRlKT0o ImEwIiwiYTEiLCJhMiIsInQwIik7CitteSAoJHZkYXRhLCR2azAsJHZrMSwkdmsyLCR2azMsJHZr NCwkdms1LCR2azYsJHZrNywkdmdlbik9KCJ2MSIsInYyIiwidjMiLCJ2NCIsInY1IiwidjYiLCJ2 NyIsInY4IiwidjkiLCJ2MTAiKTsKKyRjb2RlIC49IDw8X19fOworLnAyYWxpZ24gMworLmdsb2Js IHJ2NjRpX3p2a3NlZF9zbTRfZGVjcnlwdAorLnR5cGUgcnY2NGlfenZrc2VkX3NtNF9kZWNyeXB0 LFxAZnVuY3Rpb24KK3J2NjRpX3p2a3NlZF9zbTRfZGVjcnlwdDoKKyAgICBAe1t2c2V0aXZsaSAi emVybyIsIDQsICJlMzIiLCAibTEiLCAidGEiLCAibWEiXX0KKworICAgICMgTG9hZCBpbnB1dCBk YXRhCisgICAgQHtbdmxlMzJfdiAkdmRhdGEsICRpbl19CisgICAgQHtbdnJldjhfdiAkdmRhdGEs ICR2ZGF0YV19CisKKyAgICAjIE9yZGVyIG9mIGtleSBlbGVtZW50cyB3YXMgYWRqdXN0ZWQgaW4g c200X3NldF9rZXkoKQorICAgICMgRGVjcnlwdCB3aXRoIGFsbCBrZXlzCisgICAgQHtbdmxlMzJf diAkdms3LCAka2V5c119ICMgcmtbMzE6MjhdCisgICAgQHtbdnNtNHJfdnMgJHZkYXRhLCAkdms3 XX0KKyAgICBhZGRpICRrZXlzLCAka2V5cywgMTYKKyAgICBAe1t2bGUzMl92ICR2azYsICRrZXlz XX0gIyBya1syNzoyNF0KKyAgICBAe1t2c200cl92cyAkdmRhdGEsICR2azZdfQorICAgIGFkZGkg JGtleXMsICRrZXlzLCAxNgorICAgIEB7W3ZsZTMyX3YgJHZrNSwgJGtleXNdfSAjIHJrWzIzOjIw XQorICAgIEB7W3ZzbTRyX3ZzICR2ZGF0YSwgJHZrNV19CisgICAgYWRkaSAka2V5cywgJGtleXMs IDE2CisgICAgQHtbdmxlMzJfdiAkdms0LCAka2V5c119ICMgcmtbMTk6MTZdCisgICAgQHtbdnNt NHJfdnMgJHZkYXRhLCAkdms0XX0KKyAgICBhZGRpICRrZXlzLCAka2V5cywgMTYKKyAgICBAe1t2 bGUzMl92ICR2azMsICRrZXlzXX0gIyBya1sxNToxMV0KKyAgICBAe1t2c200cl92cyAkdmRhdGEs ICR2azNdfQorICAgIGFkZGkgJGtleXMsICRrZXlzLCAxNgorICAgIEB7W3ZsZTMyX3YgJHZrMiwg JGtleXNdfSAjIHJrWzExOjhdCisgICAgQHtbdnNtNHJfdnMgJHZkYXRhLCAkdmsyXX0KKyAgICBh ZGRpICRrZXlzLCAka2V5cywgMTYKKyAgICBAe1t2bGUzMl92ICR2azEsICRrZXlzXX0gIyBya1s3 OjRdCisgICAgQHtbdnNtNHJfdnMgJHZkYXRhLCAkdmsxXX0KKyAgICBhZGRpICRrZXlzLCAka2V5 cywgMTYKKyAgICBAe1t2bGUzMl92ICR2azAsICRrZXlzXX0gIyBya1szOjBdCisgICAgQHtbdnNt NHJfdnMgJHZkYXRhLCAkdmswXX0KKworICAgICMgU2F2ZSB0aGUgY2lwaGVydGV4dCAoaW4gcmV2 ZXJzZSBlbGVtZW50IG9yZGVyKQorICAgIEB7W3ZyZXY4X3YgJHZkYXRhLCAkdmRhdGFdfQorICAg IGxpICRzdHJpZGUsIC00CisgICAgYWRkaSAkb3V0LCAkb3V0LCAxMgorICAgIEB7W3Zzc2UzMl92 ICR2ZGF0YSwgJG91dCwgJHN0cmlkZV19CisKKyAgICByZXQKKy5zaXplIHJ2NjRpX3p2a3NlZF9z bTRfZGVjcnlwdCwuLXJ2NjRpX3p2a3NlZF9zbTRfZGVjcnlwdAorX19fCit9CisKKyRjb2RlIC49 IDw8X19fOworIyBGYW1pbHkgS2V5IChsaXR0bGUtZW5kaWFuIDMyLWJpdCBjaHVua3MpCisucDJh bGlnbiAzCitGSzoKKyAgICAud29yZCAweEEzQjFCQUM2LCAweDU2QUEzMzUwLCAweDY3N0Q5MTk3 LCAweEIyNzAyMkRDCisuc2l6ZSBGSywuLUZLCitfX18KKworcHJpbnQgJGNvZGU7CisKK2Nsb3Nl IFNURE9VVCBvciBkaWUgImVycm9yIGNsb3NpbmcgU1RET1VUOiAkISI7Ci0tIAoyLjI4LjAKCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNj diBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlz dHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==