Got signing using the TPM working.

crates/.vscode/settings.json

@@ -3,16 +3,17 @@
         "Asym",
         "blocktree",
         "bodhi",
+        "Creds",
         "Crypter",
         "Cryptotext",
-        "Decryptor",
-        "Encryptor",
         "decrypter",
+        "Decryptor",
         "encrypter",
+        "Encryptor",
         "Hashable",
         "newtype",
-        "pkey",
         "PKCS",
+        "pkey",
         "readcap",
         "readcaps",
         "writecap",

crates/btnode/Cargo.lock

@@ -69,6 +69,7 @@ dependencies = [
  "serde-block-tree",
  "strum",
  "strum_macros",
+ "tempdir",
  "tss-esapi",
  "tss-esapi-sys",
 ]
@@ -133,6 +134,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
+[[package]]
+name = "fuchsia-cprng"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
+
 [[package]]
 name = "harness"
 version = "0.0.1"
@@ -353,6 +360,43 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "rand"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
+dependencies = [
+ "fuchsia-cprng",
+ "libc",
+ "rand_core 0.3.1",
+ "rdrand",
+ "winapi",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
+dependencies = [
+ "rand_core 0.4.2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
+
+[[package]]
+name = "rdrand"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
+dependencies = [
+ "rand_core 0.3.1",
+]
+
 [[package]]
 name = "regex"
 version = "1.6.0"
@@ -370,6 +414,15 @@ version = "0.6.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
 
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "rustc_version"
 version = "0.3.3"
@@ -506,6 +559,16 @@ version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c02424087780c9b71cc96799eaeddff35af2bc513278cda5c99fc1f5d026d3c1"
 
+[[package]]
+name = "tempdir"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
+dependencies = [
+ "rand",
+ "remove_dir_all",
+]
+
 [[package]]
 name = "termcolor"
 version = "1.1.3"

crates/btnode/Cargo.toml

@@ -18,4 +18,7 @@ strum_macros = { version = "^0.24.0" }
 env_logger = "0.9.0"
 log = "0.4.17"
 tss-esapi = "7.1.0"
-tss-esapi-sys = "0.3.0"
+tss-esapi-sys = "0.3.0"
+
+[dev-dependencies]
+tempdir = "0.3.7"

crates/btnode/scripts/swtpm.sh

@@ -6,11 +6,13 @@ set -e
 # The name of the virtual TPM device. This will determine the name of the device under /dev.
 TPM_NAME=vtpm0
 # The path to the directory where the TPM's state will be stored.
-export TPM_PATH=/tmp/$TPM_NAME
-# The name of the user to run swtpm as.
-TPM_USER=tss
+TPM_PATH=/tmp/$TPM_NAME
 # The file where swtpm's pid will be stored.
 TPM_PID=$TPM_PATH/swtpm.pid
+# The file where tpm2-abrmd's pid will be stored.
+TPM_ABRMD_PID=$TPM_PATH/tpm2-abrmd.pid
+TPM_ADDR=127.0.0.1
+TPM_PORT=2321
 
 setup() {
     mkdir -p $TPM_PATH
@@ -26,11 +28,18 @@ start() {
         echo "swtpm is already running with PID $(cat $TPM_PID)."
         exit 1
     fi
-    sudo swtpm cuse --name $TPM_NAME --tpm2 --log file=$TPM_PATH/log.txt,level=5 \
+    swtpm socket --server type=tcp,port=$TPM_PORT,bindaddr=$TPM_ADDR \
+        --ctrl type=tcp,port=$(($TPM_PORT + 1)),bindaddr=$TPM_ADDR \
+        --tpm2 --log file=$TPM_PATH/log.txt,level=5 \
         --flags not-need-init,startup-clear --pid file=$TPM_PID \
-        --runas $TPM_USER --tpmstate dir=$TPM_PATH
-    sudo chown :$TPM_USER /dev/$TPM_NAME
-    sudo chmod 0660 /dev/$TPM_NAME
+        --tpmstate dir=$TPM_PATH --daemon
+    tpm2-abrmd --tcti="swtpm:host=$TPM_ADDR" --session &
+    echo -n $! > $TPM_ABRMD_PID
+}
+
+kill_from_file() {
+    pid=$(cat $1)
+    kill -s TERM $pid
 }
 
 stop() {
@@ -38,19 +47,41 @@ stop() {
         echo "swtpm is not running."
         exit 1
     fi
-    pid=$(cat $TPM_PID)
-    sudo rm $TPM_PID
-    sudo kill -SIGTERM $pid
+    kill_from_file $TPM_ABRMD_PID
+    rm $TPM_ABRMD_PID
+    kill_from_file $TPM_PID
+}
+
+restart() {
+    stop
+    start
+}
+
+purge() {
+    if [ -f $TPM_PID ]; then
+        stop
+    fi
+    rm -rf $TPM_PATH
 }
 
 usage() {
-    echo "${0} <start|stop>"
+    echo "${0} <start|stop|restart>"
 }
 
-if [ "${1}" = start ]; then
-    start
-elif [ "${1}" = stop ]; then
-    stop
-else
-    usage
-fi
+case "${1}" in
+    start)
+        start
+        ;;
+    stop) 
+        stop
+        ;;
+    restart)
+        restart
+        ;;
+    purge)
+        purge
+        ;;
+    *)
+        usage
+        ;;
+esac

crates/btnode/src/crypto/mod.rs

@@ -6,7 +6,7 @@ use super::*;
 
 use openssl::{
     error::ErrorStack,
-    encrypt::{Encrypter, Decrypter},
+    encrypt::{Encrypter as OsslEncrypter, Decrypter as OsslDecrypter},
     pkey::{PKey, Public, Private},
     symm::{Cipher, encrypt as openssl_encrypt, decrypt as openssl_decrypt},
     rand::rand_bytes,
@@ -161,7 +161,7 @@ impl Display for Hash {
     }
 }
 
-const RSA_SIG_LEN: usize = 512;
+pub(crate) const RSA_SIG_LEN: usize = 384;
 
 /// A cryptographic signature.
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone, EnumDiscriminants)]
@@ -393,9 +393,9 @@ impl RsaPriv {
     }
 }
 
