crypto-helper:

* update yew dependencies;
* add rustfmt.toml. format code;

ci:
* update trunk version;
* move clippy to the 'check' job. add fmt step to it;

Author: TheBestTvarynka

.github/workflows/github-actions.yml

@@ -7,9 +7,30 @@ on:
     branches:
     - 'main'
 jobs:
+  check:
+    name: Check code
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: 'Add nightly channel'
+      run: 'rustup toolchain install nightly'
+
+    - name: 'Add nightly fmt'
+      run: 'rustup component add rustfmt --toolchain nightly-x86_64-unknown-linux-gnu'
+
+    - name: 'Fmt'
+      run: 'cargo +nightly fmt --all -- --check'
+
+    - name: 'Clippy'
+      run: 'cargo clippy -- -D warnings'
+
   deploy:
     name: Deploy
     runs-on: ubuntu-latest
+    needs: check
 
     permissions:
       contents: 'read'
@@ -20,10 +41,7 @@ jobs:
       uses: actions/checkout@v3
 
     - name: 'Trunk Check'
-      uses: jetli/[email protected]
-
-    - name: 'Clippy'
-      run: 'cargo clippy -- -D warnings'
+      uses: jetli/[email protected]
 
     - id: 'auth'
       name: 'Authenticate to Google Cloud'

Cargo.lock

@@ -9,8 +9,8 @@ license-file = "LICENSE"
 repository = "https://github.com/TheBestTvarynka/crypto-helper"
 
 [dependencies]
-yew = { git = "https://github.com/yewstack/yew.git", rev = "5355b65ff5f9747cbad801d4b337a5ac7a94d0f4", features = ["csr"] }
-yew-router = { git = "https://github.com/yewstack/yew.git", rev = "5355b65ff5f9747cbad801d4b337a5ac7a94d0f4" }
+yew = { version = "0.20", features = ["csr"] }
+yew-router = "0.17.0"
 
 # wasm
 js-sys = "0.3.60"

Cargo.toml

@@ -0,0 +1,4 @@
+max_width = 120
+reorder_imports = true
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"

rustfmt.toml

@@ -5,26 +5,21 @@ mod input;
 mod output;
 
 pub use algorithm::RSA_HASH_ALGOS;
-
 use gloo_timers::callback::Timeout;
+use info::Info;
+use input::Input;
+use output::Output;
 use picky_krb::crypto::{ChecksumSuite, CipherSuite};
 use sha1::{Digest, Sha1};
 use uuid::Uuid;
 use yew::{classes, function_component, html, use_effect_with_deps, use_state, Callback, Html};
 
-use info::Info;
-use input::Input;
-use output::Output;
-
+use self::algorithm::Algorithm;
+use self::computations::{process_krb_cipher, process_krb_hmac, process_rsa};
 use crate::notification::{
     get_new_notifications, Notification, NotificationType, Notifications, NOTIFICATION_DURATION,
 };
 
-use self::{
-    algorithm::Algorithm,
-    computations::{process_krb_cipher, process_krb_hmac, process_rsa},
-};
-
 fn from_hex(input: &str) -> Result<Vec<u8>, String> {
     hex::decode(input).map_err(|err| format!("invalid hex input:{:?}", err))
 }
@@ -38,19 +33,11 @@ fn convert(algrithm: &Algorithm) -> Result<Vec<u8>, String> {
             Ok(sha1.finalize().to_vec())
         }
         Algorithm::Sha256(input) => Ok(hmac_sha256::Hash::hash(&from_hex(input)?).to_vec()),
