CloudNebulaProject/ips
1
0
Fork 0
mirror of https://codeberg.org/Toasterson/ips.git synced 2026-04-10 21:30:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fixing clippy issues

Browse source 
Signed-off-by: Till Wegmueller <toasterson@gmail.com>
This commit is contained in:
Till Wegmueller 2023-03-25 13:01:05 +01:00
parent 8b9e69a787
commit 59ae8ea4cc
No known key found for this signature in database
2 changed files with 58 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libips/Cargo.toml
View file

@ -25,3 +25,4 @@ sha2 = "0.9.3"
sha3 = "0.9.1" sha3 = "0.9.1"
pest = "2.1.3" pest = "2.1.3"
pest_derive = "2.1.0" pest_derive = "2.1.0"
strum = { version = "0.24.1", features = ["derive"] }

115
libips/src/digest/mod.rs
View file

@ -3,47 +3,54 @@
// MPL was not distributed with this file, You can // MPL was not distributed with this file, You can
// obtain one at https://mozilla.org/MPL/2.0/. // obtain one at https://mozilla.org/MPL/2.0/.
use thiserror::Error; use sha2::Digest as Sha2Digest;
use std::result::Result as StdResult;
use std::str::FromStr;
use sha2::{Digest as Sha2Digest};
#[allow(unused_imports)] #[allow(unused_imports)]
use sha3::{Digest as Sha3Digest}; use sha3::Digest as Sha3Digest;
use std::str::FromStr;
use std::{convert::TryInto, result::Result as StdResult};
use strum::{Display as StrumDisplay, EnumString};
use thiserror::Error;
type Result<T> = StdResult<T, DigestError>; type Result<T> = StdResult<T, DigestError>;
#[allow(dead_code)] #[allow(dead_code)]
static DEFAULT_ALGORITHM: DigestAlgorithm = DigestAlgorithm::SHA512; static DEFAULT_ALGORITHM: DigestAlgorithm = DigestAlgorithm::SHA512;
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone, StrumDisplay, EnumString, Default)]
pub enum DigestAlgorithm { pub enum DigestAlgorithm {
#[strum(serialize = "sha1")]
SHA1, //Default, sadly SHA1, //Default, sadly
#[strum(serialize = "sha256t")]
SHA256, //sha256t SHA256, //sha256t
#[default]
#[strum(serialize = "sha512t")]
SHA512, //sha512t SHA512, //sha512t
#[strum(serialize = "sha512t_256")]
SHA512Half, //sha512t_256 SHA512Half, //sha512t_256
#[strum(serialize = "sha3256t")]
SHA3256, // Sha3 version of sha256t SHA3256, // Sha3 version of sha256t
#[strum(serialize = "sha3512t_256")]
SHA3512Half, // Sha3 version of sha512t_256 SHA3512Half, // Sha3 version of sha512t_256
#[strum(serialize = "sha3512t")]
SHA3512, // Sha3 version of sha512t SHA3512, // Sha3 version of sha512t
} }
impl Default for DigestAlgorithm { #[derive(Debug, PartialEq, Clone, StrumDisplay, EnumString, Default)]
fn default() -> Self { DigestAlgorithm::SHA1 }
}
#[derive(Debug, PartialEq, Clone)]
pub enum DigestSource { pub enum DigestSource {
#[strum(serialize = "gzip")]
GzipCompressed, GzipCompressed,
#[strum(serialize = "gelf")]
GNUElf, GNUElf,
#[strum(serialize = "gelf.unsigned")]
GNUElfUnsigned, GNUElfUnsigned,
#[strum(serialize = "file")]
UncompressedFile, UncompressedFile,
#[strum(serialize = "unknown")]
Unknown, Unknown,
#[default]
PrimaryPayloadHash, PrimaryPayloadHash,
} }
impl Default for DigestSource {
fn default() -> Self { DigestSource::PrimaryPayloadHash }
}
#[derive(Debug, Default, PartialEq, Clone)] #[derive(Debug, Default, PartialEq, Clone)]
pub struct Digest { pub struct Digest {
pub hash: String, pub hash: String,
@ -57,7 +64,7 @@ impl FromStr for Digest {
fn from_str(s: &str) -> StdResult<Self, Self::Err> { fn from_str(s: &str) -> StdResult<Self, Self::Err> {
let str = String::from(s); let str = String::from(s);
if !s.contains(':') { if !s.contains(':') {
return Ok(Digest{ return Ok(Digest {
hash: String::from(s), hash: String::from(s),
algorithm: DigestAlgorithm::SHA1, algorithm: DigestAlgorithm::SHA1,
source: DigestSource::PrimaryPayloadHash, source: DigestSource::PrimaryPayloadHash,
@ -66,30 +73,19 @@ impl FromStr for Digest {
let parts: Vec<&str> = str.split(':').collect(); let parts: Vec<&str> = str.split(':').collect();
if parts.len() < 3 { if parts.len() < 3 {
return Err(DigestError::InvalidDigestFormat{ return Err(DigestError::InvalidDigestFormat {
digest: String::from(s), digest: String::from(s),
details: "cannot split into 3 parts".to_string(), details: "cannot split into 3 parts".to_string(),
}); });
} }
Ok(Digest{ Ok(Digest {
source: match parts[0] { source: parts[0].try_into().unwrap_or(DigestSource::Unknown),
"file" => DigestSource::UncompressedFile, algorithm: parts[1]
"gzip" => DigestSource::GzipCompressed, .try_into()
"gelf" => DigestSource::GNUElf, .map_err(|_e| DigestError::UnknownAlgorithm {
"gelf.unsigned" => DigestSource::GNUElfUnsigned, algorithm: String::from(parts[1]),
_ => DigestSource::Unknown, })?,
},
algorithm: match parts[1] {
"sha1" => DigestAlgorithm::SHA1,
"sha256t" => DigestAlgorithm::SHA256,
"sha512t_256" => DigestAlgorithm::SHA512Half,
"sha512t" => DigestAlgorithm::SHA512,
"sha3256t" => DigestAlgorithm::SHA3256,
"sha3512t_256" => DigestAlgorithm::SHA3512Half,
"sha3512t" => DigestAlgorithm::SHA3512,
_ => return Err(DigestError::UnknownAlgorithm {algorithm: String::from(parts[1])}),
},
hash: String::from(parts[2]), hash: String::from(parts[2]),
}) })
} }
@ -98,7 +94,7 @@ impl FromStr for Digest {
impl Digest { impl Digest {
pub fn from_bytes(b: &[u8], algo: DigestAlgorithm, src: DigestSource) -> Result<Self> { pub fn from_bytes(b: &[u8], algo: DigestAlgorithm, src: DigestSource) -> Result<Self> {
let hash = match algo { let hash = match algo {
DigestAlgorithm::SHA256=> { DigestAlgorithm::SHA256 => {
format!("{:x}", sha2::Sha256::digest(b)) format!("{:x}", sha2::Sha256::digest(b))
} }
DigestAlgorithm::SHA512Half => { DigestAlgorithm::SHA512Half => {
@ -115,8 +111,7 @@ impl Digest {
} }
}; };
Ok(Digest {
Ok(Digest{
source: src, source: src,
algorithm: algo, algorithm: algo,
hash, hash,
@ -124,33 +119,33 @@ impl Digest {
} }
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
format!("{}:{}:{}", match self.source { format!(
DigestSource::UncompressedFile => "file", "{}:{}:{}",
DigestSource::GzipCompressed => "gzip", match self.source {
DigestSource::GNUElf => "gelf", DigestSource::UncompressedFile => "file",
DigestSource::GNUElfUnsigned => "gelf.unsigned", DigestSource::GzipCompressed => "gzip",
DigestSource::Unknown | _ => "unknown", DigestSource::GNUElf => "gelf",
}, match self.algorithm { DigestSource::GNUElfUnsigned => "gelf.unsigned",
DigestAlgorithm::SHA1 => "sha1", DigestSource::Unknown | _ => "unknown",
DigestAlgorithm::SHA256 => "sha256t", },
DigestAlgorithm::SHA512Half => "sha512t_256", match self.algorithm {
DigestAlgorithm::SHA512 => "sha512t", DigestAlgorithm::SHA1 => "sha1",
DigestAlgorithm::SHA3256 => "sha3256t", DigestAlgorithm::SHA256 => "sha256t",
DigestAlgorithm::SHA3512Half => "sha3512t_256", DigestAlgorithm::SHA512Half => "sha512t_256",
DigestAlgorithm::SHA3512 => "sha3512t", DigestAlgorithm::SHA512 => "sha512t",
}, self.hash) DigestAlgorithm::SHA3256 => "sha3256t",
DigestAlgorithm::SHA3512Half => "sha3512t_256",
DigestAlgorithm::SHA3512 => "sha3512t",
},
self.hash
)
} }
} }
#[derive(Debug, Error)] #[derive(Debug, Error)]
pub enum DigestError { pub enum DigestError {
#[error("hashing algorithm {algorithm:?} is not known by this library")] #[error("hashing algorithm {algorithm:?} is not known by this library")]
UnknownAlgorithm { UnknownAlgorithm { algorithm: String },
algorithm: String,
},
#[error("digest {digest:?} is not formatted properly: {details:?}")] #[error("digest {digest:?} is not formatted properly: {details:?}")]
InvalidDigestFormat{ InvalidDigestFormat { digest: String, details: String },
digest: String,
details: String,
},
} }