-impl Decryptor for RsaPriv {
+impl Decrypter for RsaPriv {
     fn decrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
-        let decrypter = Decrypter::new(&self.pkey).map_err(Error::from)?;
+        let decrypter = OsslDecrypter::new(&self.pkey).map_err(Error::from)?;
         let buffer_len = decrypter.decrypt_len(slice).map_err(Error::from)?;
         let mut plaintext = vec![0; buffer_len];
         let plaintext_len = decrypter.decrypt(slice, &mut plaintext).map_err(Error::from)?;
@@ -405,7 +405,7 @@ impl Decryptor for RsaPriv {
 }
 
 impl Signer for RsaPriv {
-    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: &mut I) -> Result<Signature> {
+    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: I) -> Result<Signature> {
         let digest = RsaPriv::digest();
         let mut signature = RsaPriv::signature_buf();
 
@@ -435,7 +435,8 @@ impl<T: CredsPriv> ConcreteCreds<T> {
 
 impl ConcreteCreds<RsaPriv> {
     pub(crate) fn generate() -> Result<ConcreteCreds<RsaPriv>> {
-        let key = Rsa::generate(4096)?;
+        let key_bits = 8 * u32::try_from(RSA_SIG_LEN).map_err(|e| Error::Message(e.to_string()))?;
+        let key = Rsa::generate(key_bits)?;
         // TODO: Separating the keys this way seems inefficient. Investigate alternatives.
         let public_der = key.public_key_to_der().map_err(Error::from)?;
         let private_der = key.private_key_to_der().map_err(Error::from)?;
@@ -452,7 +453,7 @@ impl<T: CredsPriv> Verifier for ConcreteCreds<T> {
     }
 }
 
-impl<T: CredsPriv> Encryptor for ConcreteCreds<T> {
+impl<T: CredsPriv> Encrypter for ConcreteCreds<T> {
     fn encrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
         self.public.encrypt(slice)
     }
@@ -467,12 +468,12 @@ impl<T: CredsPriv> Owned for ConcreteCreds<T> {
 impl<T: CredsPriv> CredsPub for ConcreteCreds<T> {}
 
 impl<T: CredsPriv> Signer for ConcreteCreds<T> {
-    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: &mut I) -> Result<Signature> {
+    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: I) -> Result<Signature> {
         self.private.sign(parts)
     }
 }
 
-impl<T: CredsPriv> Decryptor for ConcreteCreds<T> {
+impl<T: CredsPriv> Decrypter for ConcreteCreds<T> {
     fn decrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
         self.private.decrypt(slice)
     }
@@ -486,20 +487,20 @@ impl<T: CredsPriv> Creds for ConcreteCreds<T> {
     }
 }
 
-pub(crate) trait Encryptor {
+pub(crate) trait Encrypter {
     fn encrypt(&self, slice: &[u8]) -> Result<Vec<u8>>;
 }
 
-impl Encryptor for SymKey {
+impl Encrypter for SymKey {
     fn encrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
         let SymParams { cipher, key, iv } = self.params();
         openssl_encrypt(cipher, key, iv, slice).map_err(Error::from)
     }
 }
 
-impl Encryptor for AsymKeyPub {
+impl Encrypter for AsymKeyPub {
     fn encrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
-        let mut encrypter = Encrypter::new(&self.pkey).map_err(Error::from)?;
+        let mut encrypter = OsslEncrypter::new(&self.pkey).map_err(Error::from)?;
         if let Some(padding) = self.padding() {
             encrypter.set_rsa_padding(padding).map_err(Error::from)?;
         }
@@ -512,11 +513,11 @@ impl Encryptor for AsymKeyPub {
     }
 }
 
-pub(crate) trait Decryptor {
+pub(crate) trait Decrypter {
     fn decrypt(&self, slice: &[u8]) -> Result<Vec<u8>>;
 }
 
-impl Decryptor for SymKey {
+impl Decrypter for SymKey {
     fn decrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
         let SymParams { cipher, key, iv } = self.params();
         openssl_decrypt(cipher, key, iv, slice).map_err(Error::from)
@@ -524,7 +525,7 @@ impl Decryptor for SymKey {
 }
 
 pub(crate) trait Signer {
-    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: &mut I) -> Result<Signature>;
+    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: I) -> Result<Signature>;
 }
 
 pub(crate) trait Verifier {
@@ -542,10 +543,10 @@ impl Verifier for AsymKeyPub {
 }
 
 /// Trait for types which can be used as public credentials.
-pub(crate) trait CredsPub: Verifier + Encryptor + Owned {}
+pub(crate) trait CredsPub: Verifier + Encrypter + Owned {}
 
 /// Trait for types which contain private credentials.
-pub(crate) trait CredsPriv: Decryptor + Signer {}
+pub(crate) trait CredsPriv: Decrypter + Signer {}
 
 /// Trait for types which contain both public and private credentials.
 pub(crate) trait Creds: CredsPriv + CredsPub {
@@ -561,10 +562,10 @@ pub(crate) trait CredStore {
     fn node_creds(&self) -> Result<&Self::CredHandle>;
     /// Returns the root credentials. If no root credentials have been generated, or the provided
     /// password is incorrect, then an error is returned.
-    fn root_creds(&self, password: &str) -> Result<&Self::CredHandle>;
+    fn root_creds<'a>(&'a self, password: &str) -> Result<&'a Self::CredHandle>;
     /// Generates the root crednetials and protects them using the given password. If the root
     /// credentials have already been generated then an error is returned.
-    fn gen_root_creds(&self, password: &str) -> Result<&Self::CredHandle>;
+    fn gen_root_creds<'a>(&'a self, password: &str) -> Result<&'a Self::CredHandle>;
 }
 
 pub(crate) fn encrypt_block<C: Creds>(
@@ -599,7 +600,7 @@ pub(crate) fn decrypt_block<K: CredsPriv>(
     Ok(block)
 }
 
-fn encrypt<T: Serialize, K: Encryptor>(value: &T, key: &K) -> Result<Cryptotext<T>> {
+fn encrypt<T: Serialize, K: Encrypter>(value: &T, key: &K) -> Result<Cryptotext<T>> {
     let data = to_vec(value).map_err(Error::from)?;
     let vec = key.encrypt(&data);
     Ok(Cryptotext::Cipher(vec?))
@@ -650,7 +651,7 @@ pub(crate) fn sign_block<K: Signer>(
     let body = get_body(block)?;
     let sig_input = HeaderSigInput::from(&*block);
     let header = to_vec(&sig_input)?;
-    let signature = priv_key.sign(&mut [header.as_slice(), body].into_iter())?;
+    let signature = priv_key.sign([header.as_slice(), body].into_iter())?;
     block.signature = signature;
     Ok(())
 }
@@ -684,7 +685,7 @@ impl<'a> From<&'a Writecap> for WritecapSigInput<'a> {
 
 pub(crate) fn sign_writecap<K: Signer>(writecap: &mut Writecap, priv_key: &K) -> Result<()> {
     let sig_input = to_vec(&WritecapSigInput::from(&*writecap))?;
-    writecap.signature = priv_key.sign(&mut [sig_input.as_slice()].into_iter())?;
+    writecap.signature = priv_key.sign([sig_input.as_slice()].into_iter())?;
     Ok(())
 }
 
@@ -798,7 +799,7 @@ mod tests {
         let key = make_key_pair();
         let header = b"About: lyrics".as_slice();
         let message = b"Everything that feels so good is bad bad bad.".as_slice();
-        let signature = key.sign(&mut [header, message].into_iter())?;
+        let signature = key.sign([header, message].into_iter())?;
         let verified = key.verify([header, message].into_iter(), signature.as_slice())?;
         assert_eq!(true, verified);
         Ok(())
@@ -961,7 +962,7 @@ mod tests {
         #[test]
         fn rsa_signature_len() -> Result<()> {
             let key = make_key_pair();
-            let signature = key.sign(&mut [NODE_PUBLIC_KEY.as_slice()].into_iter())?;
+            let signature = key.sign([NODE_PUBLIC_KEY.as_slice()].into_iter())?;
             let length = match signature {
                 Signature::Rsa(data) => data.len(),
             };

crates/btnode/src/crypto/tpm.rs

@@ -1,78 +1,348 @@
-use super::{
-    Error,
-    Result,
-    rand_array,
-};
+use super::*;
 
 use std::{
     io::{Read, Write},
-    os::raw::c_char,
+    os::{
+        raw::c_char,
+        unix::fs::PermissionsExt,
+    },
     ffi::CStr, path::{Path},
-    fs::{OpenOptions}
+    fs::{File, OpenOptions},
+    sync::{Arc, Mutex},
+};
+use openssl::{bn::BigNum, hash::Hasher, nid::Nid};
+use tss_esapi_sys::{TSS2_RC, TPMT_TK_HASHCHECK };
+use tss_esapi::{
+    Context,
+    constants::{
+        session_type::SessionType,
+        response_code::Tss2ResponseCode,
+        tss::TPM2_RH_NULL,
+    },
+    tcti_ldr::{TctiNameConf, TabrmdConfig},
+    interface_types::{
+        resource_handles::Hierarchy,
+        algorithm::HashingAlgorithm,
+        key_bits::RsaKeyBits,
+    },
+    structures::{
+        Digest,
+        HashScheme,
+        Public,
+        PublicRsaParameters,
+        SymmetricDefinition,
+        SymmetricDefinitionObject,
+        PublicKeyRsa,
+        RsaScheme,
+        RsaExponent,
+        HashcheckTicket,
+        Ticket,
+        SignatureScheme,
+    },
+    attributes::{
+        object::ObjectAttributes,
+    },
+    handles::KeyHandle,
 };
-use tss_esapi::{constants::response_code::Tss2ResponseCode};
-use tss_esapi_sys::TSS2_RC;
-    use core::str::FromStr;
-    use tss_esapi::{
-        Context,
-        constants::{
-            session_type::{SessionType},
-        },
-        tcti_ldr::{DeviceConfig, TctiNameConf, TabrmdConfig},
-        interface_types::{
-            resource_handles::{Hierarchy},
-            algorithm::{HashingAlgorithm},
-            ecc::{EccCurve},
-        },
-        structures::{
-            Digest,
-            EccPoint,
-            EccScheme,
-            KeyDerivationFunctionScheme,
-            HashScheme,
-            Public,
-            PublicEccParameters,
-            SymmetricDefinition,
-            SymmetricDefinitionObject,
-        },
-        attributes::{
-            object::{ObjectAttributes},
-        },
-    };
 
+const COOKIE_LEN: usize = RSA_SIG_LEN;
 
-const COOKIE_LEN: usize = 64;
-type Cookie = [u8; COOKIE_LEN];
+struct Cookie([u8; COOKIE_LEN]);
 
-pub(crate) struct TpmCredStore {
-    context: Context,
-    cookie: Cookie,
-}
+impl Cookie {
+    fn random() -> Result<Cookie> {
+        Ok(Cookie(rand_array()?))
+    }
 
-impl TpmCredStore {
-    fn new<P: AsRef<Path>>(tpm_path: &str, cookie_path: P) -> Result<TpmCredStore> {
-        let config = TctiNameConf::Device(DeviceConfig::from_str(tpm_path).unwrap());
-        let context = Context::new(config)
-            .tss2_expect("Failed to create context");
+    fn empty() -> Cookie {
+        Cookie([0; COOKIE_LEN])
+    }
+
+    fn load_or_init<P: AsRef<Path>>(cookie_path: P) -> Result<Cookie> {
         let cookie = match OpenOptions::new().read(true).open(&cookie_path) {
             Ok(mut file) => {
-                let mut cookie: Cookie = [0; COOKIE_LEN];
-                file.read_exact(cookie.as_mut_slice()).map_err(Error::from)?;
-                cookie
+                Cookie::load(&mut file)?
             },
-            Err(other) => {
-                if std::io::ErrorKind::NotFound != other.kind() {
-                    return Err(Error::from(other));
+            Err(error) => {
+                if std::io::ErrorKind::NotFound != error.kind() {
+                    return Err(Error::from(error));
                 }
-                let cookie: Cookie = rand_array()?;
+                let cookie = Cookie::random()?;
                 let mut file = OpenOptions::new().write(true).create_new(true).open(&cookie_path)
                     .map_err(Error::from)?;
-                file.write_all(cookie.as_slice()).map_err(Error::from)?;
+                cookie.save(&mut file)?; 
                 cookie
             }
         };
+        Ok(cookie)
+    }
+
+    fn as_slice(&self) -> &[u8] {
+        self.0.as_slice()
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        self.0.as_mut_slice()
+    }
+
+    fn save(&self, to: &mut File) -> Result<()> {
+        to.write_all(self.as_slice()).map_err(Error::from)?;
+        // Only allow read access from the current user.
+        let metadata = to.metadata().map_err(Error::from)?;
+        let mut permissions = metadata.permissions();
+        permissions.set_mode(0o400);
+        to.set_permissions(permissions).map_err(Error::from)?;
+        Ok(())
+    }
+
+    fn load(from: &mut File) -> Result<Cookie> {
+        let mut cookie = Cookie::empty();
+        from.read_exact(cookie.as_mut_slice()).map_err(Error::from)?;
+        Ok(cookie)
+    }
+}
+
+pub(crate) struct TpmCredStore {
+    context: Arc<Mutex<Context>>,
+    cookie: Cookie,
+}
+
+impl TpmCredStore {
+    pub(crate) fn new<P: AsRef<Path>>(
+        mut context: Context, cookie_path: P
+    ) -> Result<TpmCredStore> {
+        let cookie = Cookie::load_or_init(cookie_path)?;
+        let session = context.start_auth_session(
+            None,
+            None,
+            None,
+            SessionType::Hmac,
+            SymmetricDefinition::AES_256_CFB,
+            HashingAlgorithm::Sha256,
+        )
+        .map_err(Error::from)?
+        .ok_or_else(|| Error::Message("Received invalid session handle".to_string()))?;
+        context.set_sessions((Some(session), None, None));
+        let context = Arc::new(Mutex::new(context));
         Ok(TpmCredStore { context, cookie })
     }
+
+    fn gen_node_creds(&self) -> Result<TpmCreds> {
+        const RSA_EXPONENT: u32 = 65537; // 2**16 + 1
+        let template = {
+            let object_attributes = ObjectAttributes::builder()
+                .with_fixed_tpm(true)
+                .with_fixed_parent(true)
+                .with_sensitive_data_origin(true)
+                .with_user_with_auth(true)
+                .with_decrypt(true)
+                .with_sign_encrypt(true)
+                .with_restricted(false)
+                .build()
+                .map_err(Error::from)?;
+            let name_hashing_algorithm = HashingAlgorithm::Sha256;
+            let empty = [0u8; 0];
+            let auth_policy = Digest::try_from(empty.as_slice()).map_err(Error::from)?;
+            let parameters = PublicRsaParameters::new(
+                SymmetricDefinitionObject::Null,
+                RsaScheme::Null,
+                RsaKeyBits::Rsa3072,
+                RsaExponent::try_from(RSA_EXPONENT).map_err(Error::from)?, 
+            );
+            let unique = PublicKeyRsa::try_from(self.cookie.as_slice())
+                .map_err(|e| Error::Message(e.to_string()))?;
+            Public::Rsa {
+                object_attributes,
+                name_hashing_algorithm,
+                auth_policy,
+                parameters,
+                unique,
+            }
+        };
+        let result = {
+            let mut lock = self.context.lock().map_err(|e| Error::Message(e.to_string()))?;
+            lock.create_primary(
+                Hierarchy::Endorsement,
+                template,
+                None,
+                None,
+                None,
+                None,
+            )
+            .map_err(Error::from)?
+        };
+        let public = match result.out_public {
+            Public::Rsa { parameters, unique, .. } => {
+                let exponent_value = parameters.exponent().value();
+                let exponent = BigNum::from_u32(exponent_value).map_err(Error::from)?;
+                let modulus = BigNum::from_slice(unique.as_slice()).map_err(Error::from)?;
+                let rsa = Rsa::from_public_components(modulus, exponent).map_err(Error::from)?;
+                let pkey = PKey::from_rsa(rsa).map_err(Error::from)?;
+                AsymKeyPub { pkey, kind: AsymKeyKind::Rsa }
+            },
+            _ => return Err(Error::Message("Unexpected key type returned by TPM".to_string())),
+        };
+
+        Ok(TpmCreds { public, handle: result.key_handle , context: self.context.clone() })
+    }
+}
+
+trait NidExt {
+    fn sha3_256() -> Nid {
+        Nid::from_raw(1097)
+    }
+
+    fn sha3_384() -> Nid {
+        Nid::from_raw(1098)
+    }
+
+    fn sha3_512() -> Nid {
+        Nid::from_raw(1099)
+    }
+}
+
+impl NidExt for Nid {}
+
+trait MessageDigestExt {
+    fn hash_algo(&self) -> Result<HashingAlgorithm>;
+    fn hash_scheme(&self) -> Result<HashScheme> {
+        Ok(HashScheme::new(self.hash_algo()?))
+    }
+}
+
+impl MessageDigestExt for MessageDigest {
+    fn hash_algo(&self) -> Result<HashingAlgorithm> {
+        let nid = self.type_();
+        let algo =
+            if Nid::SHA1 == nid {
+                HashingAlgorithm::Sha1
+            }
+            else if Nid::SHA256 == nid {
+                HashingAlgorithm::Sha256
+            }
+            else if Nid::SHA384 == nid {
+                HashingAlgorithm::Sha384
+            }
+            else if Nid::SHA512 == nid {
+                HashingAlgorithm::Sha512
+            }
+            else if Nid::sha3_256() == nid {
+                HashingAlgorithm::Sha3_256
+            }
+            else if Nid::sha3_384() == nid {
+                HashingAlgorithm::Sha3_384
+            }
+            else if Nid::sha3_512() == nid {
+                HashingAlgorithm::Sha3_512
+            }
+            else {
+                return Err(Error::Message(
+                    format!("Unsupported hash algorithm with NID: {:?}", nid)));
+            };
+        Ok(algo)
+    }
+}
+
+trait HashcheckTicketExt {
+    fn null() -> HashcheckTicket;
+}
+
+impl HashcheckTicketExt for HashcheckTicket {
+    /// Returns the NULL Ticket of the hashcheck type, as defined in part 1 of the TPM spec,
+    /// clause 4.47.
+    fn null() -> HashcheckTicket {
+        let tk = TPMT_TK_HASHCHECK {
+            tag: HashcheckTicket::POSSIBLE_TAGS[0].into(),
+            digest: Default::default(),
+            hierarchy: TPM2_RH_NULL,
+        };
+        HashcheckTicket::try_from(tk).unwrap()
+    }
+}
+
+pub(crate) struct TpmCreds {
+    public: AsymKeyPub,
+    context: Arc<Mutex<Context>>,
+    handle: KeyHandle,
+}
+
+impl Owned for TpmCreds {
+    fn owner_of_kind(&self, kind: HashKind) -> Principal {
+        self.public.owner_of_kind(kind)
+    } 
+}
+
+impl Verifier for TpmCreds {
+    fn verify<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: I, signature: &[u8]) -> Result<bool> {
+        self.public.verify(parts, signature)
+    }
+}
+
+impl Encrypter for TpmCreds {
+    fn encrypt(&self, slice: &[u8]) -> Result<Vec<u8>> {
+        self.public.encrypt(slice)
+    }
+}
+
+impl CredsPub for TpmCreds {}
+
+impl Signer for TpmCreds {
+    fn sign<'a, I: Iterator<Item=&'a [u8]>>(&self, parts: I) -> Result<Signature> {
+        let msg_digest = self.public.digest();
+        let digest = {
+            let mut hasher = Hasher::new(msg_digest).map_err(Error::from)?;
+            for part in parts {
+                hasher.update(part).map_err(Error::from)?;
+            }
+            let bytes = hasher.finish().map_err(Error::from)?;
+            let slice: &[u8] = &bytes;
+            Digest::try_from(slice).map_err(|e| Error::Message(e.to_string()))?
+        };
+        let validation = HashcheckTicket::null();
+        let scheme = SignatureScheme::RsaSsa { hash_scheme: msg_digest.hash_scheme()? };
+        let sig = {
+            let mut lock = self.context.lock().map_err(|e| Error::Message(e.to_string()))?;
+            lock.sign(self.handle, digest, scheme, validation)
+                .map_err(|e| Error::Message(e.to_string()))?
+        };
+        let buf = match sig {
+            tss_esapi::structures::Signature::RsaSsa(inner) => {
+                let mut buf = [0u8; RSA_SIG_LEN];
+                let slice: &[u8] = inner.signature();
+                buf.as_mut_slice().write_all(slice).map_err(Error::from)?;
+                buf
+            },
+            _ => return Err(Error::Message(format!("Unexpected signature type: {:?}", sig))),
+        };
+
+        Ok(Signature::Rsa(buf))
+    }
+}
+
+impl Decrypter for TpmCreds {
+    fn decrypt(&self, _slice: &[u8]) -> Result<Vec<u8>> {
+      unimplemented!()  
+    } 
+}
+
+impl CredsPriv for TpmCreds {}
+
+impl Creds for TpmCreds {
+    fn public(&self) -> &AsymKeyPub {
+        &self.public
+    }
+}
+
+trait TctiNameConfExt {
+    fn default() -> TctiNameConf;
+}
+
+impl TctiNameConfExt for TctiNameConf {
+    /// Returns a configuration which specifies that Tabrmd should be connected to using the system
+    /// DBus.
+    fn default() -> TctiNameConf {
+        TctiNameConf::Tabrmd(TabrmdConfig::default())
+    }
 }
 
 #[link(name = "tss2-rc")]
@@ -80,13 +350,16 @@ extern {
     fn Tss2_RC_Decode(rc: TSS2_RC) -> *const c_char;
 }
 
+/// Interface for types which can be converted to TSS2 response codes.
 trait HasResponseCode {
-    fn response_code(&self) -> TSS2_RC;
+    /// Returns the TSS2 response code associated with this instance.
+    fn tss2_rc(&self) -> TSS2_RC;
 }
 
+/// Returns the error message associated with the given TSS2 response code.
 fn tss2_rc_decode<E: HasResponseCode>(err: E) -> &'static str {
     let c_str = unsafe {
-        let ptr = Tss2_RC_Decode(err.response_code());
+        let ptr = Tss2_RC_Decode(err.tss2_rc());
         CStr::from_ptr(ptr)
     };
     // We're relying on Tss2_RC_Decode to return valid C strings.
@@ -94,7 +367,7 @@ fn tss2_rc_decode<E: HasResponseCode>(err: E) -> &'static str {
 }
 
 impl HasResponseCode for Tss2ResponseCode {
-    fn response_code(&self) -> TSS2_RC {
+    fn tss2_rc(&self) -> TSS2_RC {
         match self {
             Tss2ResponseCode::Success => 0,
             Tss2ResponseCode::FormatZero(code) => code.0,
@@ -104,31 +377,22 @@ impl HasResponseCode for Tss2ResponseCode {
 }
 
 impl HasResponseCode for TSS2_RC {
-    fn response_code(&self) -> TSS2_RC {
+    fn tss2_rc(&self) -> TSS2_RC {
         *self
     }
 }
 
-trait Tss2Expect<T> {
-    /// Provides an enhanced error message for types which contain TSS2 response codes.
-    fn tss2_expect(self, err_msg: &str) -> T;
-}
-
-impl<T> Tss2Expect<T> for tss_esapi::Result<T> {
-    fn tss2_expect(self, err_msg: &str) -> T {
-        match self {
-            tss_esapi::Result::Ok(val) => val,
-            tss_esapi::Result::Err(err) => {
-                match err {
-                    tss_esapi::Error::WrapperError(err) => panic!("{}: {}", err_msg, err),
-                    tss_esapi::Error::Tss2Error(err) => {
-                        let rc = err.response_code();
-                        let text = tss2_rc_decode(err);
-                        panic!("{}, response code: {}, response text: {}", err_msg, rc, text);
-                    }
-                }
-            },
-        }
+impl From<tss_esapi::Error> for Error {
+    fn from(err: tss_esapi::Error) -> Self {
+        let string = match err {
+            tss_esapi::Error::WrapperError(err) => err.to_string(),
+            tss_esapi::Error::Tss2Error(err) => {
+               let rc = err.tss2_rc();
+               let text = tss2_rc_decode(err);
+               format!("response code: {}, response text: {}", rc, text)
+            }
+        };
+        Error::Message(string)
     }
 }
 
@@ -136,18 +400,48 @@ impl<T> Tss2Expect<T> for tss_esapi::Result<T> {
 mod test {
     use super::*;
 
+    use tempdir::TempDir;
+    use std::fs::File;
+    use tss_esapi::{
+        interface_types::{
+            ecc::EccCurve,
+        },
+        structures::{
+            EccPoint,
+            EccScheme,
+            KeyDerivationFunctionScheme,
+            PublicEccParameters,
+        },
+    };
+
+    trait ContextExt {
+        fn for_test() -> Result<Context>;
+    }
+
+    impl ContextExt for Context {
+        fn for_test() -> Result<Context> {
+            let config = TabrmdConfig::from_str("bus_type=session").map_err(Error::from)?;
+            Context::new(TctiNameConf::Tabrmd(config)).map_err(Error::from)
+        }
+    }
+
+    /// Displays the message associated with a TSS2 return code.
+    //#[test]
+    fn print_error_message() {
+        const RC: TSS2_RC = 0x00000101;
+        let msg = tss2_rc_decode(RC);
+        println!("{}", msg);
+    }
+
     #[test]
     fn create_context() {
-        let config = TabrmdConfig::default();
-        let mut context = Context::new_with_tabrmd(config).unwrap();
+        let mut context = Context::for_test().unwrap();
         context.self_test(true).unwrap();
     }
 
     #[test]
     fn create_primary_key() {
-        let config = TctiNameConf::Device(DeviceConfig::from_str("/dev/vtpm0").unwrap());
-        let mut context = Context::new(config)
-            .tss2_expect("Failed to create context");
+        let mut context = Context::for_test().unwrap();
 
         let public = {
             let object_attributes = ObjectAttributes::builder()
@@ -186,7 +480,8 @@ mod test {
             SymmetricDefinition::AES_256_CFB,
             HashingAlgorithm::Sha256,
         )
-        .tss2_expect("Failed to create session")
+        .map_err(Error::from)
+        .expect("Failed to create session")
         .expect("Received invalid handle");
 
         context.execute_with_session(Some(session), |ctx| {
@@ -198,10 +493,89 @@ mod test {
                 None,
                 None,
             )
-            .tss2_expect("create_primary failed")
+            .map_err(Error::from)
+            .expect("create_primary failed")
             .key_handle;
 
             ctx.flush_context(primary.into()).expect("flush_context failed");
         });
     }
+
+    /// Tests that a TPM Credential Store can be created when a cookie does not already exist.
+    #[test]
+    fn tpm_cred_store_new() -> Result<()> {
+        let dir = TempDir::new("btnode").map_err(Error::from)?;
+        let cookie_path = dir.path().join("cookie.bin");
+        let store = TpmCredStore::new(Context::for_test()?, &cookie_path)?;
+        let cookie = File::open(&cookie_path).map_err(Error::from)?;
+        let metadata = cookie.metadata().map_err(Error::from)?;
+        let actual = metadata.permissions().mode();
+        // Assert that the cookie can only be read by its owner.
+        assert_eq!(0o400, 0o777 & actual);
+        drop(store);
+        dir.close()?;
+        Ok(())
+    }
+
+    #[test]
+    fn gen_creds() -> Result<()> {
+        let dir = TempDir::new("btnode").map_err(Error::from)?;
+        let cookie_path = dir.path().join("cookie.bin");
+        let store = TpmCredStore::new(Context::for_test()?, &cookie_path)?;
+        store.gen_node_creds()?;
+        Ok(())
+    }
+
+    /// Displays the numeric identifiers used by the supported hash algorithms.
+    fn show_nids() {
+        fn show_nid(digest: MessageDigest) {
+            let nid = digest.type_();
+            println!("{}: {:?}", nid.long_name().unwrap(), nid);
+        }
+
+        show_nid(MessageDigest::sha1());
+        show_nid(MessageDigest::sha256());
+        show_nid(MessageDigest::sha384());
+        show_nid(MessageDigest::sha512());
+        show_nid(MessageDigest::sha3_256());
+        show_nid(MessageDigest::sha3_384());
+        show_nid(MessageDigest::sha3_512());
+    }
+
+    /// Verifies that the NIDs returned by the supported hash algorithms are as expected.
+    #[test]
+    fn verify_expected_nids() {
+        fn assert_eq(digest: MessageDigest, nid: Nid) {
+            assert_eq!(digest.type_(), nid);
+        }
+
+        assert_eq(MessageDigest::sha1(), Nid::SHA1);
+        assert_eq(MessageDigest::sha256(), Nid::SHA256);
+        assert_eq(MessageDigest::sha384(), Nid::SHA384);
+        assert_eq(MessageDigest::sha512(), Nid::SHA512);
+        assert_eq(MessageDigest::sha3_256(), Nid::sha3_256());
+        assert_eq(MessageDigest::sha3_384(), Nid::sha3_384());
+        assert_eq(MessageDigest::sha3_512(), Nid::sha3_512());
+    }
+
+    #[test]
+    fn tpm_sign_verify() -> Result<()> {
+        env_logger::init();
+        let dir = TempDir::new("btnode").map_err(Error::from)?;
+        let cookie_path = dir.path().join("cookie.bin");
+        let store = TpmCredStore::new(Context::for_test()?, &cookie_path)?;       
+        let handle = store.gen_node_creds()?;
+        let data: [u8; 1024] = rand_array()?;
+        let parts = [data.as_slice()];
+        let sig = handle.sign(parts.into_iter())?;
+        assert!(handle.verify(parts.into_iter(), sig.as_slice())?);
+        dir.close()?;
+        Ok(())
+    }
+
+    /// Tests that `HashcheckTicket::null` doesn't panic.
+    #[test]
+    fn hashcheck_null() {
+        HashcheckTicket::null();
+    }
 }

crates/btnode/src/test_helpers.rs

@@ -26,7 +26,7 @@ pub const PAYLOAD: [u8; 128] = [
     0xEE, 0x1F, 0x84, 0x17, 0xA2, 0x74, 0xC3, 0xC3, 0xD5, 0x2F, 0x70, 0x74, 0xFE, 0xD8, 0x2C, 0x29,
 ];
 
-pub const SIGNATURE: [u8; 512] = [
+pub const SIGNATURE: [u8; 384] = [
     0x12, 0xB1, 0x09, 0x2F, 0x2B, 0x3C, 0x53, 0xE8, 0x1B, 0x2B, 0x6A, 0xE7, 0x97, 0x42, 0x9D, 0x83,
     0x71, 0x75, 0x65, 0x25, 0xFD, 0xB0, 0x0E, 0x2F, 0xAB, 0x53, 0xB7, 0x03, 0x03, 0x39, 0xEE, 0xE9,
     0x15, 0x19, 0xAB, 0x1A, 0xF1, 0x2C, 0x3C, 0xAB, 0x5C, 0x02, 0xEA, 0xD6, 0xF6, 0x94, 0x36, 0x80,
@@ -51,14 +51,6 @@ pub const SIGNATURE: [u8; 512] = [
     0xCA, 0x40, 0x23, 0x44, 0xDB, 0x56, 0x90, 0x4A, 0x0E, 0xB1, 0xB1, 0xE1, 0x9B, 0x5A, 0x5D, 0x53,
     0xEF, 0x4E, 0xE1, 0x0E, 0x12, 0xA9, 0x7C, 0x11, 0x0B, 0x6A, 0x4C, 0x3A, 0x8F, 0x2B, 0x9F, 0xC6,
     0x42, 0xD7, 0xFE, 0x7D, 0x10, 0x02, 0xBD, 0x31, 0x21, 0xCD, 0xD1, 0x32, 0x04, 0x22, 0xE2, 0x36,
-    0x88, 0x8F, 0xA3, 0xFF, 0x5C, 0x81, 0xE2, 0xDA, 0xAF, 0x39, 0x10, 0x2B, 0x15, 0xDB, 0x66, 0x52,
-    0xF6, 0x8A, 0xAE, 0x37, 0xA7, 0x6E, 0x6F, 0xEA, 0xBC, 0xD0, 0x89, 0xA1, 0x05, 0x35, 0x4B, 0xD3,
-    0x18, 0xDA, 0xBC, 0xA0, 0x89, 0x22, 0xA9, 0x9A, 0xC8, 0x08, 0xD4, 0xDF, 0x13, 0x49, 0xC8, 0xE7,
-    0x2F, 0x7E, 0x7C, 0x7B, 0x02, 0x09, 0x2A, 0xCA, 0x13, 0x0E, 0xB5, 0x29, 0xC9, 0xA2, 0xD5, 0x55,
-    0x45, 0x73, 0x95, 0xC2, 0x7F, 0xFA, 0x33, 0x44, 0xF0, 0xE2, 0x32, 0x5E, 0x5B, 0x89, 0x0C, 0x7C,
-    0xC5, 0x59, 0xAB, 0x74, 0x29, 0xBE, 0x3B, 0x3D, 0xB8, 0xB3, 0x93, 0x4B, 0x49, 0xDE, 0xE7, 0x5F,
-    0x0F, 0x48, 0x23, 0x9E, 0x08, 0xDF, 0x23, 0x9E, 0xB8, 0x48, 0xB8, 0xB1, 0x8D, 0xBD, 0x66, 0xA0,
-    0x24, 0xAB, 0x4D, 0xC2, 0xDE, 0x6A, 0x1E, 0x76, 0x42, 0x0D, 0x36, 0x9D, 0xA4, 0xA2, 0x43, 0xC2,
 ];
 
 pub const KEY: [u8; 32] = [
@@ -66,380 +58,292 @@ pub const KEY: [u8; 32] = [
     0xBB, 0xF9, 0xFE, 0xD0, 0xC1, 0xF7, 0x90, 0x34, 0x69, 0xB7, 0xE7, 0xC6, 0x1C, 0x46, 0x85, 0x48,
 ];
 
-pub const ROOT_PUBLIC_KEY: [u8; 550] = [
-    0x30, 0x82, 0x02, 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 
-    0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0F, 0x00, 0x30, 0x82, 0x02, 0x0A, 0x02, 0x82, 0x02, 0x01, 
-    0x00, 0xA4, 0x3E, 0xA9, 0xF6, 0x60, 0x73, 0x29, 0x9E, 0x75, 0xB4, 0x95, 0xAD, 0x2F, 0x8E, 0x93, 
-    0xD9, 0x9D, 0xB5, 0x46, 0x99, 0xD9, 0xA2, 0x2E, 0x3F, 0x93, 0xAB, 0xDB, 0x36, 0x2F, 0x37, 0xB7, 
-    0x8C, 0x2C, 0xD5, 0xC7, 0x25, 0x94, 0x11, 0x9D, 0xBD, 0x55, 0xAB, 0x89, 0x1C, 0x47, 0x66, 0xCD, 
-    0x4D, 0x5D, 0x48, 0x72, 0x4C, 0x15, 0xC9, 0x36, 0xCB, 0x40, 0x17, 0x05, 0x44, 0xCB, 0xE1, 0xE7, 
-    0x3C, 0xB7, 0xDD, 0xE0, 0x52, 0x9A, 0xE2, 0x3A, 0xF2, 0x33, 0x82, 0xB5, 0x75, 0xA0, 0x55, 0x51, 
-    0x9E, 0x11, 0x2D, 0x41, 0x11, 0xF7, 0x6A, 0x6F, 0xB3, 0x96, 0x93, 0x82, 0xC4, 0x18, 0xAD, 0x9F, 
-    0x45, 0x3C, 0x91, 0xC2, 0x3D, 0x1B, 0x77, 0xFE, 0x4E, 0xD5, 0xE0, 0x73, 0x85, 0xE0, 0x63, 0x1B, 
-    0x07, 0xED, 0x02, 0x0A, 0x5D, 0x6D, 0x93, 0x3D, 0x17, 0x13, 0xAA, 0x06, 0x86, 0xEF, 0xB7, 0x35, 
-    0x41, 0x0E, 0xE7, 0x60, 0x2B, 0x8F, 0xA6, 0x15, 0xC8, 0xA1, 0x7B, 0xA4, 0x01, 0x7E, 0x64, 0x51, 
-    0x87, 0x83, 0xBA, 0x9B, 0x29, 0x5C, 0xB0, 0x1C, 0xE9, 0x07, 0xC1, 0xB4, 0xE2, 0x61, 0x51, 0x74, 
-    0x3A, 0x4C, 0x22, 0xE9, 0xFA, 0xAC, 0x12, 0xC3, 0x71, 0x76, 0x7B, 0xFD, 0xA5, 0x15, 0x22, 0xC5, 
-    0xB3, 0x57, 0xDC, 0xD7, 0xC1, 0xA8, 0x7A, 0x5A, 0xCB, 0xD0, 0x7E, 0x27, 0xDF, 0x02, 0x32, 0x02, 
-    0xB9, 0xD6, 0x59, 0xC7, 0x68, 0x58, 0x2D, 0x54, 0x08, 0x20, 0x1D, 0x06, 0x7E, 0xC5, 0x61, 0x58, 
-    0x28, 0x2D, 0x0F, 0x1F, 0xBA, 0x75, 0xE5, 0xB7, 0x98, 0x73, 0x0F, 0x77, 0x60, 0x9C, 0x1F, 0x74, 
-    0xD6, 0x27, 0x7B, 0x6F, 0x68, 0x77, 0x5D, 0xC1, 0x91, 0x40, 0x09, 0x6E, 0xA7, 0xF8, 0xA7, 0x71, 
-    0x37, 0xA9, 0x82, 0xFB, 0xC6, 0x06, 0x80, 0xB7, 0xCB, 0x4B, 0x0A, 0x65, 0xD5, 0xC4, 0xDE, 0x7D, 
-    0x99, 0xCC, 0xE9, 0xDC, 0x06, 0x17, 0x69, 0xCD, 0x5F, 0x4B, 0x49, 0x6C, 0x39, 0x45, 0x5F, 0x37, 
-    0xE7, 0x0D, 0x0C, 0x50, 0xBC, 0xF9, 0x44, 0xAD, 0x9E, 0x6F, 0x3E, 0x40, 0x10, 0x1E, 0xF1, 0x97, 
-    0x59, 0xD3, 0x31, 0x74, 0x01, 0x51, 0xE9, 0x01, 0x59, 0x1C, 0x5B, 0x3A, 0x0B, 0xDE, 0x4C, 0xA2, 
-    0x3D, 0xB0, 0x53, 0xDC, 0x14, 0x42, 0x03, 0xE3, 0x29, 0x51, 0x9D, 0x06, 0x5F, 0x38, 0x36, 0xAE, 
-    0xE0, 0x42, 0xDB, 0x32, 0x62, 0x38, 0x13, 0x83, 0xC6, 0x62, 0x0F, 0xAA, 0x78, 0xF2, 0xE1, 0x46, 
-    0x12, 0x15, 0x58, 0x08, 0xB1, 0x42, 0x9B, 0x3E, 0xA5, 0x00, 0xF5, 0x3B, 0x6F, 0xD4, 0xB8, 0x50, 
-    0x3D, 0xCA, 0x42, 0x47, 0x03, 0x4E, 0x28, 0x6C, 0xE1, 0x3D, 0xEB, 0x83, 0x77, 0x58, 0x07, 0x13, 
-    0x82, 0x75, 0xBF, 0x0C, 0xC6, 0x26, 0xC5, 0x54, 0xF4, 0x53, 0x52, 0x84, 0x2B, 0xB1, 0xD4, 0x6F, 
-    0xFF, 0xC3, 0x08, 0xA7, 0x92, 0xED, 0x86, 0x1C, 0x2B, 0xB1, 0x76, 0x74, 0xA7, 0x43, 0xFC, 0x47, 
-    0x4F, 0x93, 0x30, 0xD5, 0x2D, 0xF0, 0x71, 0xA3, 0xE6, 0x3B, 0xBE, 0x8F, 0x0C, 0x36, 0x73, 0xBD, 
-    0xAD, 0xCC, 0x92, 0x73, 0xEA, 0xC5, 0xCD, 0x4B, 0x12, 0x47, 0x59, 0xD9, 0xBA, 0xA9, 0x67, 0x4A, 
-    0x4E, 0xD9, 0x6D, 0x45, 0x2A, 0xE6, 0x60, 0xEB, 0x4E, 0x8D, 0xA3, 0xC2, 0x1C, 0x46, 0x85, 0x35, 
-    0x33, 0x08, 0x64, 0x1F, 0x9C, 0xEE, 0xA0, 0x9C, 0x48, 0xB5, 0x8D, 0xD0, 0xFC, 0x4F, 0x5F, 0xA1, 
-    0x85, 0x52, 0x01, 0xD4, 0x2C, 0xA6, 0xE0, 0x63, 0xFC, 0xE1, 0x74, 0x8B, 0xBC, 0xC1, 0x88, 0x25, 
-    0x20, 0xDF, 0xB8, 0xAF, 0xE2, 0xA7, 0xEF, 0x2C, 0x1D, 0x29, 0x66, 0x3D, 0xC1, 0x75, 0x13, 0x3C, 
-    0xE1, 0x47, 0x59, 0xD5, 0x96, 0x8F, 0xA0, 0xBF, 0xEE, 0x86, 0xCC, 0xC6, 0xC8, 0xF3, 0x36, 0x58, 
-    0x93, 0x02, 0x03, 0x01, 0x00, 0x01, 
+pub const ROOT_PUBLIC_KEY: [u8; 422] = [
+    0x30, 0x82, 0x01, 0xA2, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 
+    0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x8F, 0x00, 0x30, 0x82, 0x01, 0x8A, 0x02, 0x82, 0x01, 0x81, 
+    0x00, 0xCA, 0x69, 0x8F, 0x00, 0x0E, 0x09, 0xA0, 0x9A, 0x2D, 0xE6, 0xFC, 0xAC, 0x02, 0x46, 0xB7, 
+    0x5C, 0xFB, 0xAE, 0x59, 0x9F, 0x3F, 0xAD, 0xE7, 0x72, 0x9C, 0x7D, 0xC5, 0x48, 0x9A, 0x8F, 0x4C, 
+    0x33, 0x0B, 0x4E, 0x1A, 0x97, 0x95, 0xBF, 0x59, 0xA9, 0x4F, 0xB7, 0x9A, 0x43, 0x00, 0xD1, 0x80, 
+    0x52, 0xC7, 0x2A, 0x5B, 0xA1, 0xE2, 0x7E, 0x58, 0x14, 0xF8, 0x39, 0x5E, 0xD1, 0x31, 0x54, 0xC0, 
+    0xBF, 0xF7, 0x46, 0x33, 0x7B, 0xF1, 0x48, 0x85, 0x6E, 0xE0, 0x68, 0xD0, 0xCC, 0x74, 0x0F, 0x7D, 
+    0x9B, 0xF5, 0x21, 0xCA, 0xB2, 0xB6, 0x99, 0x64, 0x20, 0x6F, 0xB7, 0x71, 0xA4, 0xBA, 0x89, 0xB9, 
+    0xDA, 0x38, 0xC5, 0x2A, 0x7F, 0x44, 0x3F, 0xDA, 0xA5, 0x6A, 0x32, 0x67, 0xBA, 0x56, 0x67, 0x65, 
+    0xF4, 0xAB, 0xDF, 0xD3, 0xC8, 0x11, 0xC5, 0xAB, 0x31, 0x61, 0xFB, 0x25, 0xA7, 0x05, 0xBE, 0x2E, 
+    0xA9, 0x45, 0x80, 0x85, 0xA7, 0x19, 0xC3, 0xBD, 0x2F, 0x18, 0xD1, 0xD9, 0x08, 0xC0, 0xBE, 0xA5, 
+    0xCD, 0x8F, 0xF9, 0x36, 0x71, 0x38, 0x70, 0xD7, 0xF2, 0x10, 0x64, 0xFE, 0x9A, 0xB6, 0x98, 0xCB, 
+    0xB0, 0x16, 0x1C, 0xFE, 0x45, 0x26, 0x71, 0x5E, 0x7C, 0x99, 0x0C, 0xDD, 0xB2, 0x80, 0xE4, 0xE5, 
+    0xA6, 0x46, 0x40, 0x73, 0xDA, 0xB0, 0xF9, 0xB6, 0xFD, 0x5D, 0xD6, 0x03, 0x25, 0x1B, 0x0F, 0xD6, 
+    0x03, 0x3F, 0x5D, 0xDA, 0xDE, 0xA3, 0x23, 0xC1, 0x93, 0x71, 0x92, 0x92, 0xAE, 0xB3, 0x68, 0x25, 
+    0x83, 0x7B, 0x3F, 0x1D, 0xFD, 0x05, 0xDB, 0xA3, 0xDB, 0xB6, 0x57, 0xD8, 0x3E, 0x03, 0x83, 0xD3, 
+    0x0B, 0x0F, 0xE3, 0xEF, 0x3A, 0xBE, 0x6F, 0x92, 0x9B, 0x99, 0x1E, 0xA7, 0xB7, 0x82, 0xD4, 0x38, 
+    0x4B, 0x09, 0xF3, 0xD3, 0xF5, 0x77, 0x82, 0x6A, 0x19, 0xBD, 0x79, 0x8A, 0x96, 0x66, 0x58, 0xE9, 
+    0xBF, 0x65, 0x15, 0xB9, 0x01, 0xFD, 0x34, 0xC4, 0x42, 0x8F, 0x3A, 0x90, 0xCF, 0x6C, 0xA2, 0xC3, 
+    0xD7, 0xBB, 0xD5, 0x0C, 0x67, 0x10, 0xDA, 0x1C, 0xAC, 0x30, 0xDA, 0x50, 0xBD, 0x5D, 0x85, 0x4A, 
+    0x47, 0xAC, 0xB1, 0xB2, 0x27, 0xE8, 0xC9, 0x75, 0x1C, 0x3B, 0x93, 0xD4, 0x93, 0x5A, 0x51, 0x82, 
+    0xF2, 0x66, 0x96, 0x5F, 0x24, 0xB0, 0x30, 0x45, 0x5B, 0x9D, 0xD1, 0xE4, 0x66, 0xDF, 0xA6, 0xED, 
+    0x59, 0x1F, 0x58, 0x52, 0x05, 0x8B, 0x45, 0xD1, 0x9A, 0x3D, 0x08, 0x2E, 0x95, 0x1B, 0x08, 0x22, 
+    0x0D, 0xAA, 0x49, 0xFB, 0x85, 0x01, 0xBF, 0x83, 0x62, 0xFE, 0x21, 0x45, 0xFE, 0x73, 0x06, 0x85, 
+    0x20, 0x06, 0x77, 0x3D, 0x9B, 0x05, 0x0C, 0x2B, 0xB5, 0x89, 0x5A, 0x99, 0x4B, 0xAE, 0x4A, 0xDD, 
+    0x93, 0x2F, 0xF9, 0x1D, 0xE4, 0x6C, 0xB3, 0xF7, 0x0C, 0x42, 0x00, 0x02, 0x3E, 0x2D, 0x78, 0x01, 
+    0xA9, 0x02, 0x03, 0x01, 0x00, 0x01, 
 ];
 
-pub const ROOT_PRIVATE_KEY: [u8; 2348] = [
-    0x30, 0x82, 0x09, 0x28, 0x02, 0x01, 0x00, 0x02, 0x82, 0x02, 0x01, 0x00, 0xA4, 0x3E, 0xA9, 0xF6, 
-    0x60, 0x73, 0x29, 0x9E, 0x75, 0xB4, 0x95, 0xAD, 0x2F, 0x8E, 0x93, 0xD9, 0x9D, 0xB5, 0x46, 0x99, 
-    0xD9, 0xA2, 0x2E, 0x3F, 0x93, 0xAB, 0xDB, 0x36, 0x2F, 0x37, 0xB7, 0x8C, 0x2C, 0xD5, 0xC7, 0x25, 
-    0x94, 0x11, 0x9D, 0xBD, 0x55, 0xAB, 0x89, 0x1C, 0x47, 0x66, 0xCD, 0x4D, 0x5D, 0x48, 0x72, 0x4C, 
-    0x15, 0xC9, 0x36, 0xCB, 0x40, 0x17, 0x05, 0x44, 0xCB, 0xE1, 0xE7, 0x3C, 0xB7, 0xDD, 0xE0, 0x52, 
-    0x9A, 0xE2, 0x3A, 0xF2, 0x33, 0x82, 0xB5, 0x75, 0xA0, 0x55, 0x51, 0x9E, 0x11, 0x2D, 0x41, 0x11, 
-    0xF7, 0x6A, 0x6F, 0xB3, 0x96, 0x93, 0x82, 0xC4, 0x18, 0xAD, 0x9F, 0x45, 0x3C, 0x91, 0xC2, 0x3D, 
-    0x1B, 0x77, 0xFE, 0x4E, 0xD5, 0xE0, 0x73, 0x85, 0xE0, 0x63, 0x1B, 0x07, 0xED, 0x02, 0x0A, 0x5D, 
-    0x6D, 0x93, 0x3D, 0x17, 0x13, 0xAA, 0x06, 0x86, 0xEF, 0xB7, 0x35, 0x41, 0x0E, 0xE7, 0x60, 0x2B, 
-    0x8F, 0xA6, 0x15, 0xC8, 0xA1, 0x7B, 0xA4, 0x01, 0x7E, 0x64, 0x51, 0x87, 0x83, 0xBA, 0x9B, 0x29, 
-    0x5C, 0xB0, 0x1C, 0xE9, 0x07, 0xC1, 0xB4, 0xE2, 0x61, 0x51, 0x74, 0x3A, 0x4C, 0x22, 0xE9, 0xFA, 
-    0xAC, 0x12, 0xC3, 0x71, 0x76, 0x7B, 0xFD, 0xA5, 0x15, 0x22, 0xC5, 0xB3, 0x57, 0xDC, 0xD7, 0xC1, 
-    0xA8, 0x7A, 0x5A, 0xCB, 0xD0, 0x7E, 0x27, 0xDF, 0x02, 0x32, 0x02, 0xB9, 0xD6, 0x59, 0xC7, 0x68, 
-    0x58, 0x2D, 0x54, 0x08, 0x20, 0x1D, 0x06, 0x7E, 0xC5, 0x61, 0x58, 0x28, 0x2D, 0x0F, 0x1F, 0xBA, 
-    0x75, 0xE5, 0xB7, 0x98, 0x73, 0x0F, 0x77, 0x60, 0x9C, 0x1F, 0x74, 0xD6, 0x27, 0x7B, 0x6F, 0x68, 
-    0x77, 0x5D, 0xC1, 0x91, 0x40, 0x09, 0x6E, 0xA7, 0xF8, 0xA7, 0x71, 0x37, 0xA9, 0x82, 0xFB, 0xC6, 
-    0x06, 0x80, 0xB7, 0xCB, 0x4B, 0x0A, 0x65, 0xD5, 0xC4, 0xDE, 0x7D, 0x99, 0xCC, 0xE9, 0xDC, 0x06, 
-    0x17, 0x69, 0xCD, 0x5F, 0x4B, 0x49, 0x6C, 0x39, 0x45, 0x5F, 0x37, 0xE7, 0x0D, 0x0C, 0x50, 0xBC, 
-    0xF9, 0x44, 0xAD, 0x9E, 0x6F, 0x3E, 0x40, 0x10, 0x1E, 0xF1, 0x97, 0x59, 0xD3, 0x31, 0x74, 0x01, 
-    0x51, 0xE9, 0x01, 0x59, 0x1C, 0x5B, 0x3A, 0x0B, 0xDE, 0x4C, 0xA2, 0x3D, 0xB0, 0x53, 0xDC, 0x14, 
-    0x42, 0x03, 0xE3, 0x29, 0x51, 0x9D, 0x06, 0x5F, 0x38, 0x36, 0xAE, 0xE0, 0x42, 0xDB, 0x32, 0x62, 
-    0x38, 0x13, 0x83, 0xC6, 0x62, 0x0F, 0xAA, 0x78, 0xF2, 0xE1, 0x46, 0x12, 0x15, 0x58, 0x08, 0xB1, 
-    0x42, 0x9B, 0x3E, 0xA5, 0x00, 0xF5, 0x3B, 0x6F, 0xD4, 0xB8, 0x50, 0x3D, 0xCA, 0x42, 0x47, 0x03, 
-    0x4E, 0x28, 0x6C, 0xE1, 0x3D, 0xEB, 0x83, 0x77, 0x58, 0x07, 0x13, 0x82, 0x75, 0xBF, 0x0C, 0xC6, 
-    0x26, 0xC5, 0x54, 0xF4, 0x53, 0x52, 0x84, 0x2B, 0xB1, 0xD4, 0x6F, 0xFF, 0xC3, 0x08, 0xA7, 0x92, 
-    0xED, 0x86, 0x1C, 0x2B, 0xB1, 0x76, 0x74, 0xA7, 0x43, 0xFC, 0x47, 0x4F, 0x93, 0x30, 0xD5, 0x2D, 
-    0xF0, 0x71, 0xA3, 0xE6, 0x3B, 0xBE, 0x8F, 0x0C, 0x36, 0x73, 0xBD, 0xAD, 0xCC, 0x92, 0x73, 0xEA, 
-    0xC5, 0xCD, 0x4B, 0x12, 0x47, 0x59, 0xD9, 0xBA, 0xA9, 0x67, 0x4A, 0x4E, 0xD9, 0x6D, 0x45, 0x2A, 
-    0xE6, 0x60, 0xEB, 0x4E, 0x8D, 0xA3, 0xC2, 0x1C, 0x46, 0x85, 0x35, 0x33, 0x08, 0x64, 0x1F, 0x9C, 
-    0xEE, 0xA0, 0x9C, 0x48, 0xB5, 0x8D, 0xD0, 0xFC, 0x4F, 0x5F, 0xA1, 0x85, 0x52, 0x01, 0xD4, 0x2C, 
-    0xA6, 0xE0, 0x63, 0xFC, 0xE1, 0x74, 0x8B, 0xBC, 0xC1, 0x88, 0x25, 0x20, 0xDF, 0xB8, 0xAF, 0xE2, 
-    0xA7, 0xEF, 0x2C, 0x1D, 0x29, 0x66, 0x3D, 0xC1, 0x75, 0x13, 0x3C, 0xE1, 0x47, 0x59, 0xD5, 0x96, 
-    0x8F, 0xA0, 0xBF, 0xEE, 0x86, 0xCC, 0xC6, 0xC8, 0xF3, 0x36, 0x58, 0x93, 0x02, 0x03, 0x01, 0x00, 
-    0x01, 0x02, 0x82, 0x02, 0x00, 0x09, 0x2C, 0x26, 0xB9, 0xC7, 0xB1, 0x26, 0xC5, 0xDE, 0xB4, 0xF3, 
-    0x16, 0xF4, 0xEC, 0xF5, 0x7C, 0xD5, 0xBD, 0xE5, 0xEF, 0x79, 0xA4, 0x01, 0x09, 0x33, 0xEA, 0x09, 
-    0x18, 0x01, 0x93, 0x0F, 0x01, 0x19, 0x0F, 0xE7, 0x4B, 0x45, 0xF5, 0xA5, 0xE5, 0x88, 0xFF, 0x47, 
-    0x6C, 0xF8, 0xDF, 0xD8, 0xDF, 0x55, 0x32, 0x52, 0x8F, 0xC5, 0x37, 0xB3, 0x83, 0xAE, 0x54, 0x9A, 
-    0xCA, 0xB8, 0xC8, 0x28, 0xED, 0xCF, 0x26, 0xE8, 0xFC, 0x34, 0x02, 0x26, 0x60, 0x98, 0x57, 0xD8, 
-    0x62, 0x75, 0x4D, 0xCE, 0x7D, 0x11, 0x60, 0x81, 0x9D, 0xCB, 0x3F, 0x7A, 0x75, 0x81, 0x17, 0x43, 
-    0xDA, 0x47, 0xB6, 0x8A, 0x8A, 0x87, 0x53, 0x6C, 0x91, 0x95, 0x13, 0x22, 0x74, 0xAC, 0xA5, 0x18, 
-    0x4E, 0x85, 0xB5, 0x83, 0x30, 0xF2, 0x1F, 0x87, 0x0C, 0xA8, 0xAD, 0xEC, 0x5F, 0x79, 0x8D, 0xA9, 
-    0x47, 0xA7, 0xE3, 0x87, 0x69, 0xD6, 0xB7, 0x3D, 0x3B, 0xB1, 0x8E, 0x08, 0xF1, 0x67, 0x73, 0x4C, 
-    0x39, 0x79, 0x21, 0x89, 0x1C, 0x14, 0x53, 0x3B, 0x8F, 0x17, 0xCA, 0x0E, 0x13, 0x45, 0x87, 0x9F, 
-    0xDE, 0x74, 0xA8, 0xE3, 0xE0, 0xCD, 0x97, 0xB5, 0x91, 0x76, 0x42, 0xA5, 0xFF, 0x94, 0x2A, 0x60, 
-    0x83, 0xF3, 0xA6, 0x39, 0x7C, 0x46, 0x8F, 0xE2, 0xCC, 0xC1, 0xE7, 0xF3, 0x62, 0x26, 0x86, 0xA5, 
-    0x1B, 0x63, 0x37, 0xFF, 0xC6, 0xF9, 0x1D, 0x92, 0x71, 0x55, 0x5B, 0x52, 0xB2, 0x11, 0x79, 0x0D, 
-    0x7F, 0xCE, 0xEE, 0x1C, 0xCA, 0x41, 0x99, 0xF2, 0x9F, 0xAB, 0x2D, 0xE5, 0x0E, 0xF2, 0x7E, 0x0E, 
-    0xA0, 0xAA, 0x97, 0x67, 0x22, 0xFE, 0x99, 0x7A, 0x23, 0x4F, 0x67, 0x41, 0x04, 0x27, 0x9B, 0x5F, 
-    0x3E, 0xAA, 0x38, 0x4F, 0xAE, 0x58, 0x1D, 0x24, 0x8A, 0x6E, 0x9A, 0x89, 0xA9, 0x24, 0xCB, 0xB3, 
-    0xDC, 0x38, 0x5E, 0x64, 0x8D, 0x37, 0x61, 0x74, 0xEB, 0xAC, 0x12, 0xB3, 0xFC, 0x67, 0xC1, 0x85, 
-    0x9C, 0xB6, 0x88, 0xBA, 0x13, 0x9B, 0xDB, 0x89, 0xD6, 0xE6, 0x6F, 0x24, 0x0B, 0x5A, 0x2F, 0x5E, 
-    0xF5, 0xE7, 0x2B, 0x4B, 0x16, 0xA4, 0x9A, 0x74, 0x2D, 0xF8, 0x68, 0x63, 0x1B, 0xD1, 0xD4, 0x15, 
-    0x5A, 0x53, 0x3D, 0xF3, 0xEC, 0xCE, 0x36, 0x2F, 0xD7, 0x0B, 0x49, 0xA3, 0xA1, 0x59, 0xE3, 0x16, 
-    0x55, 0x70, 0xC7, 0x81, 0x5C, 0x38, 0x17, 0xC0, 0x20, 0x1F, 0x10, 0xD9, 0xD0, 0xFF, 0xA9, 0x9D, 
-    0x4C, 0x9A, 0x8F, 0x4B, 0xDA, 0xCE, 0xD4, 0x09, 0x53, 0xE2, 0x59, 0xBD, 0xEF, 0x74, 0x3D, 0xA3, 
-    0xA0, 0xBA, 0x1C, 0x98, 0x23, 0xF0, 0xD4, 0xB6, 0xF7, 0x18, 0x7B, 0x7D, 0xA6, 0xC7, 0x97, 0xA3, 
-    0xBB, 0x84, 0x97, 0xB9, 0x76, 0x59, 0x6A, 0x22, 0xF0, 0x4A, 0x8F, 0x27, 0xC4, 0x5B, 0x39, 0x54, 
-    0x7D, 0xA2, 0x7E, 0xFE, 0xF2, 0x61, 0xFC, 0x63, 0x3F, 0x1D, 0x4F, 0x72, 0xE5, 0xF3, 0xB7, 0xFB, 
-    0x77, 0x1C, 0x17, 0xAB, 0x2F, 0x14, 0x13, 0x9A, 0x74, 0xF4, 0xB0, 0x6E, 0xE2, 0x2F, 0x99, 0x36, 
-    0x22, 0xD2, 0xF5, 0x33, 0x9A, 0x35, 0xFC, 0x74, 0x9B, 0x48, 0x52, 0xA1, 0x28, 0x34, 0x7D, 0x19, 
-    0x6E, 0x4D, 0x6F, 0x09, 0xAF, 0x30, 0xA6, 0x0C, 0x00, 0x22, 0xAA, 0x3D, 0xCA, 0x10, 0xA8, 0x43, 
-    0x45, 0x1E, 0x0B, 0x1E, 0xFC, 0x2B, 0x2C, 0xB2, 0x00, 0xAE, 0x9A, 0x75, 0x77, 0x2C, 0x3E, 0x61, 
-    0xAB, 0x45, 0x80, 0x0F, 0xC7, 0x15, 0x56, 0xE5, 0xDE, 0x74, 0x82, 0x38, 0x98, 0xEB, 0x49, 0x76, 
-    0xA5, 0x9A, 0xB8, 0xE0, 0x9B, 0xEF, 0xEE, 0x01, 0x1A, 0x50, 0x38, 0x22, 0xC6, 0xF7, 0x3B, 0x0B, 
-    0x14, 0xAF, 0xC6, 0xDF, 0x62, 0x9C, 0x63, 0xAB, 0x55, 0xDE, 0x92, 0x41, 0xCC, 0x41, 0xEA, 0x7C, 
-    0x26, 0x39, 0x08, 0x23, 0x01, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD7, 0xD9, 0x60, 0xFC, 0xEA, 0xE7, 
-    0xF3, 0x5F, 0x80, 0x65, 0x79, 0xC7, 0xCA, 0xC1, 0xF6, 0x97, 0xD4, 0xEB, 0xD8, 0x62, 0x48, 0x82, 
-    0xF3, 0x0F, 0x4F, 0x65, 0x75, 0xDF, 0x44, 0xB8, 0x5A, 0x6D, 0xA3, 0xD1, 0x9D, 0xC8, 0x8B, 0xC1, 
-    0xD3, 0x64, 0xA8, 0x31, 0x09, 0x7C, 0xC0, 0x9D, 0x4D, 0x7B, 0x2D, 0x75, 0xF2, 0x4F, 0x8B, 0x98, 
-    0xEE, 0x03, 0xB6, 0xCD, 0x80, 0x73, 0x9F, 0xA4, 0xF0, 0x51, 0x23, 0xDD, 0x53, 0x30, 0x0A, 0xBD, 
-    0x6E, 0x2C, 0x70, 0x9D, 0xE8, 0x44, 0x67, 0x9E, 0xF3, 0xC0, 0x65, 0x91, 0xA6, 0xB1, 0xF4, 0x34, 
-    0xF8, 0x98, 0x47, 0xFD, 0x6A, 0xA7, 0xBB, 0x76, 0x14, 0x4A, 0x85, 0x22, 0xD8, 0x80, 0xF7, 0x7A, 
-    0x26, 0x78, 0x8C, 0x31, 0xCB, 0xF0, 0x17, 0x66, 0x8B, 0x0C, 0x33, 0x07, 0xA0, 0x08, 0xA1, 0x73, 
-    0xAB, 0x55, 0xC3, 0xF9, 0x49, 0x2A, 0xC6, 0x52, 0x46, 0x33, 0xC8, 0xE9, 0x20, 0xDB, 0xFB, 0xD0, 
-    0xF2, 0x25, 0x52, 0xB5, 0x72, 0x46, 0xEC, 0x2F, 0x67, 0x6D, 0x5D, 0xE4, 0xB8, 0x85, 0x77, 0xD3, 
-    0xBA, 0x15, 0x9C, 0xCF, 0x19, 0x50, 0xA3, 0xD6, 0x82, 0x7E, 0x35, 0xB6, 0xAB, 0xF2, 0xBE, 0x55, 
-    0x9E, 0x0D, 0x1C, 0x84, 0xEE, 0xAD, 0x2E, 0x71, 0x73, 0x91, 0x57, 0xD1, 0x4E, 0x89, 0x03, 0x9A, 
-    0x43, 0x07, 0x29, 0x61, 0x9C, 0x9C, 0xB0, 0x69, 0x0F, 0x4B, 0xAA, 0xEE, 0x9A, 0x4B, 0x9D, 0xEB, 
-    0x24, 0x65, 0x91, 0xA8, 0xD7, 0x5A, 0x11, 0x56, 0xEF, 0x83, 0xC8, 0x88, 0xAF, 0x9E, 0xB5, 0xAD, 
-    0x4D, 0xFC, 0x88, 0x47, 0x95, 0x26, 0x6F, 0x19, 0x5A, 0xF6, 0xD1, 0x96, 0xD1, 0xC0, 0xA3, 0xFF, 
-    0xA1, 0x42, 0xE9, 0xA2, 0x1E, 0x6E, 0x15, 0xD0, 0x9D, 0x2B, 0xE7, 0xDD, 0xB1, 0xC1, 0x57, 0xF3, 
-    0xC1, 0xD3, 0xCD, 0x60, 0x03, 0x52, 0xB7, 0x9C, 0x2B, 0x21, 0x02, 0x82, 0x01, 0x01, 0x00, 0xC2, 
-    0xCB, 0xE9, 0xC0, 0x14, 0xD6, 0xE6, 0xA6, 0xD7, 0x10, 0xE5, 0x6A, 0xC1, 0x04, 0xBB, 0x45, 0x4A, 
-    0xA6, 0xED, 0x21, 0xE0, 0x2D, 0x45, 0x6F, 0xA2, 0x08, 0xD5, 0x03, 0x60, 0xFE, 0x9B, 0x12, 0xD1, 
-    0x02, 0xE5, 0x05, 0x40, 0xCF, 0xEB, 0xE9, 0x7A, 0x0C, 0x07, 0xD2, 0x80, 0x6D, 0xA4, 0x06, 0x59, 
-    0x3F, 0xF9, 0x11, 0xFE, 0x46, 0x1A, 0x26, 0x0E, 0xE3, 0xA6, 0xE5, 0xC8, 0x58, 0x84, 0xF1, 0x80, 
-    0xA3, 0x35, 0x19, 0x0D, 0xA7, 0x28, 0xC6, 0xE2, 0x6E, 0xE4, 0xBE, 0x34, 0xD0, 0x48, 0x19, 0x8A, 
-    0xEC, 0xB3, 0xB2, 0xF2, 0xCC, 0x18, 0x14, 0xF6, 0xB9, 0x27, 0x59, 0x2E, 0xFD, 0x40, 0x1C, 0x0C, 
-    0xD7, 0x43, 0x28, 0x02, 0x01, 0x80, 0x2A, 0x37, 0x4A, 0xB0, 0xDF, 0x5C, 0x60, 0xE1, 0x01, 0xF3, 
-    0x39, 0x7F, 0x98, 0x7C, 0x1F, 0xFA, 0x82, 0xA7, 0x03, 0x13, 0xE8, 0x17, 0x1C, 0x38, 0xCE, 0xFD, 
-    0x49, 0x68, 0x40, 0xD6, 0x63, 0xBB, 0xB1, 0x69, 0xCF, 0x55, 0xD0, 0x90, 0xF6, 0x0D, 0x93, 0x5C, 
-    0x8F, 0x15, 0x10, 0x9C, 0x0D, 0x4B, 0xD5, 0xC3, 0x59, 0x60, 0x2F, 0xE2, 0xA1, 0x3F, 0xB4, 0x18, 
-    0x35, 0xF8, 0x1C, 0x0E, 0x54, 0x0A, 0x44, 0xD7, 0xA5, 0x38, 0x98, 0x0D, 0x31, 0x36, 0xD4, 0x49, 
-    0x01, 0xC2, 0x29, 0x1D, 0x15, 0x86, 0x1F, 0xC5, 0x75, 0xA1, 0x9F, 0xF2, 0xFB, 0x0F, 0xD9, 0xC8, 
-    0xD5, 0xAE, 0xE8, 0xA2, 0x77, 0x12, 0x7E, 0x05, 0x02, 0x7F, 0x88, 0x8F, 0x7F, 0x3B, 0xB7, 0xE0, 
-    0x58, 0xBE, 0x56, 0xF0, 0x50, 0x1B, 0x18, 0xFA, 0x29, 0xC0, 0x18, 0x53, 0x19, 0x39, 0x2E, 0x36, 
-    0xD8, 0x36, 0x85, 0x86, 0x6C, 0x1D, 0x85, 0x55, 0xBA, 0x72, 0xB8, 0x2C, 0x5E, 0xF0, 0xBD, 0xC8, 
-    0x3E, 0x53, 0xD9, 0x00, 0x45, 0x2A, 0xF9, 0x2B, 0xA9, 0xE4, 0x25, 0x92, 0xBA, 0xA1, 0x33, 0x02, 
-    0x82, 0x01, 0x00, 0x24, 0x90, 0xA0, 0x8B, 0x77, 0xC7, 0xBF, 0x44, 0xA8, 0x5D, 0x88, 0x59, 0xBE, 
-    0x11, 0x49, 0x92, 0xC2, 0xF1, 0x09, 0x00, 0xED, 0x43, 0xB1, 0xA5, 0x20, 0x50, 0x11, 0xBD, 0xB6, 
-    0xC8, 0x7C, 0x19, 0x22, 0xAD, 0x39, 0xCB, 0x65, 0x51, 0x7A, 0x5C, 0x0C, 0xD9, 0xF1, 0xBF, 0x7E, 
-    0x69, 0xA7, 0x5C, 0x7C, 0x81, 0x04, 0x81, 0x51, 0x26, 0xA0, 0xFB, 0x64, 0x16, 0x3F, 0xF2, 0x56, 
-    0x52, 0xFC, 0x9A, 0xE2, 0x36, 0x76, 0x07, 0x27, 0x6A, 0x9B, 0xA5, 0x4F, 0x96, 0x90, 0x68, 0x36, 
-    0x1D, 0x89, 0x31, 0x48, 0x83, 0x79, 0xF7, 0x9F, 0x64, 0xF1, 0xCF, 0xEA, 0x32, 0x15, 0xC5, 0x40, 
-    0x4E, 0x6A, 0x75, 0x8D, 0x44, 0x2F, 0xE4, 0xF9, 0x07, 0x6A, 0x48, 0xF5, 0x86, 0xE2, 0x03, 0x54, 
-    0x13, 0x7C, 0xEE, 0x9E, 0x1E, 0x66, 0x8F, 0xCF, 0xB9, 0xE6, 0x86, 0x6A, 0xE2, 0x69, 0xF0, 0xA3, 
-    0x14, 0x00, 0xEC, 0x78, 0xD6, 0x75, 0x48, 0x8E, 0xCA, 0x00, 0x9B, 0x2D, 0xFD, 0xAA, 0xD4, 0x34, 
-    0xE2, 0x7A, 0xE4, 0xDE, 0x09, 0x06, 0xF1, 0x25, 0x31, 0x6A, 0xCE, 0x8A, 0x77, 0xD2, 0xD4, 0x04, 
-    0x4D, 0x2C, 0x61, 0xF0, 0xFB, 0x76, 0xF9, 0x72, 0x20, 0xD2, 0xDB, 0x69, 0xBF, 0x63, 0x27, 0x57, 
-    0x3C, 0xC4, 0xD5, 0x14, 0x49, 0x52, 0xC2, 0x87, 0x27, 0xB4, 0xBF, 0x1B, 0xD5, 0x7B, 0x50, 0x57, 
-    0xDA, 0x14, 0x4B, 0x3F, 0x33, 0x98, 0x53, 0xC2, 0xF6, 0xB8, 0x7D, 0xB4, 0x45, 0x23, 0xE6, 0x10, 
-    0x15, 0xE8, 0x11, 0x2D, 0x01, 0x6A, 0xAE, 0xBA, 0x1C, 0x17, 0x9F, 0xF5, 0xFE, 0x1A, 0x58, 0x1E, 
-    0x6D, 0xEF, 0x28, 0xEC, 0xAC, 0x5D, 0xF0, 0x02, 0x58, 0x25, 0x9B, 0x4E, 0x34, 0xB6, 0x6E, 0xF3, 
-    0xA7, 0x19, 0x58, 0xFC, 0xB8, 0x63, 0x8A, 0x5B, 0x39, 0xE1, 0xD5, 0xDD, 0x6E, 0xAC, 0x61, 0x70, 
-    0xD5, 0x35, 0xC1, 0x02, 0x82, 0x01, 0x01, 0x00, 0x8D, 0x47, 0xAF, 0xA5, 0x2C, 0x78, 0x20, 0x99, 
-    0x68, 0xEA, 0x4C, 0x39, 0xFC, 0xFC, 0x1D, 0x86, 0xC7, 0xFA, 0x01, 0x8A, 0xCC, 0x38, 0x89, 0x5F, 
-    0xC9, 0xB9, 0x76, 0x25, 0x19, 0x38, 0x0F, 0xE8, 0xB9, 0xC6, 0xCB, 0xAB, 0xDF, 0xB1, 0xED, 0x7C, 
-    0x4C, 0x94, 0x65, 0x27, 0xFB, 0x15, 0x8A, 0x1D, 0x40, 0xA5, 0xF1, 0x53, 0x67, 0x84, 0x18, 0x7A, 
-    0xF9, 0xD9, 0x8A, 0xB6, 0xA5, 0x73, 0xEE, 0x17, 0xEA, 0x20, 0x74, 0xE6, 0x52, 0xCC, 0xA5, 0xFA, 
-    0x79, 0x47, 0xCC, 0x87, 0x57, 0x6E, 0xA8, 0x9C, 0x3D, 0xF2, 0x26, 0xF2, 0xE6, 0xBD, 0xB7, 0xC9, 
-    0x9C, 0x97, 0xF5, 0x3D, 0xED, 0xA2, 0xA7, 0xD8, 0xB0, 0x47, 0x7F, 0xE1, 0x88, 0x72, 0xE6, 0x2D, 
-    0xB8, 0x24, 0x67, 0xDB, 0xD7, 0xF8, 0x3B, 0xB9, 0x5A, 0x5A, 0x9D, 0x7C, 0x4E, 0xAA, 0x32, 0xDA, 
-    0x87, 0x9E, 0xE7, 0xD5, 0x30, 0xCD, 0xBB, 0x36, 0x04, 0xE6, 0x34, 0xC2, 0xB1, 0xBB, 0x6B, 0xE9, 
-    0xE4, 0xC0, 0x07, 0x91, 0x59, 0x51, 0xDB, 0xCE, 0xC1, 0x16, 0xD5, 0x44, 0x52, 0xAA, 0x22, 0x12, 
-    0x4B, 0xB8, 0x8A, 0xD6, 0xB0, 0x1C, 0x1B, 0x43, 0xD7, 0x3B, 0x6D, 0x53, 0x8B, 0xE0, 0xD0, 0x01, 
-    0xD6, 0x15, 0x72, 0xD2, 0x74, 0xDE, 0xF8, 0xD1, 0x46, 0x92, 0x0B, 0xEC, 0x1D, 0xB7, 0xFA, 0xAB, 
-    0x18, 0x5F, 0x94, 0x75, 0x99, 0x99, 0x15, 0x89, 0xF2, 0xEB, 0x68, 0x0C, 0x39, 0xA8, 0xFA, 0xB4, 
-    0x83, 0x95, 0xA8, 0x41, 0xB7, 0x31, 0xA4, 0x72, 0x5C, 0x38, 0x80, 0xF4, 0x35, 0x1F, 0x24, 0x48, 
-    0x1D, 0x48, 0x22, 0x96, 0x81, 0xCE, 0x8D, 0x76, 0x43, 0x38, 0xD5, 0x72, 0x4A, 0x68, 0x27, 0x91, 
-    0x08, 0xF8, 0x4D, 0x33, 0xDE, 0x9A, 0x8D, 0x28, 0x58, 0x0F, 0x3C, 0x68, 0xEA, 0x95, 0x3F, 0xF1, 
-    0xB0, 0x05, 0x6B, 0xFF, 0x04, 0x48, 0x6F, 0x99, 0x02, 0x82, 0x01, 0x00, 0x65, 0x8F, 0x41, 0x86, 
-    0x2E, 0x9A, 0x75, 0x7A, 0x96, 0x3F, 0x63, 0x69, 0x4B, 0xF9, 0xAB, 0x71, 0x79, 0xAB, 0x70, 0x2A, 
-    0x3B, 0xB7, 0x47, 0xEA, 0x53, 0x73, 0xAA, 0x21, 0x2F, 0x34, 0xE4, 0x29, 0x07, 0xD8, 0x68, 0x53, 
-    0xD1, 0x76, 0x91, 0x46, 0xC9, 0xF8, 0xAA, 0x25, 0x22, 0x54, 0x66, 0xF3, 0x0C, 0x05, 0x86, 0x94, 
-    0x65, 0x4F, 0xFB, 0x11, 0x8B, 0x1B, 0x3E, 0xF9, 0x7B, 0xF0, 0x63, 0xC6, 0x84, 0xEA, 0x40, 0xE8, 
-    0xB3, 0x8D, 0x1C, 0x99, 0x19, 0x5B, 0xD4, 0xC8, 0x48, 0x6B, 0x36, 0xBF, 0x66, 0xD3, 0x1E, 0xE2, 
-    0x04, 0x18, 0x06, 0xF5, 0x4E, 0x8E, 0xC7, 0xD6, 0x87, 0x4A, 0xD7, 0x58, 0x7F, 0x83, 0x16, 0xA9, 
-    0x40, 0x92, 0x7B, 0x9F, 0x1A, 0x86, 0x7B, 0x7C, 0xF9, 0x12, 0x46, 0xBF, 0x71, 0xE1, 0xB9, 0x38, 
-    0x59, 0x2F, 0xBA, 0x27, 0x88, 0xDA, 0xF8, 0x73, 0x35, 0x5A, 0x32, 0x18, 0xB5, 0xBB, 0xE5, 0x19, 
-    0x0F, 0x65, 0xC9, 0x93, 0x01, 0x9B, 0x96, 0x59, 0x31, 0x51, 0x23, 0xE0, 0x57, 0xE5, 0xD1, 0x63, 
-    0xE4, 0x0E, 0x0C, 0x21, 0x6C, 0x46, 0xF6, 0x7E, 0xD6, 0x45, 0xC5, 0xF2, 0x3C, 0x93, 0xFB, 0x64, 
-    0xD5, 0x6B, 0xF5, 0x66, 0x12, 0xBF, 0x47, 0xFD, 0x00, 0x4E, 0xA0, 0x7E, 0xCE, 0x96, 0x75, 0xE4, 
-    0xCB, 0xF1, 0x58, 0xD9, 0x0A, 0x4F, 0xC1, 0x05, 0x53, 0x77, 0xBD, 0x7A, 0x04, 0x82, 0x4E, 0x7E, 
-    0xC3, 0x37, 0x89, 0x25, 0x80, 0xC1, 0x19, 0x42, 0x90, 0x21, 0xD3, 0x53, 0xD0, 0x60, 0x1A, 0xF4, 
-    0xC1, 0xF4, 0x6D, 0xFD, 0xF4, 0xA7, 0xE8, 0x8E, 0xE8, 0x20, 0x70, 0xC4, 0xD1, 0x43, 0xFA, 0x39, 
-    0x30, 0xBB, 0x45, 0xD2, 0xA2, 0xC1, 0x9C, 0xDE, 0x44, 0xEF, 0x35, 0xFB, 0x09, 0xCA, 0xB0, 0x4F, 
-    0x7D, 0x1B, 0x4C, 0xB8, 0x60, 0x17, 0x1C, 0x38, 0xB1, 0xA1, 0x64, 0x92, 
+pub const ROOT_PRIVATE_KEY: [u8; 1769] = [
+    0x30, 0x82, 0x06, 0xE5, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x81, 0x00, 0xCA, 0x69, 0x8F, 0x00, 
+    0x0E, 0x09, 0xA0, 0x9A, 0x2D, 0xE6, 0xFC, 0xAC, 0x02, 0x46, 0xB7, 0x5C, 0xFB, 0xAE, 0x59, 0x9F, 
+    0x3F, 0xAD, 0xE7, 0x72, 0x9C, 0x7D, 0xC5, 0x48, 0x9A, 0x8F, 0x4C, 0x33, 0x0B, 0x4E, 0x1A, 0x97, 
+    0x95, 0xBF, 0x59, 0xA9, 0x4F, 0xB7, 0x9A, 0x43, 0x00, 0xD1, 0x80, 0x52, 0xC7, 0x2A, 0x5B, 0xA1, 
+    0xE2, 0x7E, 0x58, 0x14, 0xF8, 0x39, 0x5E, 0xD1, 0x31, 0x54, 0xC0, 0xBF, 0xF7, 0x46, 0x33, 0x7B, 
+    0xF1, 0x48, 0x85, 0x6E, 0xE0, 0x68, 0xD0, 0xCC, 0x74, 0x0F, 0x7D, 0x9B, 0xF5, 0x21, 0xCA, 0xB2, 
+    0xB6, 0x99, 0x64, 0x20, 0x6F, 0xB7, 0x71, 0xA4, 0xBA, 0x89, 0xB9, 0xDA, 0x38, 0xC5, 0x2A, 0x7F, 
+    0x44, 0x3F, 0xDA, 0xA5, 0x6A, 0x32, 0x67, 0xBA, 0x56, 0x67, 0x65, 0xF4, 0xAB, 0xDF, 0xD3, 0xC8, 
+    0x11, 0xC5, 0xAB, 0x31, 0x61, 0xFB, 0x25, 0xA7, 0x05, 0xBE, 0x2E, 0xA9, 0x45, 0x80, 0x85, 0xA7, 
+    0x19, 0xC3, 0xBD, 0x2F, 0x18, 0xD1, 0xD9, 0x08, 0xC0, 0xBE, 0xA5, 0xCD, 0x8F, 0xF9, 0x36, 0x71, 
+    0x38, 0x70, 0xD7, 0xF2, 0x10, 0x64, 0xFE, 0x9A, 0xB6, 0x98, 0xCB, 0xB0, 0x16, 0x1C, 0xFE, 0x45, 
+    0x26, 0x71, 0x5E, 0x7C, 0x99, 0x0C, 0xDD, 0xB2, 0x80, 0xE4, 0xE5, 0xA6, 0x46, 0x40, 0x73, 0xDA, 
+    0xB0, 0xF9, 0xB6, 0xFD, 0x5D, 0xD6, 0x03, 0x25, 0x1B, 0x0F, 0xD6, 0x03, 0x3F, 0x5D, 0xDA, 0xDE, 
+    0xA3, 0x23, 0xC1, 0x93, 0x71, 0x92, 0x92, 0xAE, 0xB3, 0x68, 0x25, 0x83, 0x7B, 0x3F, 0x1D, 0xFD, 
+    0x05, 0xDB, 0xA3, 0xDB, 0xB6, 0x57, 0xD8, 0x3E, 0x03, 0x83, 0xD3, 0x0B, 0x0F, 0xE3, 0xEF, 0x3A, 
+    0xBE, 0x6F, 0x92, 0x9B, 0x99, 0x1E, 0xA7, 0xB7, 0x82, 0xD4, 0x38, 0x4B, 0x09, 0xF3, 0xD3, 0xF5, 
+    0x77, 0x82, 0x6A, 0x19, 0xBD, 0x79, 0x8A, 0x96, 0x66, 0x58, 0xE9, 0xBF, 0x65, 0x15, 0xB9, 0x01, 
+    0xFD, 0x34, 0xC4, 0x42, 0x8F, 0x3A, 0x90, 0xCF, 0x6C, 0xA2, 0xC3, 0xD7, 0xBB, 0xD5, 0x0C, 0x67, 
+    0x10, 0xDA, 0x1C, 0xAC, 0x30, 0xDA, 0x50, 0xBD, 0x5D, 0x85, 0x4A, 0x47, 0xAC, 0xB1, 0xB2, 0x27, 
+    0xE8, 0xC9, 0x75, 0x1C, 0x3B, 0x93, 0xD4, 0x93, 0x5A, 0x51, 0x82, 0xF2, 0x66, 0x96, 0x5F, 0x24, 
+    0xB0, 0x30, 0x45, 0x5B, 0x9D, 0xD1, 0xE4, 0x66, 0xDF, 0xA6, 0xED, 0x59, 0x1F, 0x58, 0x52, 0x05, 
+    0x8B, 0x45, 0xD1, 0x9A, 0x3D, 0x08, 0x2E, 0x95, 0x1B, 0x08, 0x22, 0x0D, 0xAA, 0x49, 0xFB, 0x85, 
+    0x01, 0xBF, 0x83, 0x62, 0xFE, 0x21, 0x45, 0xFE, 0x73, 0x06, 0x85, 0x20, 0x06, 0x77, 0x3D, 0x9B, 
+    0x05, 0x0C, 0x2B, 0xB5, 0x89, 0x5A, 0x99, 0x4B, 0xAE, 0x4A, 0xDD, 0x93, 0x2F, 0xF9, 0x1D, 0xE4, 
+    0x6C, 0xB3, 0xF7, 0x0C, 0x42, 0x00, 0x02, 0x3E, 0x2D, 0x78, 0x01, 0xA9, 0x02, 0x03, 0x01, 0x00, 
+    0x01, 0x02, 0x82, 0x01, 0x81, 0x00, 0x86, 0x24, 0xC8, 0xF1, 0xA7, 0x5B, 0xF8, 0x04, 0xD6, 0x10, 
+    0xF4, 0x39, 0x66, 0xD4, 0xC8, 0xE6, 0xA5, 0xA1, 0x99, 0xA1, 0xB1, 0x89, 0x26, 0x0F, 0x4D, 0xE9, 
+    0x08, 0x5B, 0x22, 0x9B, 0x7F, 0x4B, 0x80, 0xDD, 0x85, 0x40, 0x1A, 0xAD, 0x12, 0xD5, 0xE3, 0x8F, 
+    0xF1, 0x7B, 0x20, 0x4A, 0xB7, 0xB9, 0xA4, 0x66, 0xCD, 0x0D, 0x8F, 0x56, 0x5E, 0x37, 0x9F, 0x7E, 
+    0x1D, 0xF9, 0x93, 0xB0, 0xF0, 0x81, 0x08, 0x76, 0x8C, 0xDE, 0x42, 0x3C, 0xE6, 0xB9, 0x61, 0x9D, 
+    0xF5, 0x6A, 0xDA, 0x2B, 0xFD, 0xF9, 0xE2, 0xCE, 0x3F, 0x50, 0x8B, 0x35, 0x43, 0x27, 0x40, 0x02, 
+    0x9A, 0x1D, 0x2A, 0xC6, 0xE5, 0xD5, 0xDA, 0xB3, 0xC8, 0x83, 0x49, 0x8E, 0xEB, 0xEF, 0x9E, 0x5E, 
+    0xC3, 0x61, 0xB9, 0xAB, 0x92, 0xE5, 0x41, 0x16, 0xF8, 0x7A, 0xEA, 0x54, 0x4F, 0x2D, 0x4E, 0x1B, 
+    0x2C, 0x8B, 0xF1, 0x81, 0x65, 0xD9, 0x26, 0xC7, 0x93, 0x4B, 0xF8, 0x06, 0x42, 0x15, 0xB9, 0x64, 
+    0x31, 0x6A, 0xDC, 0x9A, 0x3C, 0xB5, 0xEC, 0x09, 0xA4, 0x6C, 0x0A, 0x94, 0xB6, 0x78, 0xA5, 0x26, 
+    0xD9, 0x99, 0x5D, 0x14, 0x0C, 0x41, 0xA9, 0x96, 0x13, 0x69, 0x6E, 0x9D, 0xC9, 0x99, 0xD7, 0xB0, 
+    0xB0, 0x28, 0x81, 0xC5, 0xB0, 0xF0, 0xAE, 0x34, 0x3E, 0xD3, 0x9B, 0x60, 0x13, 0x46, 0xFC, 0xEE, 
+    0x3D, 0x6D, 0x54, 0xEE, 0xFC, 0xCC, 0x41, 0xE5, 0x7B, 0xF6, 0xBA, 0x30, 0x64, 0x3A, 0x1D, 0xAC, 
+    0xF2, 0x3E, 0x60, 0x81, 0xAB, 0xDF, 0x61, 0x75, 0x5C, 0xB6, 0x24, 0x27, 0xE4, 0x32, 0xA3, 0x60, 
+    0x6B, 0x96, 0xFA, 0xE5, 0xC8, 0xBE, 0x8C, 0xED, 0x48, 0xBD, 0x8B, 0xFB, 0x9C, 0x80, 0x3E, 0xAF, 
+    0x01, 0xFB, 0x82, 0x98, 0xC2, 0x08, 0x11, 0xAB, 0x71, 0x9A, 0xE1, 0xC3, 0xA8, 0x27, 0xBC, 0xFF, 
+    0x11, 0x9A, 0x05, 0xBC, 0x9B, 0xE6, 0xE0, 0x79, 0x8E, 0xC9, 0x76, 0x56, 0x42, 0x78, 0x6F, 0x24, 
+    0x5E, 0x9C, 0x81, 0x0D, 0x5E, 0xAD, 0x4C, 0x33, 0x25, 0x24, 0x70, 0x89, 0x9E, 0xD5, 0xD3, 0xB1, 
+    0x81, 0x2F, 0xBA, 0xAC, 0x9F, 0xA6, 0x6B, 0xEC, 0x2D, 0xDB, 0xDD, 0x4F, 0x97, 0x05, 0x6B, 0x77, 
+    0x55, 0xCF, 0xE2, 0x91, 0xE8, 0x67, 0xE3, 0xA2, 0x99, 0x53, 0xC3, 0xD6, 0x83, 0xF8, 0x0E, 0xAC, 
+    0xE0, 0x2E, 0x61, 0xF4, 0x64, 0x0A, 0x20, 0x35, 0xEB, 0x5B, 0x60, 0x43, 0x2F, 0x33, 0x6F, 0xEC, 
+    0x93, 0xA7, 0x92, 0x7A, 0xC6, 0xB7, 0x55, 0xB3, 0x46, 0x21, 0x8B, 0x47, 0x83, 0x84, 0xF1, 0x39, 
+    0xF7, 0xB3, 0xC7, 0x7E, 0xD8, 0x65, 0x52, 0xA5, 0x6A, 0x4B, 0xE6, 0x92, 0x8B, 0x32, 0x7A, 0xBD, 
+    0x64, 0xD3, 0xC0, 0xA6, 0x25, 0x32, 0xF8, 0x6A, 0xEE, 0xF3, 0xCE, 0x18, 0xAA, 0x48, 0x5D, 0x20, 
+    0xFB, 0x02, 0x8B, 0x69, 0x05, 0xD1, 0x02, 0x81, 0xC1, 0x00, 0xF1, 0xE9, 0x9B, 0x56, 0x65, 0x41, 
+    0xEF, 0x74, 0x0E, 0xF9, 0xF2, 0xD3, 0x28, 0xA6, 0xC7, 0xB9, 0x22, 0x61, 0x29, 0x2F, 0x8A, 0x39, 
+    0xF8, 0xAE, 0x5C, 0x7F, 0xCC, 0xAA, 0x9A, 0x4B, 0x94, 0x02, 0xF8, 0x05, 0xC3, 0x27, 0x18, 0x0E, 
+    0x2B, 0x81, 0x61, 0x87, 0x58, 0xF3, 0xC2, 0x40, 0xFB, 0x2A, 0xAA, 0x78, 0x8D, 0x75, 0x97, 0xA3, 
+    0xB9, 0xFD, 0xFA, 0x60, 0x95, 0x69, 0xC4, 0xF8, 0xED, 0xD4, 0xBA, 0x5D, 0xEC, 0x81, 0x78, 0x0B, 
+    0x48, 0xB2, 0xB5, 0x96, 0x18, 0xA2, 0xC2, 0xFD, 0xD3, 0x22, 0x15, 0xCD, 0xD5, 0xD9, 0xF9, 0x4A, 
+    0x45, 0x48, 0xA3, 0x85, 0x8C, 0xED, 0x75, 0x3B, 0x60, 0xB5, 0x03, 0x53, 0x44, 0x7A, 0x01, 0x3E, 
+    0xA0, 0x50, 0x8F, 0xA5, 0x63, 0x28, 0xEA, 0xD0, 0x8C, 0xB1, 0xAF, 0xB5, 0xAE, 0x21, 0x80, 0x9F, 
+    0x66, 0x40, 0x65, 0x64, 0x34, 0x6A, 0xE1, 0xC1, 0x24, 0x0A, 0x71, 0xA4, 0x02, 0xD8, 0x34, 0xA9, 
+    0xA4, 0x3E, 0x5E, 0x12, 0x56, 0x8D, 0x37, 0xF4, 0x96, 0xCB, 0xA6, 0xD3, 0x89, 0xF3, 0x49, 0xB8, 
+    0x01, 0xB6, 0x72, 0xB6, 0xD6, 0x1F, 0xB2, 0xBF, 0x94, 0x78, 0x30, 0x6F, 0xB8, 0x03, 0x61, 0x56, 
+    0x0E, 0xFA, 0x88, 0x73, 0x30, 0x13, 0x6B, 0xDD, 0x33, 0x11, 0x15, 0x3B, 0x01, 0x60, 0x7F, 0xF4, 
+    0xFE, 0xF5, 0x5E, 0xB4, 0x82, 0xC7, 0xBE, 0xD8, 0xCD, 0x85, 0x02, 0x81, 0xC1, 0x00, 0xD6, 0x33, 
+    0x16, 0xDE, 0x07, 0xAC, 0x4C, 0xB1, 0xAD, 0x9C, 0x49, 0x01, 0x6E, 0x55, 0x62, 0x31, 0x6A, 0x7A, 
+    0xEF, 0x0C, 0x09, 0xC6, 0x38, 0xD5, 0x6C, 0xBB, 0xFA, 0x40, 0x27, 0x4A, 0x0F, 0x76, 0xC6, 0x77, 
+    0x05, 0x57, 0x6C, 0x1D, 0xB3, 0x29, 0x43, 0x87, 0xF4, 0x96, 0x54, 0x20, 0x9B, 0x1D, 0x88, 0xA4, 
+    0xA6, 0x8D, 0xE8, 0x00, 0x27, 0xC1, 0xCF, 0x90, 0x91, 0xDD, 0x0E, 0xBB, 0x23, 0x94, 0xD2, 0x8C, 
+    0x47, 0xE8, 0x4D, 0xAA, 0x1C, 0x8C, 0xDD, 0x37, 0x28, 0x82, 0x93, 0xDC, 0x3D, 0x9B, 0x3E, 0x59, 
+    0x04, 0x0A, 0x74, 0xD0, 0x09, 0xC0, 0x6A, 0xBE, 0x0B, 0xF1, 0x75, 0x26, 0x8D, 0x33, 0x21, 0xC8, 
+    0x52, 0xE2, 0x62, 0x85, 0x51, 0x79, 0x64, 0x7A, 0x6E, 0xD9, 0xBB, 0x76, 0x73, 0xEC, 0x40, 0x4B, 
+    0xED, 0xF9, 0x2D, 0x34, 0xE3, 0x86, 0x07, 0xB8, 0x3F, 0xC5, 0x2F, 0xF3, 0xB2, 0x51, 0x31, 0xA0, 
+    0x69, 0xC9, 0x92, 0x0E, 0x15, 0xA3, 0x1F, 0xD9, 0x4A, 0x0D, 0x4F, 0x0F, 0x8D, 0x70, 0x23, 0x79, 
+    0xDC, 0xFC, 0x2A, 0x1F, 0x2C, 0x34, 0xD3, 0x0C, 0x38, 0x3B, 0x20, 0xF2, 0xF4, 0x85, 0x6B, 0x81, 
+    0x96, 0xF8, 0xE7, 0xC1, 0xAD, 0x89, 0x97, 0xE6, 0x92, 0x19, 0xC2, 0xAA, 0xEE, 0x3B, 0x2D, 0x3B, 
+    0xAC, 0x06, 0xFC, 0x8B, 0x9D, 0xFD, 0xD1, 0x53, 0xDA, 0xDF, 0x26, 0x97, 0x9A, 0xD5, 0x02, 0x81, 
+    0xC1, 0x00, 0xF1, 0x7C, 0xEF, 0xD2, 0x48, 0xF6, 0x8F, 0x20, 0xDE, 0x2A, 0x69, 0x5A, 0x9D, 0x44, 
+    0x10, 0x30, 0x21, 0xBF, 0xB8, 0x2B, 0x7A, 0xE2, 0xEF, 0xFA, 0xAE, 0xDF, 0xEC, 0xE1, 0x89, 0x71, 
+    0x54, 0xE9, 0xB9, 0xC9, 0x96, 0xCC, 0x99, 0xD8, 0xDB, 0x59, 0x26, 0x90, 0xC4, 0x1D, 0x61, 0x97, 
+    0x18, 0xA3, 0xB8, 0xD4, 0xEA, 0xF1, 0xAE, 0x54, 0x84, 0xC0, 0xA2, 0x86, 0x73, 0xE0, 0xC7, 0xFE, 
+    0x6E, 0xFC, 0x62, 0xA6, 0x8C, 0x07, 0x9A, 0x5C, 0x39, 0x50, 0x1C, 0xB1, 0x1F, 0x1A, 0xAB, 0x68, 
+    0x52, 0xB1, 0xBD, 0xEE, 0x62, 0x42, 0x5B, 0xF6, 0xE6, 0x3E, 0xE2, 0xED, 0xD8, 0x86, 0xDA, 0xF6, 
+    0x51, 0x4D, 0xA1, 0x6A, 0x27, 0xFB, 0x5A, 0xEE, 0xB7, 0x7E, 0x74, 0x46, 0xF7, 0x3B, 0xCB, 0x5C, 
+    0x30, 0x76, 0xD8, 0x1E, 0x97, 0x1B, 0x5E, 0x98, 0xC0, 0xAC, 0x1C, 0x0A, 0xF1, 0xC0, 0x98, 0x68, 
+    0x03, 0xA0, 0x61, 0x5D, 0x06, 0x71, 0xE9, 0xF0, 0x46, 0xC2, 0xF3, 0x89, 0x7E, 0xD9, 0x2E, 0x38, 
+    0x7D, 0xA8, 0x02, 0x7B, 0x3D, 0x44, 0x9E, 0x1C, 0x8F, 0xA9, 0x1F, 0xCE, 0xA0, 0xE5, 0xB7, 0xBC, 
+    0x43, 0x6B, 0xCF, 0x7E, 0x56, 0xC5, 0x19, 0x0F, 0x9D, 0x98, 0x3F, 0x4A, 0x2D, 0x7D, 0xD5, 0xB9, 
+    0x54, 0xD7, 0x02, 0xC8, 0x8A, 0x51, 0x58, 0xAA, 0xAB, 0x31, 0x2A, 0x3F, 0x2C, 0x26, 0x55, 0xBF, 
+    0x7B, 0x39, 0x02, 0x81, 0xC0, 0x0C, 0x68, 0xF7, 0x59, 0x33, 0xCE, 0x9A, 0xBE, 0xEC, 0x95, 0x12, 
+    0x71, 0xBF, 0xC7, 0xB8, 0xA1, 0xAE, 0x4E, 0xA3, 0x0C, 0xEA, 0x80, 0x0E, 0x88, 0xE6, 0xFC, 0xD9, 
+    0x19, 0xE0, 0x6C, 0xDD, 0x0A, 0x7F, 0xA3, 0x23, 0xAF, 0x15, 0xF7, 0x7E, 0x8A, 0xD4, 0x7B, 0xCB, 
+    0x02, 0xEE, 0xAA, 0xD8, 0xF1, 0xD4, 0x19, 0xDE, 0x00, 0x78, 0xC1, 0x91, 0x8C, 0x1C, 0x0F, 0x7F, 
+    0x33, 0xF4, 0x87, 0x89, 0x1F, 0x35, 0x37, 0xA5, 0x6E, 0xE3, 0x19, 0x09, 0x00, 0x6C, 0x4C, 0xA6, 
+    0xCF, 0x31, 0xEB, 0xDF, 0xB1, 0xDF, 0xE1, 0xDE, 0x67, 0x10, 0xAF, 0x80, 0xF1, 0x21, 0xFE, 0x12, 
+    0xC9, 0x11, 0x85, 0x83, 0x46, 0xC4, 0x1D, 0x4C, 0x18, 0x0B, 0xA7, 0x37, 0xBA, 0x35, 0xC5, 0x16, 
+    0x29, 0x0D, 0x40, 0x66, 0xA4, 0xF8, 0x70, 0xAD, 0xBF, 0xF3, 0x0B, 0x8E, 0x67, 0x14, 0x89, 0x6B, 
+    0x40, 0x6C, 0x6F, 0xCD, 0x14, 0x01, 0x31, 0x0F, 0x0F, 0xFB, 0xA3, 0x4F, 0x43, 0x9D, 0x33, 0xC4, 
+    0xA3, 0x92, 0xC2, 0x0E, 0xEA, 0xC1, 0x53, 0x6D, 0x27, 0x3A, 0xF5, 0x85, 0x65, 0x26, 0x19, 0x1E, 
+    0x24, 0xE6, 0xDA, 0xCC, 0xA9, 0xF2, 0x39, 0x96, 0xDA, 0xA2, 0xEA, 0xC8, 0xB8, 0x21, 0x11, 0xDD, 
+    0xC3, 0x1A, 0x51, 0x36, 0xEE, 0x3C, 0xC7, 0xA9, 0x46, 0xDA, 0x58, 0xE8, 0x75, 0x6D, 0x2C, 0x53, 
+    0x90, 0xFC, 0x36, 0x6A, 0x65, 0x02, 0x81, 0xC1, 0x00, 0x90, 0x17, 0x57, 0x12, 0x83, 0x17, 0xC8, 
+    0x4C, 0x8E, 0xF7, 0x72, 0x9A, 0x8E, 0xC8, 0x6B, 0x73, 0x1A, 0x73, 0x43, 0x8A, 0x11, 0xBD, 0x76, 
+    0xC6, 0x56, 0xEE, 0xE9, 0xCF, 0xFA, 0x20, 0x67, 0x8C, 0x20, 0xEF, 0x7E, 0xDF, 0x0B, 0x7A, 0xF9, 
+    0xA8, 0x43, 0x62, 0xE1, 0x94, 0x4D, 0xB4, 0x47, 0xDF, 0xBD, 0xD8, 0x4E, 0xF8, 0x12, 0xCF, 0x9D, 
+    0x4B, 0x24, 0x64, 0x90, 0x79, 0xA3, 0xF6, 0x8C, 0x5A, 0xDA, 0xBC, 0x97, 0x1A, 0x2B, 0xBF, 0x61, 
+    0x6D, 0x21, 0xBB, 0xAB, 0xD0, 0x03, 0x9A, 0xA4, 0x38, 0x9B, 0x1A, 0x92, 0x36, 0xA4, 0xAA, 0xB0, 
+    0x70, 0x05, 0x2D, 0x90, 0x00, 0x60, 0x09, 0x3C, 0x0C, 0x00, 0xA1, 0xFE, 0x36, 0x39, 0x29, 0x15, 
+    0x8B, 0xC1, 0x34, 0x82, 0x4E, 0x36, 0xAB, 0xF3, 0x73, 0x1C, 0x68, 0x7D, 0x5D, 0x1A, 0x18, 0xA1, 
+    0x53, 0x31, 0xD0, 0x22, 0x14, 0xF6, 0x22, 0x3A, 0xB5, 0x8D, 0xDC, 0x3C, 0x24, 0x56, 0x38, 0x34, 
+    0x01, 0xA2, 0x1F, 0x57, 0x05, 0xC3, 0x84, 0xBD, 0xFC, 0xED, 0xB1, 0xAA, 0x37, 0xA0, 0x86, 0xFA, 
+    0x45, 0x74, 0x87, 0x9F, 0xC0, 0x16, 0xAD, 0x8E, 0x65, 0xA0, 0x37, 0x00, 0x09, 0x52, 0x6A, 0x38, 
+    0x65, 0x6B, 0xB1, 0xE4, 0xAE, 0xCC, 0xD4, 0xC9, 0xEB, 0x9D, 0x34, 0x72, 0x72, 0xAE, 0xB5, 0xC8, 
+    0xF6, 0x50, 0x85, 0xF7, 0x8C, 0xCE, 0x16, 0xE1, 0x09, 
 ];
 
-pub const NODE_PUBLIC_KEY: [u8; 550] = [
-    0x30, 0x82, 0x02, 0x22, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 
-    0x01, 0x05, 0x00, 0x03, 0x82, 0x02, 0x0F, 0x00, 0x30, 0x82, 0x02, 0x0A, 0x02, 0x82, 0x02, 0x01, 
-    0x00, 0xB7, 0xFF, 0xBF, 0x35, 0x21, 0xB3, 0xC1, 0xBB, 0x8F, 0x3B, 0x83, 0x9B, 0x9E, 0x3B, 0x2E, 
-    0x47, 0xDC, 0x67, 0xDA, 0xF7, 0x90, 0x1C, 0x37, 0x32, 0x7C, 0xC8, 0x8A, 0x90, 0xD3, 0x1F, 0x43, 
-    0x83, 0x3E, 0x96, 0xCF, 0x03, 0x8B, 0x0B, 0xE6, 0xBB, 0x97, 0xB9, 0xC4, 0x2E, 0xBF, 0xF3, 0xC1, 
-    0xAB, 0xC8, 0x9E, 0x97, 0xC3, 0xEE, 0x7D, 0x4C, 0xB2, 0x8E, 0x56, 0x16, 0xA4, 0xBD, 0x66, 0x9B, 
-    0xF7, 0x44, 0x2A, 0x19, 0x22, 0xA1, 0x1C, 0x87, 0x4B, 0xF8, 0x4B, 0x73, 0x89, 0xC7, 0x9E, 0xBE, 
-    0x09, 0x1C, 0x37, 0x68, 0xAE, 0x1A, 0x42, 0x74, 0x1D, 0xB4, 0x15, 0xA2, 0x59, 0xC1, 0x6D, 0xB6, 
-    0x24, 0xEC, 0x8A, 0x20, 0x53, 0x24, 0x53, 0x48, 0xE8, 0x10, 0x94, 0x7F, 0xBA, 0xDD, 0xE7, 0x9F, 
-    0x8D, 0xEB, 0xC0, 0x93, 0x26, 0x74, 0x7C, 0xC8, 0x8B, 0xA0, 0x6D, 0x2B, 0x8B, 0x04, 0x9D, 0x2F, 
-    0xDF, 0x0A, 0x83, 0x72, 0x25, 0x06, 0x89, 0xC7, 0xD4, 0x27, 0xBF, 0x99, 0x8F, 0xF3, 0x2D, 0xA6, 
-    0x9B, 0xF2, 0x78, 0x8C, 0xDA, 0x2E, 0x8D, 0xAC, 0x94, 0xCB, 0xA7, 0xFD, 0xCD, 0x39, 0x09, 0xE4, 
-    0xC3, 0x22, 0x59, 0xC4, 0xAC, 0x80, 0x84, 0x56, 0x55, 0xA8, 0xE7, 0x7C, 0x70, 0x37, 0x9C, 0x5B, 
-    0x46, 0x3A, 0xDF, 0xD8, 0x3A, 0xA3, 0x67, 0x98, 0x96, 0xC5, 0x90, 0x56, 0x7C, 0x67, 0xE2, 0xFE, 
-    0x1A, 0xD0, 0x80, 0xE2, 0x8B, 0xF5, 0x6C, 0x75, 0x16, 0x77, 0xDF, 0x5B, 0x76, 0x36, 0xA9, 0xC9, 
-    0xC9, 0xB9, 0xC4, 0x04, 0xF1, 0x8A, 0xB9, 0xBC, 0xA8, 0x16, 0x41, 0xC5, 0x54, 0xA7, 0x51, 0xF3, 
-    0x2A, 0x39, 0x80, 0x55, 0x6A, 0xB2, 0xBF, 0x29, 0xD0, 0x40, 0x9E, 0x2A, 0x59, 0xA9, 0xEB, 0xA8, 
-    0xBF, 0x32, 0x3F, 0x54, 0x10, 0x45, 0x1B, 0x64, 0x3B, 0x15, 0x26, 0x2C, 0x37, 0xB3, 0xA0, 0x9E, 
-    0xE9, 0xAB, 0x55, 0x34, 0x82, 0xD5, 0xA8, 0xF0, 0x7C, 0xC5, 0x1B, 0xA1, 0x30, 0x75, 0x2D, 0x9D, 
-    0xB3, 0xEC, 0xF7, 0xE6, 0x54, 0x4B, 0xE8, 0xBB, 0x59, 0xFB, 0xD4, 0x35, 0xA3, 0x7F, 0xA2, 0xF6, 
-    0x95, 0x9F, 0x7F, 0x65, 0x41, 0x4F, 0x58, 0x1E, 0x92, 0xA4, 0x43, 0x4A, 0x66, 0xB6, 0xB6, 0x3D, 
-    0x6B, 0x85, 0xAE, 0x7D, 0x2A, 0x82, 0xD1, 0xB3, 0xBD, 0xF1, 0x4A, 0x4B, 0x90, 0x86, 0x56, 0x41, 
-    0x39, 0x2F, 0x97, 0x7F, 0x78, 0xCE, 0x59, 0x7A, 0xD5, 0x40, 0xDB, 0x0D, 0x5F, 0x44, 0x69, 0xBC, 
-    0xA0, 0xDF, 0xEC, 0x3E, 0x83, 0xAB, 0x9A, 0xAA, 0x46, 0xAE, 0xD0, 0x8D, 0x67, 0x9C, 0x47, 0x3B, 
-    0xFA, 0xD1, 0x90, 0xD9, 0x1B, 0x48, 0x43, 0xED, 0x1E, 0xEE, 0x0A, 0x25, 0x46, 0xDE, 0xFE, 0x8C, 
-    0x1A, 0xDA, 0xA5, 0xAD, 0xC8, 0x4F, 0x33, 0x3B, 0x93, 0x48, 0x10, 0xD9, 0xF8, 0xA4, 0xC0, 0x68, 
-    0x45, 0x71, 0x85, 0x1D, 0xCA, 0xC8, 0x5A, 0xDC, 0x02, 0x6A, 0x62, 0x0E, 0x80, 0xBC, 0xAD, 0x53, 
-    0xE3, 0x26, 0x1F, 0x5B, 0xE8, 0x4F, 0x37, 0xA9, 0x7F, 0x36, 0xDF, 0x3B, 0x35, 0x8D, 0xF6, 0x34, 
-    0x9F, 0xB3, 0x84, 0xC3, 0x1E, 0xA8, 0xD2, 0x0E, 0x0F, 0x13, 0x1E, 0xEB, 0xD1, 0x2C, 0x9F, 0x84, 
-    0x3E, 0x62, 0xF4, 0x07, 0x8A, 0x6E, 0xC8, 0x56, 0xA1, 0xB0, 0x42, 0xF7, 0x0B, 0xF9, 0xD7, 0x36, 
-    0x22, 0xE2, 0xB2, 0x44, 0xA7, 0x3E, 0x4D, 0x9E, 0x6B, 0x3C, 0x8B, 0x2E, 0xEC, 0x13, 0x21, 0x3A, 
-    0xBA, 0x3E, 0x4B, 0x98, 0x5F, 0x6B, 0x8B, 0x5F, 0x90, 0x05, 0x11, 0x7D, 0xE9, 0xF3, 0x3A, 0xBD, 
-    0x0A, 0xAE, 0x49, 0x6E, 0xA6, 0x3C, 0x4E, 0xF0, 0xFA, 0xF1, 0xDE, 0xEF, 0xDC, 0x20, 0xC4, 0x2F, 
-    0xD1, 0x61, 0x3B, 0xAF, 0xA4, 0xE2, 0x92, 0x2B, 0xF3, 0x6B, 0x17, 0xAD, 0x95, 0x11, 0x4C, 0x90, 
-    0x5F, 0x02, 0x03, 0x01, 0x00, 0x01, 
+pub const NODE_PUBLIC_KEY: [u8; 422] = [
+    0x30, 0x82, 0x01, 0xA2, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 
+    0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x8F, 0x00, 0x30, 0x82, 0x01, 0x8A, 0x02, 0x82, 0x01, 0x81, 
+    0x00, 0xCB, 0x0E, 0x66, 0x6E, 0xF3, 0x55, 0x59, 0x8E, 0x58, 0x1A, 0x85, 0x60, 0x7D, 0x2D, 0x54, 
+    0x4D, 0x48, 0xD4, 0xEC, 0x68, 0xF0, 0xF0, 0x86, 0x68, 0xDC, 0x9B, 0xBF, 0xCC, 0xE9, 0xCA, 0x84, 
+    0xE5, 0x4D, 0x67, 0xBA, 0x24, 0xB2, 0x89, 0xA1, 0x6A, 0x8D, 0xD9, 0x53, 0xA3, 0xB5, 0xF9, 0xF1, 
+    0x09, 0x97, 0xE3, 0xA2, 0x5E, 0x91, 0x7E, 0x9B, 0xD5, 0xDB, 0xA8, 0x32, 0xB3, 0x4F, 0xE8, 0x41, 
+    0x49, 0x2E, 0x62, 0x69, 0xB3, 0xC5, 0x56, 0xD9, 0xB3, 0x75, 0x4B, 0xF9, 0x09, 0xA6, 0xE9, 0xBD, 
+    0xD0, 0x87, 0xDA, 0x20, 0xF7, 0x6A, 0x8D, 0x93, 0x02, 0x6F, 0x51, 0xB8, 0x65, 0x1B, 0x77, 0xCA, 
+    0xE2, 0x75, 0x15, 0x9E, 0x94, 0x45, 0x69, 0x15, 0x94, 0xF3, 0x9F, 0x7C, 0xBD, 0x90, 0xB3, 0x27, 
+    0x8C, 0xBA, 0x38, 0x32, 0x5E, 0xDD, 0x84, 0x1C, 0x7F, 0x18, 0xA9, 0x93, 0x88, 0x5A, 0x1B, 0x3E, 
+    0x96, 0xA3, 0x69, 0x7C, 0x82, 0xFD, 0x73, 0x17, 0xC3, 0x65, 0x1C, 0xA3, 0x4D, 0x6D, 0x3F, 0x4E, 
+    0x81, 0x73, 0x3C, 0x47, 0x64, 0x34, 0xD7, 0xC9, 0x32, 0xA7, 0x9C, 0xD8, 0xC9, 0x78, 0xE5, 0xB9, 
+    0x65, 0xBD, 0x95, 0xD4, 0xF2, 0x4B, 0xB5, 0xD5, 0xCA, 0x44, 0xD9, 0x04, 0x7B, 0xCF, 0x77, 0x32, 
+    0x5F, 0xAF, 0xD4, 0x64, 0x32, 0x97, 0x8E, 0x06, 0x61, 0x0A, 0xCD, 0xD5, 0xA0, 0x50, 0x8D, 0xD1, 
+    0xA8, 0xBF, 0x15, 0xB8, 0x81, 0xA8, 0x40, 0xBC, 0x6D, 0x82, 0x6B, 0x69, 0xA9, 0x70, 0x4D, 0xA3, 
+    0x42, 0x53, 0x6A, 0xD3, 0xE7, 0x47, 0xDD, 0x46, 0x9F, 0xA8, 0xA4, 0x0A, 0x5D, 0xC6, 0x4F, 0x1C, 
+    0x38, 0xFF, 0xC7, 0x94, 0xAD, 0xB8, 0xB6, 0x7F, 0x25, 0xA1, 0x21, 0x5A, 0x97, 0x6E, 0x06, 0x39, 
+    0xDF, 0xEB, 0x8F, 0xF4, 0x43, 0x64, 0xCD, 0xB4, 0x1C, 0xDD, 0x2B, 0xC9, 0x6D, 0x5F, 0xAC, 0x83, 
+    0xD8, 0x0C, 0xB0, 0x9F, 0x2A, 0xDA, 0xC0, 0xC3, 0x4E, 0x04, 0xC2, 0xF0, 0x09, 0x0B, 0x10, 0xBD, 
+    0x19, 0x00, 0x24, 0x32, 0xD1, 0xF4, 0x0A, 0x50, 0x44, 0xCB, 0xBE, 0x70, 0xD4, 0xDA, 0x63, 0xBC, 
+    0xFC, 0xDC, 0xAD, 0x24, 0x63, 0x07, 0x66, 0x96, 0xE6, 0xA3, 0x86, 0xB9, 0xDD, 0xDE, 0x4B, 0xF1, 
+    0xB5, 0x49, 0x94, 0x10, 0xE2, 0xF5, 0xD0, 0xF1, 0xAE, 0xDC, 0xCB, 0x22, 0xE8, 0xAE, 0x26, 0xFF, 
+    0xD6, 0xFE, 0xE4, 0xDA, 0x5F, 0x70, 0xD4, 0xF7, 0x9A, 0xA0, 0x78, 0xFB, 0x84, 0x69, 0x0B, 0xB7, 
+    0x71, 0xAD, 0xEC, 0x18, 0xB4, 0xA7, 0x38, 0x9A, 0xC8, 0xCB, 0x9A, 0x1C, 0x30, 0x44, 0xFB, 0xF3, 
+    0xB5, 0xFF, 0x95, 0x53, 0x16, 0x50, 0xE8, 0x94, 0x06, 0xCF, 0xA2, 0x94, 0xB6, 0x48, 0x83, 0xA0, 
+    0xAF, 0xA7, 0x87, 0x8C, 0xCA, 0xE7, 0x1F, 0xEA, 0x4A, 0x5B, 0x14, 0x54, 0x6A, 0x55, 0xDF, 0x3E, 
+    0xCF, 0x02, 0x03, 0x01, 0x00, 0x01, 
 ];
 
-pub const NODE_PRIVATE_KEY: [u8; 2349] = [
-    0x30, 0x82, 0x09, 0x29, 0x02, 0x01, 0x00, 0x02, 0x82, 0x02, 0x01, 0x00, 0xB7, 0xFF, 0xBF, 0x35, 
-    0x21, 0xB3, 0xC1, 0xBB, 0x8F, 0x3B, 0x83, 0x9B, 0x9E, 0x3B, 0x2E, 0x47, 0xDC, 0x67, 0xDA, 0xF7, 
-    0x90, 0x1C, 0x37, 0x32, 0x7C, 0xC8, 0x8A, 0x90, 0xD3, 0x1F, 0x43, 0x83, 0x3E, 0x96, 0xCF, 0x03, 
-    0x8B, 0x0B, 0xE6, 0xBB, 0x97, 0xB9, 0xC4, 0x2E, 0xBF, 0xF3, 0xC1, 0xAB, 0xC8, 0x9E, 0x97, 0xC3, 
-    0xEE, 0x7D, 0x4C, 0xB2, 0x8E, 0x56, 0x16, 0xA4, 0xBD, 0x66, 0x9B, 0xF7, 0x44, 0x2A, 0x19, 0x22, 
-    0xA1, 0x1C, 0x87, 0x4B, 0xF8, 0x4B, 0x73, 0x89, 0xC7, 0x9E, 0xBE, 0x09, 0x1C, 0x37, 0x68, 0xAE, 
-    0x1A, 0x42, 0x74, 0x1D, 0xB4, 0x15, 0xA2, 0x59, 0xC1, 0x6D, 0xB6, 0x24, 0xEC, 0x8A, 0x20, 0x53, 
-    0x24, 0x53, 0x48, 0xE8, 0x10, 0x94, 0x7F, 0xBA, 0xDD, 0xE7, 0x9F, 0x8D, 0xEB, 0xC0, 0x93, 0x26, 
-    0x74, 0x7C, 0xC8, 0x8B, 0xA0, 0x6D, 0x2B, 0x8B, 0x04, 0x9D, 0x2F, 0xDF, 0x0A, 0x83, 0x72, 0x25, 
-    0x06, 0x89, 0xC7, 0xD4, 0x27, 0xBF, 0x99, 0x8F, 0xF3, 0x2D, 0xA6, 0x9B, 0xF2, 0x78, 0x8C, 0xDA, 
-    0x2E, 0x8D, 0xAC, 0x94, 0xCB, 0xA7, 0xFD, 0xCD, 0x39, 0x09, 0xE4, 0xC3, 0x22, 0x59, 0xC4, 0xAC, 
-    0x80, 0x84, 0x56, 0x55, 0xA8, 0xE7, 0x7C, 0x70, 0x37, 0x9C, 0x5B, 0x46, 0x3A, 0xDF, 0xD8, 0x3A, 
-    0xA3, 0x67, 0x98, 0x96, 0xC5, 0x90, 0x56, 0x7C, 0x67, 0xE2, 0xFE, 0x1A, 0xD0, 0x80, 0xE2, 0x8B, 
-    0xF5, 0x6C, 0x75, 0x16, 0x77, 0xDF, 0x5B, 0x76, 0x36, 0xA9, 0xC9, 0xC9, 0xB9, 0xC4, 0x04, 0xF1, 
-    0x8A, 0xB9, 0xBC, 0xA8, 0x16, 0x41, 0xC5, 0x54, 0xA7, 0x51, 0xF3, 0x2A, 0x39, 0x80, 0x55, 0x6A, 
-    0xB2, 0xBF, 0x29, 0xD0, 0x40, 0x9E, 0x2A, 0x59, 0xA9, 0xEB, 0xA8, 0xBF, 0x32, 0x3F, 0x54, 0x10, 
-    0x45, 0x1B, 0x64, 0x3B, 0x15, 0x26, 0x2C, 0x37, 0xB3, 0xA0, 0x9E, 0xE9, 0xAB, 0x55, 0x34, 0x82, 
-    0xD5, 0xA8, 0xF0, 0x7C, 0xC5, 0x1B, 0xA1, 0x30, 0x75, 0x2D, 0x9D, 0xB3, 0xEC, 0xF7, 0xE6, 0x54, 
-    0x4B, 0xE8, 0xBB, 0x59, 0xFB, 0xD4, 0x35, 0xA3, 0x7F, 0xA2, 0xF6, 0x95, 0x9F, 0x7F, 0x65, 0x41, 
-    0x4F, 0x58, 0x1E, 0x92, 0xA4, 0x43, 0x4A, 0x66, 0xB6, 0xB6, 0x3D, 0x6B, 0x85, 0xAE, 0x7D, 0x2A, 
-    0x82, 0xD1, 0xB3, 0xBD, 0xF1, 0x4A, 0x4B, 0x90, 0x86, 0x56, 0x41, 0x39, 0x2F, 0x97, 0x7F, 0x78, 
-    0xCE, 0x59, 0x7A, 0xD5, 0x40, 0xDB, 0x0D, 0x5F, 0x44, 0x69, 0xBC, 0xA0, 0xDF, 0xEC, 0x3E, 0x83, 
-    0xAB, 0x9A, 0xAA, 0x46, 0xAE, 0xD0, 0x8D, 0x67, 0x9C, 0x47, 0x3B, 0xFA, 0xD1, 0x90, 0xD9, 0x1B, 
-    0x48, 0x43, 0xED, 0x1E, 0xEE, 0x0A, 0x25, 0x46, 0xDE, 0xFE, 0x8C, 0x1A, 0xDA, 0xA5, 0xAD, 0xC8, 
-    0x4F, 0x33, 0x3B, 0x93, 0x48, 0x10, 0xD9, 0xF8, 0xA4, 0xC0, 0x68, 0x45, 0x71, 0x85, 0x1D, 0xCA, 
-    0xC8, 0x5A, 0xDC, 0x02, 0x6A, 0x62, 0x0E, 0x80, 0xBC, 0xAD, 0x53, 0xE3, 0x26, 0x1F, 0x5B, 0xE8, 
-    0x4F, 0x37, 0xA9, 0x7F, 0x36, 0xDF, 0x3B, 0x35, 0x8D, 0xF6, 0x34, 0x9F, 0xB3, 0x84, 0xC3, 0x1E, 
-    0xA8, 0xD2, 0x0E, 0x0F, 0x13, 0x1E, 0xEB, 0xD1, 0x2C, 0x9F, 0x84, 0x3E, 0x62, 0xF4, 0x07, 0x8A, 
-    0x6E, 0xC8, 0x56, 0xA1, 0xB0, 0x42, 0xF7, 0x0B, 0xF9, 0xD7, 0x36, 0x22, 0xE2, 0xB2, 0x44, 0xA7, 
-    0x3E, 0x4D, 0x9E, 0x6B, 0x3C, 0x8B, 0x2E, 0xEC, 0x13, 0x21, 0x3A, 0xBA, 0x3E, 0x4B, 0x98, 0x5F, 
-    0x6B, 0x8B, 0x5F, 0x90, 0x05, 0x11, 0x7D, 0xE9, 0xF3, 0x3A, 0xBD, 0x0A, 0xAE, 0x49, 0x6E, 0xA6, 
-    0x3C, 0x4E, 0xF0, 0xFA, 0xF1, 0xDE, 0xEF, 0xDC, 0x20, 0xC4, 0x2F, 0xD1, 0x61, 0x3B, 0xAF, 0xA4, 
-    0xE2, 0x92, 0x2B, 0xF3, 0x6B, 0x17, 0xAD, 0x95, 0x11, 0x4C, 0x90, 0x5F, 0x02, 0x03, 0x01, 0x00, 
-    0x01, 0x02, 0x82, 0x02, 0x01, 0x00, 0xA2, 0x95, 0x3C, 0x2A, 0x41, 0x96, 0x69, 0xA8, 0x46, 0x9E, 
-    0xEA, 0xE2, 0xB6, 0x05, 0x4B, 0x16, 0xBA, 0x5D, 0x96, 0x71, 0x4C, 0x08, 0x72, 0x89, 0x8D, 0x13, 
-    0x52, 0xC5, 0x37, 0x98, 0x17, 0x7A, 0xBF, 0xF2, 0x58, 0x07, 0xA4, 0x74, 0xA6, 0xB3, 0xBA, 0x14, 
-    0xAE, 0x92, 0x34, 0x90, 0xB9, 0xE0, 0x05, 0xCC, 0x85, 0x03, 0xDF, 0x17, 0x1E, 0x8F, 0x64, 0x10, 
-    0x13, 0xC0, 0x0B, 0x8F, 0xC0, 0x5E, 0xD3, 0xFF, 0x72, 0xE8, 0x53, 0x7E, 0x36, 0xDA, 0xDD, 0x12, 
-    0x26, 0x8C, 0x67, 0x34, 0x10, 0x6D, 0x52, 0x5E, 0x6F, 0x83, 0xEF, 0xB6, 0x2A, 0x8E, 0x18, 0x93, 
-    0x49, 0x3A, 0x90, 0x1D, 0x56, 0x65, 0xF8, 0x10, 0xF1, 0x11, 0x26, 0x36, 0xE5, 0x64, 0x11, 0x4A, 
-    0x76, 0x36, 0xF3, 0x5F, 0x78, 0x6F, 0xDA, 0x11, 0xF6, 0xB4, 0x73, 0x17, 0xD3, 0xC8, 0xF4, 0xBF, 
-    0xA2, 0x4B, 0x1B, 0x8F, 0x9D, 0x3E, 0x33, 0x37, 0x04, 0xC4, 0x4C, 0xAB, 0xB0, 0x43, 0xF9, 0xBF, 
-    0x66, 0x7C, 0x78, 0xFF, 0x2C, 0x89, 0xFD, 0xCD, 0xA1, 0x80, 0x24, 0xC4, 0x90, 0xEB, 0x85, 0xAC, 
-    0xF2, 0x29, 0xC5, 0xAD, 0xC5, 0x52, 0xDB, 0x66, 0x80, 0xCF, 0x80, 0x5B, 0xEF, 0x41, 0x8F, 0x96, 
-    0xC4, 0x31, 0x10, 0x22, 0x7B, 0xD0, 0x69, 0xB3, 0x63, 0x88, 0x24, 0xDD, 0x24, 0x4A, 0x8D, 0x55, 
-    0xC5, 0xE5, 0xF5, 0x91, 0xF0, 0xC0, 0x56, 0xDE, 0x9B, 0xCF, 0xD9, 0xD3, 0xB4, 0xFE, 0x5E, 0x7B, 
-    0xA1, 0x80, 0xAA, 0x3A, 0x8B, 0x10, 0x51, 0xB2, 0x30, 0x40, 0x12, 0x39, 0x9E, 0xC6, 0xD3, 0xAB, 
-    0xD8, 0x26, 0xBE, 0x16, 0x3E, 0x8C, 0x5F, 0xF4, 0xD3, 0x05, 0x0D, 0xDE, 0xB6, 0x9E, 0xCA, 0x8A, 
-    0x37, 0x97, 0xB4, 0xFA, 0x83, 0xC8, 0x36, 0x29, 0x19, 0x29, 0xAB, 0x36, 0xD1, 0xF1, 0x16, 0xF5, 
-    0xFC, 0xFA, 0x57, 0x21, 0xA5, 0x68, 0x0A, 0x7F, 0x84, 0x0B, 0xF6, 0x95, 0xCA, 0x88, 0x2B, 0x74, 
-    0x42, 0x76, 0xD4, 0xB3, 0xC4, 0x29, 0x16, 0x4A, 0xB9, 0x65, 0x2B, 0xCD, 0x46, 0x52, 0x89, 0xF0, 
-    0x0F, 0x8F, 0x0E, 0xFB, 0x61, 0xE2, 0xC1, 0x50, 0xFD, 0xBD, 0x59, 0xEC, 0x55, 0xDC, 0x5E, 0xF1, 
-    0x9F, 0x2A, 0x94, 0x14, 0x5D, 0xDB, 0x58, 0xCB, 0xE8, 0x10, 0x8C, 0x00, 0xED, 0x5D, 0x93, 0xAA, 
-    0x91, 0xB4, 0xBB, 0xB3, 0xCB, 0x55, 0xF9, 0x27, 0x70, 0x23, 0x94, 0xE2, 0x23, 0x56, 0x04, 0xA2, 
-    0xDC, 0xFC, 0xAA, 0x6A, 0x98, 0xDE, 0xBC, 0xE4, 0x4B, 0x2B, 0xAE, 0xD8, 0x65, 0xF8, 0x27, 0xD8, 
-    0x78, 0xE4, 0x57, 0x7C, 0xF0, 0xB1, 0x0D, 0xB2, 0x80, 0x0F, 0x3A, 0xCE, 0xC1, 0xB9, 0xA9, 0xCA, 
-    0xD5, 0x74, 0xFB, 0x1F, 0xE2, 0x49, 0x28, 0xC3, 0x52, 0xAB, 0xB4, 0x38, 0xDD, 0xDC, 0x6A, 0x88, 
-    0xD6, 0xA5, 0xCE, 0x08, 0x64, 0xB1, 0x75, 0x01, 0x8A, 0xCB, 0xEC, 0x8C, 0x57, 0x53, 0x5B, 0xD2, 
-    0x8D, 0x90, 0xE8, 0x29, 0xA3, 0xFC, 0x5F, 0x50, 0x7A, 0xFC, 0x26, 0xB8, 0xA9, 0x9F, 0x39, 0x94, 
-    0xDD, 0xFE, 0x12, 0x84, 0x3A, 0x0A, 0x64, 0x81, 0x11, 0x0A, 0x37, 0xD1, 0x8D, 0xBD, 0xBD, 0x53, 
-    0x5F, 0xC2, 0xD1, 0x13, 0x69, 0xD2, 0xA9, 0xA7, 0xA9, 0xFE, 0xF6, 0x88, 0xEF, 0xBC, 0x65, 0xFF, 
-    0x81, 0xEA, 0x57, 0x5B, 0x45, 0xEB, 0x52, 0xFD, 0x54, 0xAA, 0x75, 0x8F, 0x4B, 0x01, 0x83, 0xB2, 
-    0x12, 0x2A, 0x9D, 0x79, 0xE0, 0x57, 0x07, 0x9C, 0x65, 0x79, 0x1D, 0x12, 0x7B, 0x10, 0x41, 0x99, 
-    0x65, 0x63, 0x14, 0xED, 0x0C, 0x80, 0x0F, 0x74, 0x83, 0x0E, 0xED, 0x79, 0x33, 0x9A, 0x12, 0x96, 
-    0x62, 0x39, 0x6F, 0xD3, 0x57, 0x30, 0x97, 0x77, 0xCB, 0x2A, 0xE0, 0xA5, 0x30, 0x42, 0xCE, 0xDF, 
-    0xDD, 0x31, 0xD5, 0xCF, 0x49, 0xD9, 0x02, 0x82, 0x01, 0x01, 0x00, 0xDF, 0xB2, 0xC5, 0x6B, 0xBE, 
-    0x77, 0x50, 0x8E, 0x84, 0xB5, 0xA8, 0x6E, 0x24, 0x81, 0xE1, 0x5C, 0x25, 0x9F, 0x79, 0x27, 0xD4, 
-    0x61, 0xC3, 0xA1, 0xCD, 0xBD, 0xAE, 0xB0, 0xBD, 0xA3, 0xBA, 0x95, 0x2E, 0x59, 0x00, 0x88, 0xE5, 
-    0x47, 0x83, 0x18, 0xAA, 0xE9, 0x1A, 0x72, 0xCE, 0xA2, 0x65, 0x82, 0xCB, 0xEC, 0xDB, 0x84, 0xA3, 
-    0xED, 0x28, 0x66, 0xED, 0x91, 0xDD, 0xFE, 0xC0, 0x10, 0x3E, 0xC0, 0x28, 0xE0, 0x2A, 0x25, 0x91, 
-    0x29, 0x5D, 0xFD, 0x2E, 0x6F, 0xFF, 0x5A, 0x6D, 0x9D, 0x6A, 0x7B, 0x0F, 0x8A, 0x0F, 0x99, 0x07, 
-    0x79, 0x54, 0x9E, 0xF5, 0xE5, 0x97, 0xE8, 0xD9, 0x39, 0xDC, 0x43, 0xC6, 0x24, 0xCF, 0xA2, 0x30, 
-    0xAE, 0xA2, 0xC1, 0x5E, 0xEA, 0x5F, 0x75, 0x28, 0xA9, 0x4B, 0x75, 0xBF, 0x41, 0xEA, 0x27, 0xFD, 
-    0x7D, 0xD7, 0x87, 0x2D, 0x3D, 0xEF, 0x76, 0x69, 0x1B, 0x34, 0x57, 0x2C, 0x09, 0xC5, 0xA8, 0x11, 
-    0x7E, 0x20, 0x71, 0x05, 0x0A, 0x0D, 0xAD, 0xC1, 0xF1, 0x8B, 0x6A, 0x9E, 0x26, 0xF3, 0xDC, 0x10, 
-    0x5A, 0x1B, 0x0A, 0x15, 0x1E, 0xC2, 0xDC, 0xB4, 0x93, 0xF9, 0xA3, 0xE6, 0xD9, 0x0D, 0x79, 0x12, 
-    0xCB, 0x52, 0xFE, 0x89, 0x05, 0x3C, 0xCA, 0xA5, 0x1A, 0xBE, 0x4F, 0x0E, 0x82, 0x00, 0xAF, 0x18, 
-    0x67, 0x87, 0xBD, 0x65, 0x8B, 0xED, 0x78, 0xA6, 0x4F, 0x13, 0xFF, 0xF7, 0xB4, 0x9F, 0xAA, 0x08, 
-    0xDD, 0x4D, 0xEA, 0x90, 0x94, 0x11, 0xE6, 0xE6, 0x93, 0xF3, 0x1A, 0xEB, 0xA3, 0x44, 0x2D, 0x28, 
-    0xE6, 0xBF, 0xD9, 0xCC, 0xB3, 0xD5, 0x09, 0x71, 0xFB, 0x64, 0x75, 0x1F, 0xAD, 0x59, 0x81, 0xB6, 
-    0xC2, 0x32, 0x3D, 0xB8, 0x43, 0xB7, 0xBA, 0xD2, 0x8E, 0xA2, 0x80, 0xB5, 0xFE, 0x25, 0x60, 0x29, 
-    0xD2, 0x06, 0x3B, 0xEA, 0xE9, 0xEC, 0xB2, 0xF1, 0x03, 0xEF, 0x6D, 0x02, 0x82, 0x01, 0x01, 0x00, 
-    0xD2, 0x91, 0x73, 0x96, 0xA0, 0x37, 0x26, 0x6E, 0x78, 0x6E, 0xFF, 0xCB, 0xE3, 0xC2, 0x55, 0xC8, 
-    0x59, 0xBE, 0x3C, 0xBB, 0x58, 0x10, 0x1B, 0x61, 0xDE, 0x5A, 0x63, 0x37, 0x09, 0xB9, 0xCE, 0xB2, 
-    0xD6, 0xF1, 0x5B, 0x92, 0x86, 0x96, 0xBB, 0xB3, 0x50, 0xF0, 0xB3, 0x0B, 0x4F, 0x0D, 0xE1, 0x4F, 
-    0x0E, 0xE4, 0xE2, 0x08, 0xAA, 0x32, 0x10, 0x87, 0xA2, 0x31, 0xAE, 0xBA, 0xC9, 0xC9, 0x1E, 0x95, 
-    0xCF, 0xD5, 0xDC, 0x8F, 0x41, 0x36, 0x48, 0x75, 0x50, 0x1F, 0x8C, 0xE5, 0x5A, 0x53, 0xB0, 0xF1, 
-    0xC0, 0x8B, 0x3E, 0x23, 0x22, 0x30, 0xFD, 0x3C, 0xF6, 0x69, 0x6B, 0x64, 0x74, 0xF7, 0xB8, 0x69, 
-    0x9D, 0x23, 0xDB, 0x3E, 0x02, 0x79, 0x68, 0x16, 0xAD, 0xE2, 0xC1, 0xB8, 0xD4, 0x6E, 0x10, 0x73, 
-    0x31, 0x3C, 0x1C, 0xDB, 0xC9, 0x8C, 0x2E, 0x2F, 0x12, 0x2D, 0x02, 0x7B, 0xE1, 0xBE, 0x97, 0xA1, 
-    0xD2, 0x16, 0x68, 0x19, 0xE9, 0x3E, 0x7E, 0x45, 0x7D, 0xC5, 0xEA, 0x01, 0xB8, 0x93, 0x2C, 0x72, 
-    0x0F, 0xF1, 0x9B, 0x24, 0xED, 0x84, 0x19, 0xFC, 0x2F, 0x28, 0xD5, 0x07, 0x25, 0xBC, 0xBA, 0xA6, 
-    0xC9, 0x55, 0xE2, 0x14, 0x0C, 0x23, 0xED, 0x5A, 0x80, 0x9B, 0xC7, 0xEC, 0x15, 0xD5, 0x8B, 0x76, 
-    0x28, 0xF5, 0x0F, 0x09, 0x6A, 0xAF, 0xFB, 0x73, 0x84, 0x0C, 0x3F, 0x51, 0xA7, 0xB8, 0xCA, 0x84, 
-    0xF2, 0xB0, 0x56, 0x17, 0xE0, 0xC5, 0x04, 0x7E, 0x53, 0x5D, 0xEB, 0x03, 0xA9, 0xE9, 0xA9, 0x1A, 
-    0xB1, 0x40, 0x1A, 0xFC, 0x44, 0x7E, 0x22, 0xEB, 0x92, 0x2E, 0xEF, 0xE2, 0x91, 0x66, 0x74, 0x4F, 
-    0x7F, 0x5F, 0x92, 0xE4, 0x8D, 0x27, 0x22, 0x60, 0x73, 0x65, 0x80, 0xF9, 0xC5, 0x4C, 0xD9, 0x64, 
-    0x49, 0x02, 0x95, 0x1C, 0x09, 0xDD, 0xC1, 0xFE, 0x77, 0x4F, 0xEB, 0xC4, 0x05, 0x5B, 0x43, 0x7B, 
-    0x02, 0x82, 0x01, 0x00, 0x54, 0xD7, 0x60, 0xB8, 0xF4, 0x8C, 0x1C, 0x29, 0x71, 0x7B, 0xD4, 0x5D, 
-    0xB1, 0xCA, 0xF0, 0xC6, 0x1A, 0x1E, 0xD9, 0xBC, 0x99, 0x78, 0x5A, 0xD2, 0x4B, 0x4D, 0xDD, 0xAB, 
-    0x7A, 0xC1, 0x56, 0x4A, 0xAE, 0x41, 0x63, 0x4A, 0x88, 0x6B, 0x0E, 0xF5, 0x94, 0x1C, 0xC4, 0xC3, 
-    0x36, 0x4B, 0xB1, 0x64, 0x62, 0x23, 0x7B, 0x3E, 0x5B, 0x4D, 0xDF, 0x3C, 0xEA, 0x6D, 0xA0, 0x5C, 
-    0xB6, 0x4B, 0x73, 0x01, 0x3E, 0x7F, 0x86, 0x7C, 0xA9, 0x09, 0x9F, 0x74, 0x1E, 0xE0, 0xAB, 0x60, 
-    0x88, 0xA2, 0x63, 0x78, 0x38, 0xF4, 0x8B, 0xE5, 0xE6, 0x47, 0xC6, 0x28, 0x63, 0xEA, 0xA8, 0x2A, 
-    0xCF, 0xF8, 0x79, 0xE9, 0xDA, 0x84, 0xAB, 0x9B, 0x40, 0x0B, 0x7B, 0xFF, 0x0B, 0x18, 0xA9, 0x0B, 
-    0xAE, 0x58, 0x47, 0x1E, 0x69, 0x63, 0x7E, 0x83, 0x9C, 0x48, 0xD6, 0x2D, 0x96, 0xA3, 0x1E, 0xE7, 
-    0x32, 0x05, 0xF7, 0x5B, 0xF8, 0x7F, 0xDC, 0x4F, 0x5A, 0x13, 0x14, 0x0A, 0xC9, 0x76, 0x7E, 0xA9, 
-    0xA0, 0x1D, 0x14, 0x5B, 0x63, 0x90, 0x32, 0x7D, 0x0C, 0x56, 0xA0, 0x5A, 0xBA, 0x97, 0xE8, 0x1F, 
-    0xFC, 0xFD, 0x02, 0x79, 0x7F, 0x5C, 0x63, 0x17, 0xC0, 0x61, 0x0D, 0x21, 0x2C, 0xA6, 0xA7, 0xDF, 
-    0xD3, 0xAE, 0xC8, 0xEF, 0x02, 0xF9, 0x9B, 0x78, 0xCD, 0x30, 0xB6, 0xF2, 0xC6, 0x48, 0xC3, 0xD0, 
-    0x36, 0x83, 0x57, 0x7A, 0x85, 0x60, 0x24, 0x0E, 0x41, 0x3E, 0x6E, 0x06, 0xC0, 0xBE, 0xE7, 0xEB, 
-    0x43, 0x18, 0x69, 0xE3, 0x93, 0xEB, 0x60, 0x38, 0x20, 0x83, 0x23, 0xD0, 0x5F, 0x2A, 0xF5, 0x69, 
-    0x97, 0xA9, 0x58, 0xF8, 0x73, 0x03, 0x34, 0x27, 0x56, 0x41, 0x60, 0xFC, 0xB7, 0x9E, 0x37, 0x58, 
-    0xCB, 0xF2, 0xFC, 0xFF, 0x04, 0x07, 0x57, 0xF5, 0x98, 0xE6, 0xE7, 0x26, 0x62, 0x7A, 0x46, 0x23, 
-    0xB7, 0xF5, 0x5E, 0x21, 0x02, 0x82, 0x01, 0x01, 0x00, 0xCF, 0x14, 0x32, 0x0B, 0x88, 0xC6, 0x93, 
-    0xEA, 0x02, 0x50, 0x8F, 0x09, 0x31, 0x94, 0xD5, 0x8D, 0xF2, 0x0B, 0xEF, 0x68, 0x02, 0xA3, 0xDC, 
-    0x79, 0xF4, 0x15, 0x0A, 0x0B, 0x7F, 0x6A, 0x16, 0xC7, 0xB4, 0x30, 0xAA, 0x70, 0xC0, 0x21, 0x8E, 
-    0xB8, 0x3B, 0x3A, 0x6B, 0xAA, 0x0C, 0x75, 0xC7, 0x05, 0x5B, 0xCD, 0x66, 0x29, 0x45, 0x4F, 0x75, 
-    0x08, 0x1E, 0x4F, 0x23, 0xDA, 0x18, 0x45, 0xCC, 0xE9, 0x61, 0xFA, 0x9D, 0x2C, 0xD8, 0xE2, 0x0C, 
-    0x82, 0x2A, 0x68, 0xCC, 0xC4, 0x65, 0x7F, 0x76, 0xBD, 0x59, 0x30, 0xD6, 0xCB, 0xF0, 0x7D, 0x23, 
-    0x1E, 0x87, 0xEA, 0x86, 0xAD, 0xC5, 0x86, 0x34, 0xFA, 0xD0, 0x8A, 0x09, 0xBB, 0xC2, 0xED, 0x28, 
-    0x9B, 0x5D, 0x28, 0x6A, 0x81, 0x5D, 0x90, 0x5C, 0x67, 0x1C, 0x9D, 0x54, 0x78, 0x25, 0x8E, 0xD1, 
-    0x80, 0x83, 0x2C, 0x76, 0x8B, 0xE4, 0x26, 0xEE, 0xB2, 0x3A, 0x8C, 0xC4, 0x95, 0xEE, 0xD7, 0x01, 
-    0x91, 0x4F, 0xAE, 0x8A, 0x82, 0x64, 0xC5, 0x7F, 0xE9, 0x30, 0x9A, 0xD7, 0x8B, 0x8A, 0x75, 0xE6, 
-    0xA4, 0x26, 0xB0, 0xCE, 0x47, 0x78, 0x2A, 0x51, 0x99, 0x62, 0xD9, 0x2E, 0x3B, 0xAE, 0xF0, 0xCA, 
-    0x24, 0xBD, 0xE3, 0xF5, 0xC9, 0xCC, 0x73, 0x34, 0xF2, 0xE0, 0x36, 0x98, 0x32, 0x17, 0x94, 0xB8, 
-    0x02, 0x13, 0x73, 0x83, 0xF5, 0xC6, 0xAF, 0x29, 0xA3, 0x73, 0x94, 0x4D, 0x26, 0xB0, 0x6A, 0xB1, 
-    0x0F, 0x96, 0xE6, 0xFF, 0x0F, 0x9C, 0x52, 0xE9, 0x76, 0x11, 0xA8, 0xCC, 0xA1, 0x18, 0xAE, 0xBF, 
-    0xA2, 0xD2, 0x21, 0x8C, 0xD2, 0x51, 0x51, 0xE3, 0xC2, 0xA6, 0xAE, 0x14, 0x24, 0xE6, 0x57, 0xFD, 
-    0x2B, 0xC3, 0x70, 0xA8, 0x55, 0x7A, 0x5E, 0x28, 0x50, 0xC2, 0xA8, 0x62, 0x81, 0xAF, 0x86, 0x41, 
-    0x99, 0x02, 0x37, 0x3B, 0xD2, 0x8B, 0xBE, 0x03, 0xEF, 0x02, 0x82, 0x01, 0x00, 0x45, 0x6D, 0xA8, 
-    0xD3, 0xA8, 0x9B, 0x2C, 0x91, 0x48, 0xEF, 0x3E, 0x27, 0xF8, 0x48, 0xEE, 0xB7, 0x90, 0xF7, 0xFD, 
-    0xAB, 0x03, 0x40, 0xF8, 0xE6, 0xB5, 0x72, 0xC7, 0x2B, 0x82, 0xCE, 0xC5, 0xFB, 0x52, 0x0A, 0x8C, 
-    0xEF, 0x1D, 0x04, 0x01, 0x4D, 0xA4, 0x16, 0x29, 0x99, 0xAE, 0x5B, 0xAE, 0xDC, 0x80, 0xF2, 0x00, 
-    0xA0, 0xE2, 0xEB, 0x90, 0x01, 0x99, 0x23, 0x3C, 0xAF, 0xAA, 0x97, 0xA5, 0x1C, 0x9F, 0x37, 0x6E, 
-    0x3E, 0xAB, 0xED, 0xAD, 0xF6, 0xB3, 0x79, 0x78, 0x4E, 0x6D, 0xFA, 0x96, 0x72, 0xC3, 0xD1, 0xC3, 
-    0x1B, 0xE0, 0xB4, 0xF8, 0x67, 0x01, 0xC1, 0xDC, 0x6E, 0xC0, 0x3C, 0xE1, 0xB7, 0xDB, 0x7F, 0x4F, 
-    0x86, 0xA3, 0x27, 0x41, 0xAB, 0x23, 0x70, 0x94, 0xBC, 0x2F, 0xE5, 0xEF, 0x6B, 0xB1, 0x74, 0x70, 
-    0xF4, 0x82, 0x76, 0xEB, 0x12, 0x90, 0x99, 0x74, 0xAF, 0xCA, 0x41, 0x27, 0x24, 0xC8, 0x41, 0xFA, 
-    0x80, 0x34, 0xE6, 0x32, 0xD2, 0x5A, 0xD9, 0x24, 0x7C, 0x12, 0xD9, 0x6C, 0x42, 0x38, 0xEE, 0xD8, 
-    0x4A, 0xEB, 0x79, 0x49, 0x1C, 0x76, 0xD6, 0xA5, 0x26, 0x16, 0xD7, 0xED, 0xC1, 0xED, 0xC7, 0x0C, 
-    0xA1, 0xA5, 0x61, 0xD8, 0xA0, 0x03, 0x11, 0x6C, 0x74, 0x54, 0x5B, 0x2B, 0x07, 0x29, 0x3C, 0x29, 
-    0xC4, 0x3E, 0xEA, 0x54, 0x9B, 0xCA, 0xB8, 0xEE, 0xB3, 0xFF, 0x10, 0x35, 0x96, 0x9A, 0x21, 0xBE, 
-    0x8D, 0xD6, 0x7B, 0x6C, 0x0D, 0xA1, 0x8D, 0xFD, 0xA8, 0xEF, 0x5D, 0xB5, 0x5B, 0x48, 0xF5, 0x1D, 
-    0x52, 0xD3, 0x88, 0x45, 0x4D, 0xF9, 0x3F, 0xC4, 0x38, 0x2E, 0x00, 0xF4, 0xCA, 0xF3, 0x3C, 0xDB, 
-    0x30, 0x74, 0x1A, 0x28, 0x5F, 0x04, 0x14, 0xFB, 0xA5, 0xC8, 0x04, 0x60, 0x5A, 0x47, 0x51, 0x7F, 
-    0x1A, 0xEC, 0x3F, 0x4E, 0xA4, 0x2E, 0xA5, 0xFC, 0xF0, 0xE3, 0x82, 0x5C, 0x3B, 
+pub const NODE_PRIVATE_KEY: [u8; 1768] = [
+    0x30, 0x82, 0x06, 0xE4, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x81, 0x00, 0xCB, 0x0E, 0x66, 0x6E, 
+    0xF3, 0x55, 0x59, 0x8E, 0x58, 0x1A, 0x85, 0x60, 0x7D, 0x2D, 0x54, 0x4D, 0x48, 0xD4, 0xEC, 0x68, 
+    0xF0, 0xF0, 0x86, 0x68, 0xDC, 0x9B, 0xBF, 0xCC, 0xE9, 0xCA, 0x84, 0xE5, 0x4D, 0x67, 0xBA, 0x24, 
+    0xB2, 0x89, 0xA1, 0x6A, 0x8D, 0xD9, 0x53, 0xA3, 0xB5, 0xF9, 0xF1, 0x09, 0x97, 0xE3, 0xA2, 0x5E, 
+    0x91, 0x7E, 0x9B, 0xD5, 0xDB, 0xA8, 0x32, 0xB3, 0x4F, 0xE8, 0x41, 0x49, 0x2E, 0x62, 0x69, 0xB3, 
+    0xC5, 0x56, 0xD9, 0xB3, 0x75, 0x4B, 0xF9, 0x09, 0xA6, 0xE9, 0xBD, 0xD0, 0x87, 0xDA, 0x20, 0xF7, 
+    0x6A, 0x8D, 0x93, 0x02, 0x6F, 0x51, 0xB8, 0x65, 0x1B, 0x77, 0xCA, 0xE2, 0x75, 0x15, 0x9E, 0x94, 
+    0x45, 0x69, 0x15, 0x94, 0xF3, 0x9F, 0x7C, 0xBD, 0x90, 0xB3, 0x27, 0x8C, 0xBA, 0x38, 0x32, 0x5E, 
+    0xDD, 0x84, 0x1C, 0x7F, 0x18, 0xA9, 0x93, 0x88, 0x5A, 0x1B, 0x3E, 0x96, 0xA3, 0x69, 0x7C, 0x82, 
+    0xFD, 0x73, 0x17, 0xC3, 0x65, 0x1C, 0xA3, 0x4D, 0x6D, 0x3F, 0x4E, 0x81, 0x73, 0x3C, 0x47, 0x64, 
+    0x34, 0xD7, 0xC9, 0x32, 0xA7, 0x9C, 0xD8, 0xC9, 0x78, 0xE5, 0xB9, 0x65, 0xBD, 0x95, 0xD4, 0xF2, 
+    0x4B, 0xB5, 0xD5, 0xCA, 0x44, 0xD9, 0x04, 0x7B, 0xCF, 0x77, 0x32, 0x5F, 0xAF, 0xD4, 0x64, 0x32, 
+    0x97, 0x8E, 0x06, 0x61, 0x0A, 0xCD, 0xD5, 0xA0, 0x50, 0x8D, 0xD1, 0xA8, 0xBF, 0x15, 0xB8, 0x81, 
+    0xA8, 0x40, 0xBC, 0x6D, 0x82, 0x6B, 0x69, 0xA9, 0x70, 0x4D, 0xA3, 0x42, 0x53, 0x6A, 0xD3, 0xE7, 
+    0x47, 0xDD, 0x46, 0x9F, 0xA8, 0xA4, 0x0A, 0x5D, 0xC6, 0x4F, 0x1C, 0x38, 0xFF, 0xC7, 0x94, 0xAD, 
+    0xB8, 0xB6, 0x7F, 0x25, 0xA1, 0x21, 0x5A, 0x97, 0x6E, 0x06, 0x39, 0xDF, 0xEB, 0x8F, 0xF4, 0x43, 
+    0x64, 0xCD, 0xB4, 0x1C, 0xDD, 0x2B, 0xC9, 0x6D, 0x5F, 0xAC, 0x83, 0xD8, 0x0C, 0xB0, 0x9F, 0x2A, 
+    0xDA, 0xC0, 0xC3, 0x4E, 0x04, 0xC2, 0xF0, 0x09, 0x0B, 0x10, 0xBD, 0x19, 0x00, 0x24, 0x32, 0xD1, 
+    0xF4, 0x0A, 0x50, 0x44, 0xCB, 0xBE, 0x70, 0xD4, 0xDA, 0x63, 0xBC, 0xFC, 0xDC, 0xAD, 0x24, 0x63, 
+    0x07, 0x66, 0x96, 0xE6, 0xA3, 0x86, 0xB9, 0xDD, 0xDE, 0x4B, 0xF1, 0xB5, 0x49, 0x94, 0x10, 0xE2, 
+    0xF5, 0xD0, 0xF1, 0xAE, 0xDC, 0xCB, 0x22, 0xE8, 0xAE, 0x26, 0xFF, 0xD6, 0xFE, 0xE4, 0xDA, 0x5F, 
+    0x70, 0xD4, 0xF7, 0x9A, 0xA0, 0x78, 0xFB, 0x84, 0x69, 0x0B, 0xB7, 0x71, 0xAD, 0xEC, 0x18, 0xB4, 
+    0xA7, 0x38, 0x9A, 0xC8, 0xCB, 0x9A, 0x1C, 0x30, 0x44, 0xFB, 0xF3, 0xB5, 0xFF, 0x95, 0x53, 0x16, 
+    0x50, 0xE8, 0x94, 0x06, 0xCF, 0xA2, 0x94, 0xB6, 0x48, 0x83, 0xA0, 0xAF, 0xA7, 0x87, 0x8C, 0xCA, 
+    0xE7, 0x1F, 0xEA, 0x4A, 0x5B, 0x14, 0x54, 0x6A, 0x55, 0xDF, 0x3E, 0xCF, 0x02, 0x03, 0x01, 0x00, 
+    0x01, 0x02, 0x82, 0x01, 0x80, 0x19, 0x44, 0x5A, 0x74, 0xB5, 0xEC, 0xC9, 0xEF, 0x0F, 0x81, 0x85, 
+    0x55, 0x43, 0x5E, 0x4F, 0x9E, 0x2A, 0x50, 0xEC, 0x76, 0x06, 0x7D, 0x37, 0x8C, 0x76, 0xDF, 0x1E, 
+    0x97, 0xC6, 0x03, 0xC0, 0x53, 0xB4, 0x35, 0x13, 0x11, 0x9B, 0xF1, 0xCA, 0x57, 0x32, 0xFD, 0x77, 
+    0x0D, 0xE9, 0x08, 0x07, 0xF9, 0x54, 0xA0, 0x2B, 0xC5, 0x2E, 0xBF, 0x9D, 0x6E, 0x98, 0x1D, 0xAE, 
+    0xE9, 0x67, 0x29, 0x14, 0x6E, 0xA1, 0xC9, 0xF7, 0x33, 0x3A, 0x7C, 0x1B, 0x2C, 0xDC, 0x8C, 0xAE, 
+    0x99, 0x87, 0xDE, 0x90, 0x13, 0x11, 0xC4, 0x8F, 0xD3, 0x99, 0xBB, 0xB2, 0x2E, 0x5C, 0x61, 0xC3, 
+    0xDB, 0x38, 0xF6, 0xC8, 0x15, 0x33, 0xD2, 0x93, 0xE0, 0x09, 0x5F, 0x11, 0x23, 0x6E, 0xC9, 0x4A, 
+    0xC1, 0x5F, 0xEF, 0x1B, 0x1D, 0xC4, 0xD2, 0x57, 0x5A, 0x3C, 0xA0, 0x42, 0xD7, 0x81, 0xDF, 0x20, 
+    0x0F, 0x98, 0x7E, 0xC9, 0x63, 0xFF, 0x43, 0x92, 0x0D, 0xCE, 0xB1, 0xF2, 0xA4, 0x0A, 0xC1, 0xEC, 
+    0x84, 0x26, 0xF2, 0xF8, 0xB6, 0xDC, 0xFB, 0x04, 0x3B, 0x30, 0xE4, 0x25, 0x12, 0x1B, 0x8F, 0x45, 
+    0xDE, 0x94, 0x1F, 0xA9, 0xD9, 0x42, 0x25, 0x11, 0xD1, 0x70, 0xA0, 0x58, 0xD1, 0x09, 0x8E, 0x23, 
+    0xA3, 0xB0, 0x66, 0x39, 0xAB, 0x74, 0x7A, 0xAE, 0x59, 0x29, 0x48, 0xAF, 0xFC, 0x85, 0x56, 0xA5, 
+    0x9D, 0x84, 0x48, 0x91, 0x6D, 0x00, 0x4F, 0x35, 0xEA, 0xAC, 0xC9, 0x0C, 0x20, 0x06, 0x07, 0x72, 
+    0xAB, 0x53, 0x12, 0x3D, 0x9A, 0xE7, 0x5E, 0x86, 0x86, 0xBF, 0xAF, 0x54, 0xFF, 0x61, 0xB6, 0x6F, 
+    0xEC, 0x6C, 0xAB, 0xDD, 0xEC, 0x9C, 0x07, 0xD7, 0x44, 0x02, 0xE7, 0xF3, 0x38, 0x8B, 0x2C, 0x7B, 
+    0x29, 0x10, 0x50, 0xF3, 0xE2, 0x45, 0x9A, 0x37, 0xB1, 0x80, 0xE1, 0xD7, 0x8F, 0xAC, 0x5D, 0x44, 
+    0xEF, 0xC8, 0x54, 0x54, 0x08, 0x7F, 0x63, 0x91, 0xB3, 0x15, 0xE0, 0xAD, 0x1A, 0xA3, 0xB4, 0xB2, 
+    0xFB, 0x2F, 0x5F, 0xD8, 0x7E, 0xAD, 0x6D, 0x05, 0x20, 0x5E, 0x16, 0x5C, 0xF9, 0x03, 0x43, 0x45, 
+    0x46, 0xF3, 0x0F, 0xEA, 0x1F, 0x00, 0x2D, 0x5A, 0x3B, 0x62, 0xE6, 0xCD, 0xB5, 0xED, 0x35, 0x24, 
+    0xA7, 0xB6, 0xA2, 0x16, 0xD9, 0xF3, 0xA9, 0x5D, 0x32, 0xBE, 0x2D, 0x97, 0xBC, 0x4A, 0x1A, 0x37, 
+    0x79, 0xE7, 0x7A, 0xDE, 0x1A, 0xFE, 0x70, 0x01, 0x54, 0x95, 0x02, 0xE9, 0x1A, 0xD7, 0x72, 0xD8, 
+    0x1E, 0xB4, 0xD3, 0x59, 0xB5, 0x22, 0x0B, 0x31, 0x55, 0x7F, 0xF6, 0x0F, 0xED, 0x1C, 0x55, 0x48, 
+    0x81, 0x6E, 0xA4, 0xF5, 0x9D, 0x9B, 0x58, 0xED, 0x42, 0x6D, 0xE6, 0xBE, 0x2C, 0x10, 0xD7, 0x06, 
+    0x7D, 0x63, 0x4E, 0xA5, 0x0B, 0x39, 0x5E, 0x1B, 0xE5, 0x85, 0x92, 0x89, 0xC7, 0xC8, 0xBB, 0x4F, 
+    0x59, 0xF8, 0xC1, 0x78, 0xB9, 0x02, 0x81, 0xC1, 0x00, 0xEA, 0x11, 0x29, 0x0E, 0x92, 0xFD, 0x82, 
+    0x3B, 0x89, 0x5E, 0x07, 0x07, 0x29, 0x67, 0x40, 0xDC, 0xC3, 0x64, 0x9E, 0xD0, 0x9C, 0x02, 0x61, 
+    0x42, 0xBE, 0xFE, 0xC7, 0x6E, 0x77, 0x47, 0xA0, 0x2F, 0x85, 0xD6, 0x78, 0xF6, 0x2D, 0x34, 0x89, 
+    0x8A, 0x56, 0x5C, 0xFF, 0x4B, 0x53, 0x92, 0xBD, 0xE5, 0x04, 0x88, 0x2A, 0x0D, 0x61, 0x7C, 0xA0, 
+    0xBA, 0x5E, 0x95, 0x9A, 0x8B, 0x9D, 0x65, 0xD2, 0x8F, 0x10, 0x87, 0x5D, 0x61, 0xAE, 0x22, 0xC1, 
+    0x1C, 0x88, 0x1E, 0xC2, 0xA9, 0x0F, 0x6C, 0xAA, 0x35, 0x80, 0x6C, 0x50, 0xF3, 0x03, 0xBA, 0x68, 
+    0x9F, 0xE4, 0x0C, 0x0E, 0xC6, 0x7E, 0xBA, 0xC9, 0xE1, 0x6F, 0x9C, 0xA0, 0xD1, 0xD9, 0xE5, 0x2D, 
+    0x75, 0xE0, 0x73, 0x4A, 0x00, 0x47, 0x26, 0x4D, 0x7D, 0x15, 0xF1, 0x7E, 0xEA, 0xA0, 0xB2, 0x5F, 
+    0xE9, 0xCC, 0x61, 0xB0, 0x06, 0x70, 0xC1, 0x0E, 0xD0, 0xCA, 0x91, 0x1C, 0xAC, 0xD0, 0x0D, 0x16, 
+    0xC0, 0x19, 0x90, 0xD2, 0xBE, 0x15, 0xE4, 0x6E, 0xF1, 0x1F, 0x48, 0xA5, 0x6D, 0xFF, 0x13, 0xA4, 
+    0xEB, 0x58, 0x7B, 0x2F, 0x09, 0x67, 0x01, 0xBA, 0xF4, 0x2E, 0x4F, 0x29, 0x8F, 0x48, 0x2F, 0xC4, 
+    0x17, 0xE5, 0x5B, 0x4F, 0x77, 0x62, 0x06, 0x6A, 0xCA, 0x1D, 0x47, 0x6B, 0xA3, 0x25, 0x07, 0xA7, 
+    0x39, 0x16, 0x3E, 0xAB, 0xE6, 0xCD, 0xB6, 0x40, 0x33, 0x02, 0x81, 0xC1, 0x00, 0xDE, 0x15, 0x59, 
+    0x0D, 0x19, 0xBA, 0x9C, 0xF3, 0x97, 0xB1, 0x0A, 0x45, 0xEE, 0x33, 0x4D, 0xEC, 0xBC, 0x86, 0x39, 
+    0xF2, 0x17, 0xDF, 0x24, 0xD0, 0x91, 0xB1, 0x03, 0x6E, 0xFD, 0xE7, 0x5A, 0x1E, 0x72, 0x8C, 0xF5, 
+    0x8C, 0x98, 0x79, 0x42, 0x88, 0x49, 0xA2, 0xD9, 0xE2, 0x1C, 0x15, 0x3D, 0x68, 0xC2, 0x29, 0x3E, 
+    0x86, 0xBC, 0x0B, 0xE7, 0xDC, 0x0B, 0xB9, 0xD5, 0xB2, 0x39, 0x2F, 0x4B, 0x54, 0x7E, 0x16, 0xF3, 
+    0xE9, 0xE5, 0xD6, 0x13, 0x2A, 0x96, 0x2F, 0x00, 0x64, 0xE6, 0x7B, 0x5C, 0xDC, 0xD8, 0xA9, 0x24, 
+    0x68, 0xC5, 0xF9, 0x1A, 0xCD, 0x0C, 0x3A, 0x5A, 0xF4, 0x62, 0xEA, 0x6D, 0x59, 0x72, 0x63, 0xD8, 
+    0xA5, 0xA4, 0x19, 0x03, 0xD5, 0x70, 0x22, 0xFA, 0xEF, 0x89, 0x97, 0x8C, 0x0B, 0xEC, 0x55, 0x9A, 
+    0x18, 0xDF, 0xBC, 0x28, 0xAC, 0x7D, 0x4B, 0x4B, 0x63, 0x9B, 0x54, 0x60, 0x07, 0xA9, 0xAB, 0x6C, 
+    0xF0, 0x8D, 0xA5, 0xD0, 0x89, 0xA4, 0xF5, 0x6B, 0x8F, 0x23, 0xC8, 0x0E, 0x21, 0x32, 0x5E, 0x28, 
+    0x22, 0x3B, 0xAB, 0x09, 0xCB, 0x1B, 0xD6, 0xDB, 0x1C, 0x48, 0x8A, 0x4D, 0x45, 0x01, 0x41, 0x5F, 
+    0x22, 0x2A, 0xCE, 0xD8, 0xD2, 0xB9, 0x96, 0x3D, 0xEB, 0x1F, 0x3E, 0x92, 0xA9, 0xD9, 0xF1, 0x9C, 
+    0x41, 0x0B, 0x94, 0xC0, 0x2F, 0x5B, 0x87, 0x25, 0x11, 0x4B, 0x36, 0xFA, 0xF5, 0x02, 0x81, 0xC0, 
+    0x40, 0xE9, 0x97, 0x68, 0x4A, 0x4D, 0x71, 0xD3, 0x8F, 0x09, 0xFB, 0x8A, 0xF9, 0xE9, 0x7F, 0xAC, 
+    0x79, 0xA7, 0xAA, 0xFF, 0x91, 0x74, 0x7B, 0x82, 0xA6, 0x33, 0x44, 0x1D, 0x97, 0x88, 0xCE, 0x9C, 
+    0xBF, 0x52, 0x36, 0x63, 0x97, 0x2F, 0xCD, 0xC1, 0x06, 0xA8, 0x6D, 0xC8, 0x77, 0x19, 0xE7, 0xFD, 
+    0xDE, 0x5E, 0xE0, 0xC2, 0xAB, 0x39, 0x83, 0xDD, 0x8B, 0xA3, 0x93, 0xA3, 0x8A, 0x78, 0x15, 0x87, 
+    0xC5, 0x7E, 0xB4, 0xE0, 0x05, 0x09, 0xF0, 0x62, 0x38, 0x41, 0xC7, 0x9C, 0x59, 0x01, 0xBA, 0xC6, 
+    0x71, 0xA2, 0x18, 0x64, 0xFC, 0xB0, 0xB2, 0x99, 0x3D, 0x06, 0x37, 0x06, 0xC7, 0x58, 0x87, 0xEA, 
+    0x34, 0x28, 0xCC, 0xD4, 0xC5, 0xC7, 0xEF, 0xEE, 0x93, 0xDB, 0x85, 0x37, 0x44, 0x84, 0x13, 0xD3, 
+    0x4F, 0xC5, 0x94, 0x7B, 0xFF, 0x2A, 0xD8, 0xBC, 0x9F, 0x08, 0xAC, 0x67, 0x6C, 0xD7, 0xAD, 0x83, 
+    0x2B, 0xDA, 0x48, 0x88, 0x88, 0x7E, 0x48, 0xC3, 0xE7, 0x93, 0x29, 0x4E, 0xBC, 0x05, 0x88, 0xDA, 
+    0xE7, 0xE1, 0x1E, 0xB7, 0xBD, 0x98, 0xB6, 0x10, 0xEA, 0x8D, 0xE7, 0x02, 0x85, 0x85, 0x8E, 0x52, 
+    0x6F, 0x91, 0x56, 0xA6, 0x3C, 0xCF, 0xBA, 0x63, 0x22, 0x21, 0x4B, 0x8D, 0x81, 0x2A, 0xE4, 0x6C, 
+    0xBE, 0xE7, 0xF2, 0xAA, 0xE0, 0xF7, 0x19, 0x62, 0x14, 0x90, 0x36, 0xDE, 0x20, 0x48, 0x9D, 0xCF, 
+    0x02, 0x81, 0xC1, 0x00, 0xA6, 0xF9, 0x31, 0xFD, 0x11, 0x8D, 0x27, 0x18, 0x56, 0xC2, 0xBB, 0x50, 
+    0x9C, 0xA9, 0x62, 0x3B, 0x4D, 0xFB, 0x35, 0x71, 0xF9, 0xD4, 0xC2, 0x1F, 0x36, 0x8A, 0xFA, 0x63, 
+    0xE6, 0xEE, 0x9C, 0xE9, 0x2B, 0x83, 0x23, 0xD3, 0x53, 0x88, 0x48, 0x27, 0xA4, 0x05, 0x96, 0xFF, 
+    0xD3, 0xD1, 0x7C, 0x5C, 0x59, 0x2F, 0x1D, 0x5D, 0xBB, 0xE0, 0xCF, 0xB0, 0xB7, 0xF8, 0x3E, 0xDD, 
+    0x42, 0xF5, 0x76, 0x13, 0xCE, 0xC1, 0x7F, 0x1E, 0x2A, 0xB9, 0xEB, 0xAB, 0x27, 0x43, 0xAB, 0x6E, 
+    0x31, 0x84, 0x2A, 0xEB, 0xB8, 0xD2, 0x63, 0x17, 0x8B, 0x51, 0xA1, 0x7E, 0xED, 0x64, 0xAA, 0xA1, 
+    0xF8, 0x04, 0xFD, 0xB6, 0x34, 0xB5, 0x31, 0x5C, 0x48, 0xA6, 0xAE, 0x25, 0x39, 0xAC, 0x73, 0x32, 
+    0xCA, 0x26, 0x71, 0x1B, 0x3D, 0xD3, 0x96, 0x8A, 0x81, 0x1D, 0x3D, 0x0F, 0x83, 0x1C, 0xAB, 0x4F, 
+    0xF6, 0xA7, 0x57, 0x94, 0x2B, 0x53, 0x42, 0x13, 0x12, 0xCC, 0xCA, 0x9F, 0xD2, 0xB0, 0xDA, 0xEF, 
+    0xC2, 0x1D, 0x55, 0xD2, 0x4B, 0xC6, 0x53, 0x32, 0x79, 0xDE, 0x3C, 0xFC, 0xC2, 0xAF, 0xA6, 0x09, 
+    0xFB, 0xD8, 0x50, 0x04, 0x43, 0xCF, 0x5C, 0xB1, 0x99, 0xB1, 0xEF, 0x7F, 0x70, 0x1D, 0xAF, 0xEC, 
+    0x29, 0x8F, 0xA8, 0x41, 0xA0, 0x25, 0x72, 0x2F, 0xCD, 0x7F, 0x47, 0x87, 0xD3, 0xAF, 0x26, 0x85, 
+    0x7C, 0x21, 0x98, 0x49, 0x02, 0x81, 0xC1, 0x00, 0xE6, 0xDC, 0x27, 0xAF, 0x9C, 0x39, 0x82, 0xD2, 
+    0x36, 0x51, 0xCC, 0x5A, 0xE5, 0x15, 0x1A, 0x16, 0x31, 0x50, 0xBA, 0x67, 0xA6, 0x15, 0x1F, 0x1B, 
+    0x5B, 0x9C, 0x40, 0x18, 0xEC, 0x18, 0x1C, 0xEA, 0xB0, 0x7D, 0x30, 0xF9, 0xBA, 0x6A, 0x68, 0x00, 
+    0xDC, 0x69, 0x70, 0xDD, 0x2C, 0xBD, 0xBF, 0xBF, 0xBC, 0xEB, 0x8F, 0x00, 0x8A, 0x71, 0x39, 0xE0, 
+    0xEC, 0x09, 0xEB, 0xAC, 0x85, 0x44, 0xC4, 0xF4, 0x43, 0x0F, 0xA3, 0x63, 0x76, 0xD3, 0x36, 0x4A, 
+    0xB9, 0x86, 0x13, 0x3A, 0x2A, 0x16, 0xD4, 0x44, 0x4E, 0xF7, 0x0A, 0x7C, 0xDC, 0x86, 0x94, 0x5D, 
+    0xB8, 0x0C, 0xBF, 0xE3, 0x78, 0xB5, 0x52, 0xF8, 0x62, 0x57, 0xE7, 0x8B, 0x50, 0x23, 0x32, 0x83, 
+    0xAF, 0x7E, 0xAD, 0xAB, 0x4E, 0xFC, 0x4B, 0x87, 0xEF, 0x3A, 0xC3, 0x00, 0xBF, 0x4D, 0x56, 0xFF, 
+    0x01, 0x08, 0x89, 0xBC, 0x02, 0x4F, 0x37, 0x1E, 0xE2, 0x39, 0xEE, 0xBA, 0xDA, 0xBA, 0x44, 0x8A, 
+    0x35, 0x5D, 0x49, 0xEC, 0x0F, 0xD7, 0x54, 0x20, 0x61, 0xA9, 0x63, 0x17, 0xF2, 0x57, 0xFC, 0x57, 
+    0x91, 0x34, 0xE3, 0x14, 0x9B, 0x54, 0x7B, 0xC3, 0x3C, 0x97, 0x16, 0x8E, 0x90, 0x0D, 0x0C, 0x80, 
+    0xA3, 0x31, 0x6C, 0x31, 0x28, 0x5B, 0x25, 0x2C, 0x12, 0x1E, 0x41, 0xEA, 0x58, 0x69, 0xC4, 0x1E, 
+    0x0F, 0x5A, 0xC2, 0x7B, 0x01, 0x2C, 0xB7, 0xFA, 
 ];
 
 pub const BLOCK_KEY: [u8; 32] = [
@@ -579,7 +483,8 @@ fn write_rsa_keys_to_file(path: &str) -> Result<()> {
     use openssl::{
         rsa::Rsa,
     };
-    let rsa = Rsa::generate(4096).map_err(convert_err)?;
+    let key_bits = 8 * u32::try_from(RSA_SIG_LEN).map_err(|e| Error::Message(e.to_string()))?;
+    let rsa = Rsa::generate(key_bits).map_err(convert_err)?;
     let public_der = rsa.public_key_to_der().map_err(convert_err)?;
     let private_der = rsa.private_key_to_der().map_err(convert_err)?;
     let slices = [