-        Algorithm::Sha512(input) => Ok(hmac_sha512::Hash::hash(&from_hex(input)?).to_vec()),
-        Algorithm::Aes128CtsHmacSha196(input) => {
-            process_krb_cipher(CipherSuite::Aes128CtsHmacSha196.cipher(), input)
-        }
-        Algorithm::Aes256CtsHmacSha196(input) => {
-            process_krb_cipher(CipherSuite::Aes256CtsHmacSha196.cipher(), input)
-        }
-        Algorithm::HmacSha196Aes128(input) => {
-            process_krb_hmac(ChecksumSuite::HmacSha196Aes128.hasher(), input)
-        }
-        Algorithm::HmacSha196Aes256(input) => {
-            process_krb_hmac(ChecksumSuite::HmacSha196Aes256.hasher(), input)
-        }
+        Algorithm::Sha512(input) => Ok(hmac_sha512::Hash::hash(from_hex(input)?).to_vec()),
+        Algorithm::Aes128CtsHmacSha196(input) => process_krb_cipher(CipherSuite::Aes128CtsHmacSha196.cipher(), input),
+        Algorithm::Aes256CtsHmacSha196(input) => process_krb_cipher(CipherSuite::Aes256CtsHmacSha196.cipher(), input),
+        Algorithm::HmacSha196Aes128(input) => process_krb_hmac(ChecksumSuite::HmacSha196Aes128.hasher(), input),
+        Algorithm::HmacSha196Aes256(input) => process_krb_hmac(ChecksumSuite::HmacSha196Aes256.hasher(), input),
         Algorithm::Rsa(input) => process_rsa(input),
     }
 }

src/crypto_helper.rs

@@ -1,19 +1,13 @@
-use picky::{
-    key::{PrivateKey, PublicKey},
-    signature::SignatureAlgorithm,
-};
+use picky::key::{PrivateKey, PublicKey};
+use picky::signature::SignatureAlgorithm;
 use picky_krb::crypto::{Checksum, Cipher};
 use rand::SeedableRng;
 use rand_chacha::ChaCha8Rng;
-use rsa::{
-    pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey},
-    PaddingScheme, PublicKey as PublicKeyTrait, RsaPrivateKey, RsaPublicKey,
-};
+use rsa::pkcs1::{DecodeRsaPrivateKey, DecodeRsaPublicKey};
+use rsa::{PaddingScheme, PublicKey as PublicKeyTrait, RsaPrivateKey, RsaPublicKey};
 
-use super::{
-    algorithm::{KrbInput, KrbInputData, RsaAction, RsaInput},
-    from_hex,
-};
+use super::algorithm::{KrbInput, KrbInputData, RsaAction, RsaInput};
+use super::from_hex;
 
 pub fn process_rsa(input: &RsaInput) -> Result<Vec<u8>, String> {
     let payload = from_hex(&input.payload)?;
@@ -26,23 +20,20 @@ pub fn process_rsa(input: &RsaInput) -> Result<Vec<u8>, String> {
                 .map_err(|err| err.to_string())
         }
         RsaAction::Decrypt(input) => {
-            let private_key =
-                RsaPrivateKey::from_pkcs1_pem(input).map_err(|err| err.to_string())?;
+            let private_key = RsaPrivateKey::from_pkcs1_pem(input).map_err(|err| err.to_string())?;
             private_key
                 .decrypt(PaddingScheme::PKCS1v15Encrypt, &payload)
                 .map_err(|err| err.to_string())
         }
         RsaAction::Sign(input) => {
-            let private_key =
-                PrivateKey::from_pem_str(&input.rsa_key).map_err(|err| err.to_string())?;
+            let private_key = PrivateKey::from_pem_str(&input.rsa_key).map_err(|err| err.to_string())?;
             Ok(SignatureAlgorithm::RsaPkcs1v15(input.hash_algorithm.0)
                 .sign(&payload, &private_key)
                 .map_err(|err| err.to_string())?)
         }
         RsaAction::Verify(input) => {
             let signature = from_hex(&input.signature)?;
-            let public_key =
-                PublicKey::from_pem_str(&input.rsa_key).map_err(|err| err.to_string())?;
+            let public_key = PublicKey::from_pem_str(&input.rsa_key).map_err(|err| err.to_string())?;
             SignatureAlgorithm::RsaPkcs1v15(input.hash_algorithm.0)
                 .verify(&public_key, &payload, &signature)
                 .map(|_| vec![1])
@@ -79,10 +70,7 @@ pub fn process_krb_cipher(cipher: Box<dyn Cipher>, input: &KrbInput) -> Result<V
     }
 }
 
