Merge pull request #59 from TheBestTvarynka/local-storage

Local storage support

Cargo.toml

@@ -18,6 +18,7 @@ members = [
 yew = { version = "0.20", features = ["csr"] }
 yew-router = "0.17.0"
 yew-notifications = { git = "https://github.com/TheBestTvarynka/yew-notifications.git", features = ["standard-notification"] }
+yew-hooks = "0.2.0"
 
 # wasm
 js-sys = "0.3.60"
@@ -47,7 +48,6 @@ sha1 = "0.10.5"
 hmac-sha256 = "1.1.5"
 hmac-sha512 = { version = "1.1.2", features = ["sha384"] }
 rsa = "0.7.2"
-yew-hooks = "0.2.0"
 bcrypt = "0.14.0"
 flate2 = { version = "1.0.26", features = ["zlib"] }
 

src/asn1.rs

@@ -8,15 +8,15 @@ mod scheme;
 
 use std::rc::Rc;
 
-use asn1_parser::{Asn1, Asn1Decoder};
+use asn1_parser::{Asn1, Asn1Decoder, Asn1Encoder};
 use web_sys::KeyboardEvent;
 use yew::{classes, function_component, html, use_effect_with_deps, use_reducer, use_state, Callback, Html, Reducible};
-use yew_hooks::{use_clipboard, use_location};
+use yew_hooks::{use_clipboard, use_local_storage, use_location};
 use yew_notifications::{use_notification, Notification, NotificationType};
 
 use crate::asn1::asn1_viewer::Asn1Viewer;
 use crate::asn1::hex_view::HexViewer;
-use crate::common::ByteInput;
+use crate::common::{encode_bytes, ByteInput, BytesFormat};
 use crate::url_query_params;
 use crate::url_query_params::generate_asn1_link;
 
@@ -26,6 +26,7 @@ pub const TEST_ASN1: &[u8] = &[
  48, 30, 160, 2, 5, 0, 161, 24, 30, 22, 0, 67, 0, 101, 0, 114, 0, 116, 0, 105, 0, 102, 0, 105, 0, 99, 0, 97, 0, 116,
  0, 101,
 ];
+const ASN1_LOCAL_STORAGE_KEY: &str = "ASN1_DATA";
 
 pub fn compare_ids(asn1_node_id: u64, cur_node: &Option<u64>) -> bool {
  matches!(cur_node, Some(node_id) if *node_id == asn1_node_id)
@@ -83,7 +84,7 @@ pub fn asn1_parser_page() -> Html {
  let raw_data = (*raw_asn1).clone();
  let parse_asn1 = Callback::from(move |_| match Asn1::decode_buff(&raw_data) {
  Ok(asn1) => {
- log::debug!("parsed!");
+ debug!("parsed!");
  asn1_setter.set(asn1.to_owned_with_asn1(asn1.inner_asn1().to_owned()));
  }
  Err(error) => notifications.spawn(Notification::new(
@@ -109,11 +110,25 @@ pub fn asn1_parser_page() -> Html {
  let notifications = notification_manager.clone();
  let raw_asn1_setter = raw_asn1.setter();
  let asn1_setter = parsed_asn1.setter();
+ let local_storage = use_local_storage::<String>(ASN1_LOCAL_STORAGE_KEY.to_owned());
  use_effect_with_deps(
  move |_: &[(); 0]| {
  let query = &location.search;
 
  if query.len() < 2 {
+ // URL query params is empty. We try to load ASN1 from local storage.
+ if let Some(raw_asn1) = (*local_storage).as_ref() {
+ if let Ok(bytes) = hex::decode(raw_asn1) {
+ match Asn1::decode_buff(&bytes) {
+ Ok(asn1) => {
+ asn1_setter.set(asn1.to_owned_with_asn1(asn1.inner_asn1().to_owned()));
+ }
+ Err(err) => {
+ error!("Can not decode asn1: {:?}", err);
+ }
+ }
+ }
+ }
  return;
  }
 
@@ -122,7 +137,6 @@ pub fn asn1_parser_page() -> Html {
  let url_query_params::Asn1 { asn1: asn1_data } = asn1;
  match Asn1::decode_buff(&asn1_data) {
  Ok(asn1) => {
- log::debug!("parsed!");
  asn1_setter.set(asn1.to_owned_with_asn1(asn1.inner_asn1().to_owned()));
  }
  Err(error) => notifications.spawn(Notification::new(
@@ -145,6 +159,16 @@ pub fn asn1_parser_page() -> Html {
  [],
  );
 
+ let local_storage = use_local_storage::<String>(ASN1_LOCAL_STORAGE_KEY.to_owned());
+ use_effect_with_deps(
+ move |asn1| {
+ let mut encoded = vec![0; asn1.needed_buf_size()];
+ asn1.encode_buff(&mut encoded).expect("ASN1 encoding should not fail");
+ local_storage.set(encode_bytes(encoded, BytesFormat::Hex));
+ },
+ parsed_asn1.clone(),
+ );
+
  let clipboard = use_clipboard();
  let raw_asn1_data = (*raw_asn1).clone();
  let share_by_link = Callback::from(move |_| {

src/common/mod.rs

@@ -63,7 +63,7 @@ pub const BYTES_FORMATS: [BytesFormat; 5] = [
  BytesFormat::Binary,
 ];
 
-fn encode_bytes(bytes: impl AsRef<[u8]>, format: BytesFormat) -> String {
+pub fn encode_bytes(bytes: impl AsRef<[u8]>, format: BytesFormat) -> String {
  match format {
  BytesFormat::Hex => hex::encode(bytes),
  BytesFormat::Base64 => base64::encode(bytes),

src/crypto_helper.rs

@@ -4,7 +4,6 @@ mod info;
 mod input;
 mod macros;
 mod output;
-pub mod serde;
 
 pub use algorithm::Algorithm;
 use info::Info;
@@ -14,13 +13,15 @@ use picky_krb::crypto::{ChecksumSuite, CipherSuite};
 use sha1::{Digest, Sha1};
 use web_sys::KeyboardEvent;
 use yew::{function_component, html, use_effect_with_deps, use_state, Callback, Html};
-use yew_hooks::{use_clipboard, use_location};
+use yew_hooks::{use_clipboard, use_local_storage, use_location};
 use yew_notifications::{use_notification, Notification, NotificationType};
 
 use self::computations::{process_krb_cipher, process_krb_hmac, process_rsa, process_zlib};
 use crate::crypto_helper::computations::process_bcrypt;
 use crate::url_query_params::generate_crypto_helper_link;
 
+const CRYPTO_HELPER_LOCAL_STORAGE_KEY: &str = "CRYPTO_HELPER_DATA";
+
 fn convert(algrithm: &Algorithm) -> Result<Vec<u8>, String> {
  match algrithm {
  Algorithm::Md5(input) => Ok(md5::compute(input).to_vec()),
@@ -71,29 +72,59 @@ pub fn crypto_helper() -> Html {
  let algorithm_setter = algorithm.setter();
  let location = use_location();
  let notifications = notification_manager.clone();
+ let local_storage = use_local_storage::<String>(CRYPTO_HELPER_LOCAL_STORAGE_KEY.to_owned());
  use_effect_with_deps(
  move |_: &[(); 0]| {
  let query = &location.search;
 
- if query.len() < 2 {
- return;
- }
-
- match serde_qs::from_str(&query[1..]) {
- Ok(algorithm) => {
- algorithm_setter.set(algorithm);
+ // First, we try to load data from the url.
+ // question mark + one any other char
+ if query.len() >= 2 {
+ match serde_qs::from_str(&query[1..]) {
+ Ok(algorithm) => {
+ algorithm_setter.set(algorithm);
+ }
+ Err(err) => notifications.spawn(Notification::new(
+ NotificationType::Error,
+ "Can not load data from url",
+ err.to_string(),
+ Notification::NOTIFICATION_LIFETIME,
+ )),
+ }
+ } else {
+ // Otherwise, we try to find a data in the local storage.
+ let raw_data = if let Some(raw_data) = (*local_storage).as_ref() {
+ raw_data.as_str()
+ } else {
+ return;
+ };
+ match serde_json::from_str(raw_data) {
+ Ok(algorithm) => {
+ algorithm_setter.set(algorithm);
+ }
+ Err(err) => notifications.spawn(Notification::new(
+ NotificationType::Error,
+ "Can not load data from the local storage",
+ err.to_string(),
+ Notification::NOTIFICATION_LIFETIME,
+ )),
  }
- Err(err) => notifications.spawn(Notification::new(
- NotificationType::Error,
- "Can not load data from url",
- err.to_string(),
- Notification::NOTIFICATION_LIFETIME,
- )),
  }
  },
  [],
  );
 
+ let local_storage = use_local_storage::<String>(CRYPTO_HELPER_LOCAL_STORAGE_KEY.to_owned());
+ use_effect_with_deps(
+ move |algorithm| {
+ let algorithm: &Algorithm = algorithm;
+ local_storage.set(
+ serde_json::to_string(algorithm).expect("algorithm serialization into json string should never fail"),
+ );
+ },
+ algorithm.clone(),
+ );
+
  let algorithm_data = (*algorithm).clone();
  let clipboard = use_clipboard();
  let share_by_link = Callback::from(move |_| {

src/crypto_helper/algorithm.rs

@@ -4,7 +4,7 @@ use rsa::pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey};
 use rsa::{RsaPrivateKey, RsaPublicKey};
 use serde::{Deserialize, Serialize};
 
-use super::serde::*;
+use crate::serde::*;
 
 pub const MD5: &str = "MD5";
 pub const SHA1: &str = "SHA1";

src/jwt.rs

@@ -10,7 +10,7 @@ use std::str::FromStr;
 
 use web_sys::{HtmlInputElement, KeyboardEvent};
 use yew::{function_component, html, use_effect_with_deps, use_state, Callback, Html, TargetCast};
-use yew_hooks::use_location;
+use yew_hooks::{use_local_storage, use_location};
 use yew_notifications::{use_notification, Notification, NotificationType};
 
 use crate::common::Checkbox;
@@ -20,6 +20,7 @@ use crate::jwt::jwt_utils::JwtUtils;
 use crate::jwt::jwte::Jwte;
 use crate::url_query_params;
 
+const JWT_LOCAL_STORAGE_KEY: &str = "JWT_DATA";
 const TEST_JWT: &str = "eyJhbGciOiJIUzI1NiJ9.eyJSb2xlIjoiQWRtaW4iLCJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkphdmFJblVzZSIsImV4cCI6MTY3MDAwNDI1NCwiaWF0IjoxNjcwMDA0MjU0fQ.ZGsN42vr-bM4uxXowtlNl7xRerkdKu6i29VS8DFQ4Tw";
 
 #[function_component(Jwt)]
@@ -86,11 +87,23 @@ pub fn jwt() -> Html {
  let jwt_setter = raw_jwt.setter();
  let jwte_setter = jwte.setter();
  let notifications = use_notification::<Notification>();
+ let local_storage = use_local_storage::<String>(JWT_LOCAL_STORAGE_KEY.to_owned());
  use_effect_with_deps(
  move |_: &[(); 0]| {
  let query = &location.search;
 
  if query.len() < 2 {
+ // URL query params is empty. We try to load JWT from local storage.
+ if let Some(raw_jwt) = (*local_storage).as_ref() {
+ match serde_json::from_str(raw_jwt.as_str()) {
+ Ok(jwt) => {
+ jwte_setter.set(Some(Jwte::Jwt(jwt)));
+ }
+ Err(err) => {
+ error!("Can not load JWT from local storage: {:?}", err);
+ }
+ }
+ }
  return;
  }
 
@@ -125,6 +138,17 @@ pub fn jwt() -> Html {
  [],
  );
 
+ let local_storage = use_local_storage::<String>(JWT_LOCAL_STORAGE_KEY.to_owned());
+ use_effect_with_deps(
+ move |jwte| {
+ let jwte: &Option<Jwte> = jwte;
+ if let Some(Jwte::Jwt(jwt)) = jwte {
+ local_storage.set(serde_json::to_string(jwt).expect("JWT serialization should not fail"));
+ }
+ },
+ jwte.clone(),
+ );
+
  let jwte_setter = jwte.setter();
  let set_jwt = Callback::from(move |jwt| {
  jwte_setter.set(Some(Jwte::Jwt(jwt)));

src/jwt/jwt.rs

@@ -1,11 +1,13 @@
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
 use super::signature::JwtSignatureAlgorithm;
+use crate::serde::{deserialize_bytes, serialize_bytes};
 
 pub mod editor;
 pub mod viewer;
 
-#[derive(Debug, PartialEq, Eq, Default, Clone)]
+#[derive(Debug, PartialEq, Eq, Default, Clone, Serialize, Deserialize)]
 pub struct Jwt {
  pub raw_header: String,
  pub parsed_header: String,
@@ -15,6 +17,7 @@ pub struct Jwt {
 
  pub raw_signature: String,
  pub parsed_signature: String,
+ #[serde(serialize_with = "serialize_bytes", deserialize_with = "deserialize_bytes")]
  pub signature: Vec<u8>,
  pub signature_algorithm: JwtSignatureAlgorithm,
 

src/jwt/jwt_utils.rs

@@ -427,7 +427,7 @@ fn validate_signature(jwt: &Jwt, spawn_notification: Callback<Notification>) ->
  Some(jwt.signature == calculated_signature)
 }
 
-fn generate_jwt(jwt: &Jwt, spawn_notification: Callback<Notification>) -> Option<Vec<u8>> {
+pub fn generate_jwt(jwt: &Jwt, spawn_notification: Callback<Notification>) -> Option<Vec<u8>> {
  let signature = calculate_signature(jwt, spawn_notification)?;
 
  let header = base64::encode_config(jwt.parsed_header.as_bytes(), base64::URL_SAFE_NO_PAD);

src/jwt/signature.rs

@@ -1,22 +1,28 @@
 use std::fmt::{self, Display};
 
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
+use crate::serde::{deserialize_bytes, serialize_bytes};
+
 const JWT_SIGNATURE_ALGORITHMS: [&str; 10] = [
  "HS256", "HS512", "none", "RS256", "HS384", "RS384", "RS512", "ES256", "ES384", "ES512",
 ];
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub enum JwtSignatureAlgorithm {
  None,
 
  /// HMAC using SHA-256
+ #[serde(serialize_with = "serialize_bytes", deserialize_with = "deserialize_bytes")]
  Hs256(Vec<u8>),
 
  /// HMAC using SHA-384
+ #[serde(serialize_with = "serialize_bytes", deserialize_with = "deserialize_bytes")]
  Hs384(Vec<u8>),
 
  /// HMAC using SHA-512
+ #[serde(serialize_with = "serialize_bytes", deserialize_with = "deserialize_bytes")]
  Hs512(Vec<u8>),
 
  /// RSASSA-PKCS1-v1_5 using SHA-256

src/main.rs

@@ -1,3 +1,6 @@
+#[macro_use]
+extern crate log;
+
 mod about;
 mod asn1;
 mod common;
@@ -6,6 +9,7 @@ mod footer;
 mod header;
 mod jwt;
 mod not_found;
+pub mod serde;
 mod url_query_params;
 mod utils;
 

src/url_query_params.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
-use crate::crypto_helper::serde::{deserialize_bytes, serialize_bytes};
 use crate::crypto_helper::Algorithm;
+use crate::serde::{deserialize_bytes, serialize_bytes};
 
 const APP_HOST: &str = env!("APP_HOST");