-pub fn process_krb_hmac(
-    hasher: Box<dyn Checksum>,
-    input: &KrbInputData,
-) -> Result<Vec<u8>, String> {
+pub fn process_krb_hmac(hasher: Box<dyn Checksum>, input: &KrbInputData) -> Result<Vec<u8>, String> {
     hasher
         .checksum(
             &from_hex(&input.key).map_err(|err| format!("key: {}", err))?,

src/crypto_helper/computations.rs

@@ -1,14 +1,11 @@
 mod algo_search;
 
 use web_sys::HtmlInputElement;
-use yew::{
-    classes, function_component, html, html::onchange::Event, use_state, Callback, Html,
-    Properties, TargetCast, UseStateSetter,
-};
-
-use crate::crypto_helper::info::algo_search::AlgoSearch;
+use yew::html::onchange::Event;
+use yew::{classes, function_component, html, use_state, Callback, Html, Properties, TargetCast, UseStateSetter};
 
 use super::algorithm::{Algorithm, SUPPORTED_ALGORITHMS};
+use crate::crypto_helper::info::algo_search::AlgoSearch;
 
 #[derive(PartialEq, Properties)]
 pub struct InfoProps {

src/crypto_helper/info.rs

@@ -1,7 +1,7 @@
 use web_sys::{Event, FocusEvent, HtmlInputElement, InputEvent, KeyboardEvent, MouseEvent};
 use yew::{
-    classes, function_component, html, use_effect_with_deps, use_state, Callback, Html, Properties,
-    TargetCast, UseStateSetter,
+    classes, function_component, html, use_effect_with_deps, use_state, Callback, Html, Properties, TargetCast,
+    UseStateSetter,
 };
 
 use crate::crypto_helper::algorithm::{Algorithm, SUPPORTED_ALGORITHMS};

src/crypto_helper/info/algo_search.rs

@@ -5,9 +5,11 @@ mod simple;
 use picky_krb::crypto::CipherSuite;
 use yew::{classes, function_component, html, Callback, Html, Properties, UseStateSetter};
 
-use self::{krb::build_krb_input, rsa::build_rsa_input, simple::build_simple_input};
-
-use super::{algorithm::KrbInput, Algorithm};
+use self::krb::build_krb_input;
+use self::rsa::build_rsa_input;
+use self::simple::build_simple_input;
+use super::algorithm::KrbInput;
+use super::Algorithm;
 
 fn get_input_components(algorithm: &Algorithm, setter: &UseStateSetter<Algorithm>) -> Html {
     let setter = setter.clone();
@@ -30,17 +32,13 @@ fn get_input_components(algorithm: &Algorithm, setter: &UseStateSetter<Algorithm
         ),
         Algorithm::Aes128CtsHmacSha196(kerberos_input) => build_krb_input(
             kerberos_input.clone(),
-            Callback::from(move |kerberos_input| {
-                setter.set(Algorithm::Aes128CtsHmacSha196(kerberos_input))
-            }),
+            Callback::from(move |kerberos_input| setter.set(Algorithm::Aes128CtsHmacSha196(kerberos_input))),
             CipherSuite::Aes128CtsHmacSha196,
             true,
         ),
         Algorithm::Aes256CtsHmacSha196(kerberos_input) => build_krb_input(
             kerberos_input.clone(),
-            Callback::from(move |kerberos_input| {
-                setter.set(Algorithm::Aes256CtsHmacSha196(kerberos_input))
-            }),
+            Callback::from(move |kerberos_input| setter.set(Algorithm::Aes256CtsHmacSha196(kerberos_input))),
             CipherSuite::Aes256CtsHmacSha196,
             true,
         ),

src/crypto_helper/input.rs

@@ -1,8 +1,7 @@
 use picky_krb::crypto::CipherSuite;
 use web_sys::{HtmlInputElement, InputEvent, MouseEvent};
 use yew::{
-    classes, function_component, html, use_effect, use_state, Callback, Html, Properties,
-    TargetCast, UseStateSetter,
+    classes, function_component, html, use_effect, use_state, Callback, Html, Properties, TargetCast, UseStateSetter,
 };
 
 use crate::common::Switch;

src/crypto_helper/input/krb.rs

@@ -2,8 +2,7 @@ use web_sys::{Event, HtmlInputElement};
 use yew::{classes, function_component, html, Callback, Classes, Html, Properties, TargetCast};
 
 use crate::crypto_helper::algorithm::{
-    RsaAction, RsaHashAlgorithm, RsaInput as RsaInputData, RsaSignInput, RsaVerifyInput,
-    RSA_HASH_ALGOS,
+    RsaAction, RsaHashAlgorithm, RsaInput as RsaInputData, RsaSignInput, RsaVerifyInput, RSA_HASH_ALGOS,
 };
 
 #[derive(Debug, PartialEq, Properties)]
@@ -20,10 +19,7 @@ fn get_action_classes(is_selected: bool) -> Classes {
     }
 }
 
-fn generate_selection_action_component(
-    action: &RsaAction,
-    set_action: Callback<RsaAction>,
-) -> Html {
+fn generate_selection_action_component(action: &RsaAction, set_action: Callback<RsaAction>) -> Html {
     html! {
         <div class={classes!("rsa-actions-container")}>
             {RsaAction::enumerate_actions()
@@ -44,10 +40,7 @@ fn generate_selection_action_component(
     }
 }
 
-fn get_hash_selection_component(
-    hash_algorithm: &RsaHashAlgorithm,
-    set_hash_algo: Callback<RsaHashAlgorithm>,
-) -> Html {
+fn get_hash_selection_component(hash_algorithm: &RsaHashAlgorithm, set_hash_algo: Callback<RsaHashAlgorithm>) -> Html {
     let onchange = Callback::from(move |event: Event| {
         let input: HtmlInputElement = event.target_unchecked_into();
 
@@ -77,8 +70,7 @@ fn get_hash_selection_component(
 }
 
 fn generate_rsa_input(input: &RsaAction, set_action: Callback<RsaAction>) -> Html {
-    let selected_algorithm_component =
-        generate_selection_action_component(input, set_action.clone());
+    let selected_algorithm_component = generate_selection_action_component(input, set_action.clone());
     match input {
         RsaAction::Encrypt(input) => {
             let oninput = Callback::from(move |event: html::oninput::Event| {

src/crypto_helper/input/rsa.rs

@@ -3,28 +3,19 @@ mod simple;
 
 use yew::{classes, function_component, html, Callback, Html, Properties};
 
-use crate::notification::Notification;
-
-use self::{krb::build_krb_output, simple::build_simple_output};
-
+use self::krb::build_krb_output;
+use self::simple::build_simple_output;
 use super::Algorithm;
+use crate::notification::Notification;
 
-fn get_output_components(
-    algorithm: &Algorithm,
-    output: &[u8],
-    add_notification: &Callback<Notification>,
-) -> Html {
+fn get_output_components(algorithm: &Algorithm, output: &[u8], add_notification: &Callback<Notification>) -> Html {
     match algorithm {
         Algorithm::Md5(_) => build_simple_output(output, add_notification.clone()),
         Algorithm::Sha1(_) => build_simple_output(output, add_notification.clone()),
         Algorithm::Sha256(_) => build_simple_output(output, add_notification.clone()),
         Algorithm::Sha512(_) => build_simple_output(output, add_notification.clone()),
-        Algorithm::Aes128CtsHmacSha196(input) => {
-            build_krb_output(input, output, add_notification.clone())
-        }
-        Algorithm::Aes256CtsHmacSha196(input) => {
-            build_krb_output(input, output, add_notification.clone())
-        }
+        Algorithm::Aes128CtsHmacSha196(input) => build_krb_output(input, output, add_notification.clone()),
+        Algorithm::Aes256CtsHmacSha196(input) => build_krb_output(input, output, add_notification.clone()),
         Algorithm::HmacSha196Aes128(_) => build_simple_output(output, add_notification.clone()),
         Algorithm::HmacSha196Aes256(_) => build_simple_output(output, add_notification.clone()),
         Algorithm::Rsa(_) => build_simple_output(output, add_notification.clone()),