diff options
Diffstat (limited to 'examples')
| -rw-r--r-- | examples/password-hasher.rs | 19 | ||||
| -rw-r--r-- | examples/sql.rs | 188 |
2 files changed, 155 insertions, 52 deletions
diff --git a/examples/password-hasher.rs b/examples/password-hasher.rs index 92de7f7..3c88a40 100644 --- a/examples/password-hasher.rs +++ b/examples/password-hasher.rs @@ -1,6 +1,9 @@ use std::io::Write; -use argon2::{Argon2, password_hash::{rand_core::OsRng, PasswordHasher, PasswordHash, PasswordVerifier, SaltString}}; +use argon2::{ + password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString}, + Argon2, +}; fn main() -> std::io::Result<()> { eprint!("Type a password: "); @@ -15,19 +18,19 @@ fn main() -> std::io::Result<()> { let salt = SaltString::generate(&mut OsRng); let argon2 = Argon2::default(); //eprintln!("{}", password.trim()); - let password_hash = argon2.hash_password(password.trim().as_bytes(), &salt) + let password_hash = argon2 + .hash_password(password.trim().as_bytes(), &salt) .expect("Hashing a password should not error out") .serialize(); println!("{}", password_hash.as_str()); assert!(Argon2::default() - .verify_password( - password.trim().as_bytes(), - &PasswordHash::new(password_hash.as_str()) - .expect("Password hash should be valid") - ).is_ok() - ); + .verify_password( + password.trim().as_bytes(), + &PasswordHash::new(password_hash.as_str()).expect("Password hash should be valid") + ) + .is_ok()); Ok(()) } diff --git a/examples/sql.rs b/examples/sql.rs index 5d552da..59db1eb 100644 --- a/examples/sql.rs +++ b/examples/sql.rs @@ -15,8 +15,11 @@ fn sanitize(expr: &Expr) -> Result<(), Error> { match expr { Expr::Identifier(_) => Ok(()), Expr::CompoundIdentifier(_) => Ok(()), - Expr::JsonAccess { left, operator: _, right } => sanitize(left) - .and(sanitize(right)), + Expr::JsonAccess { + left, + operator: _, + right, + } => sanitize(left).and(sanitize(right)), Expr::CompositeAccess { expr, key: _ } => sanitize(expr), Expr::IsFalse(subexpr) => sanitize(subexpr), Expr::IsNotFalse(subexpr) => sanitize(subexpr), @@ -26,84 +29,180 @@ fn sanitize(expr: &Expr) -> Result<(), Error> { Expr::IsNotNull(subexpr) => sanitize(subexpr), Expr::IsUnknown(subexpr) => sanitize(subexpr), Expr::IsNotUnknown(subexpr) => sanitize(subexpr), - Expr::IsDistinctFrom(left, right) => sanitize(left) - .and(sanitize(right)), - Expr::IsNotDistinctFrom(left, right) => sanitize(left) - .and(sanitize(right)), - Expr::InList { expr, list, negated: _ } => sanitize(expr) - .and(list.iter().try_for_each(sanitize)), - Expr::InSubquery { expr: _, subquery, negated: _ } => Err(Error::SubqueryDetected(subquery.as_ref())), - Expr::InUnnest { expr, array_expr, negated: _ } => sanitize(expr).and(sanitize(array_expr)), - Expr::Between { expr, negated: _, low, high } => sanitize(expr) - .and(sanitize(low)) - .and(sanitize(high)), - Expr::BinaryOp { left, op: _, right } => sanitize(left) - .and(sanitize(right)), - Expr::Like { negated: _, expr, pattern, escape_char: _ } => sanitize(expr) - .and(sanitize(pattern)), - Expr::ILike { negated: _, expr, pattern, escape_char: _ } => sanitize(expr).and(sanitize(pattern)), - Expr::SimilarTo { negated: _, expr, pattern, escape_char: _ } => sanitize(expr).and(sanitize(pattern)), - Expr::RLike { negated: _, expr, pattern, regexp: _ } => sanitize(expr).and(sanitize(pattern)), - Expr::AnyOp { left, compare_op: _, right } => sanitize(left).and(sanitize(right)), - Expr::AllOp { left, compare_op: _, right } => sanitize(left).and(sanitize(right)), + Expr::IsDistinctFrom(left, right) => sanitize(left).and(sanitize(right)), + Expr::IsNotDistinctFrom(left, right) => sanitize(left).and(sanitize(right)), + Expr::InList { + expr, + list, + negated: _, + } => sanitize(expr).and(list.iter().try_for_each(sanitize)), + Expr::InSubquery { + expr: _, + subquery, + negated: _, + } => Err(Error::SubqueryDetected(subquery.as_ref())), + Expr::InUnnest { + expr, + array_expr, + negated: _, + } => sanitize(expr).and(sanitize(array_expr)), + Expr::Between { + expr, + negated: _, + low, + high, + } => sanitize(expr).and(sanitize(low)).and(sanitize(high)), + Expr::BinaryOp { left, op: _, right } => sanitize(left).and(sanitize(right)), + Expr::Like { + negated: _, + expr, + pattern, + escape_char: _, + } => sanitize(expr).and(sanitize(pattern)), + Expr::ILike { + negated: _, + expr, + pattern, + escape_char: _, + } => sanitize(expr).and(sanitize(pattern)), + Expr::SimilarTo { + negated: _, + expr, + pattern, + escape_char: _, + } => sanitize(expr).and(sanitize(pattern)), + Expr::RLike { + negated: _, + expr, + pattern, + regexp: _, + } => sanitize(expr).and(sanitize(pattern)), + Expr::AnyOp { + left, + compare_op: _, + right, + } => sanitize(left).and(sanitize(right)), + Expr::AllOp { + left, + compare_op: _, + right, + } => sanitize(left).and(sanitize(right)), Expr::UnaryOp { op: _, expr } => sanitize(expr), - Expr::Convert { expr, data_type: _, charset: _, target_before_value: _ } => sanitize(expr), - Expr::Cast { expr, data_type: _, format: _ } => sanitize(expr), - Expr::TryCast { expr, data_type: _, format: _ } => sanitize(expr), - Expr::SafeCast { expr, data_type: _, format: _ } => sanitize(expr), - Expr::AtTimeZone { timestamp, time_zone: _ } => sanitize(timestamp), + Expr::Convert { + expr, + data_type: _, + charset: _, + target_before_value: _, + } => sanitize(expr), + Expr::Cast { + expr, + data_type: _, + format: _, + } => sanitize(expr), + Expr::TryCast { + expr, + data_type: _, + format: _, + } => sanitize(expr), + Expr::SafeCast { + expr, + data_type: _, + format: _, + } => sanitize(expr), + Expr::AtTimeZone { + timestamp, + time_zone: _, + } => sanitize(timestamp), Expr::Extract { field: _, expr } => sanitize(expr), Expr::Ceil { expr, field: _ } => sanitize(expr), Expr::Floor { expr, field: _ } => sanitize(expr), Expr::Position { expr, r#in } => sanitize(expr).and(sanitize(r#in)), - Expr::Substring { expr, substring_from, substring_for, special: _ } => sanitize(expr) + Expr::Substring { + expr, + substring_from, + substring_for, + special: _, + } => sanitize(expr) .and(substring_from.as_deref().map(sanitize).unwrap_or(Ok(()))) .and(substring_for.as_deref().map(sanitize).unwrap_or(Ok(()))), - Expr::Trim { expr, trim_where: _, trim_what, trim_characters } => sanitize(expr) + Expr::Trim { + expr, + trim_where: _, + trim_what, + trim_characters, + } => sanitize(expr) .and(trim_what.as_deref().map(sanitize).unwrap_or(Ok(()))) .and( trim_characters .as_ref() .map(|v| v.iter()) .map(|mut iter| iter.try_for_each(sanitize)) - .unwrap_or(Ok(())) + .unwrap_or(Ok(())), ), - Expr::Overlay { expr, overlay_what, overlay_from, overlay_for } => sanitize(expr) + Expr::Overlay { + expr, + overlay_what, + overlay_from, + overlay_for, + } => sanitize(expr) .and(sanitize(overlay_what)) .and(sanitize(overlay_from)) .and(overlay_for.as_deref().map(sanitize).unwrap_or(Ok(()))), Expr::Collate { expr, collation: _ } => sanitize(expr), Expr::Nested(subexpr) => sanitize(subexpr), Expr::Value(_) => Ok(()), - Expr::IntroducedString { introducer: _, value: _ } => Ok(()), - Expr::TypedString { data_type: _, value: _ } => Ok(()), - Expr::MapAccess { column, keys } => sanitize(column).and(keys.iter().try_for_each(sanitize)), + Expr::IntroducedString { + introducer: _, + value: _, + } => Ok(()), + Expr::TypedString { + data_type: _, + value: _, + } => Ok(()), + Expr::MapAccess { column, keys } => { + sanitize(column).and(keys.iter().try_for_each(sanitize)) + } Expr::Function(func) => Err(Error::FunctionCallDetected(func)), - Expr::AggregateExpressionWithFilter { expr, filter } => sanitize(expr).and(sanitize(filter)), - Expr::Case { operand, conditions, results, else_result } => conditions.iter() + Expr::AggregateExpressionWithFilter { expr, filter } => { + sanitize(expr).and(sanitize(filter)) + } + Expr::Case { + operand, + conditions, + results, + else_result, + } => conditions + .iter() .chain(results) .chain(operand.iter().map(std::borrow::Borrow::borrow)) .chain(else_result.iter().map(std::borrow::Borrow::borrow)) .try_for_each(sanitize), - Expr::Exists { subquery, negated: _ } => Err(Error::SubqueryDetected(subquery)), + Expr::Exists { + subquery, + negated: _, + } => Err(Error::SubqueryDetected(subquery)), Expr::Subquery(subquery) => Err(Error::SubqueryDetected(subquery.as_ref())), Expr::ArraySubquery(subquery) => Err(Error::SubqueryDetected(subquery.as_ref())), Expr::ListAgg(agg) => sanitize(&agg.expr), Expr::ArrayAgg(agg) => sanitize(&agg.expr), - Expr::GroupingSets(sets) => sets.iter() + Expr::GroupingSets(sets) => sets + .iter() .map(|i| i.iter()) .try_for_each(|mut si| si.try_for_each(sanitize)), - Expr::Cube(cube) => cube.iter() + Expr::Cube(cube) => cube + .iter() .map(|i| i.iter()) .try_for_each(|mut si| si.try_for_each(sanitize)), - Expr::Rollup(rollup) => rollup.iter() + Expr::Rollup(rollup) => rollup + .iter() .map(|i| i.iter()) .try_for_each(|mut si| si.try_for_each(sanitize)), Expr::Tuple(tuple) => tuple.iter().try_for_each(sanitize), Expr::Struct { values, fields: _ } => values.iter().try_for_each(sanitize), Expr::Named { expr, name: _ } => sanitize(expr), - Expr::ArrayIndex { obj, indexes } => sanitize(obj) - .and(indexes.iter().try_for_each(sanitize)), + Expr::ArrayIndex { obj, indexes } => { + sanitize(obj).and(indexes.iter().try_for_each(sanitize)) + } Expr::Array(array) => array.elem.iter().try_for_each(sanitize), Expr::Interval(interval) => sanitize(&interval.value), Expr::MatchAgainst { .. } => Ok(()), @@ -115,7 +214,8 @@ fn sanitize(expr: &Expr) -> Result<(), Error> { fn main() -> Result<(), sqlparser::parser::ParserError> { let query = std::env::args().skip(1).take(1).next().unwrap(); - static DIALECT: sqlparser::dialect::PostgreSqlDialect = sqlparser::dialect::PostgreSqlDialect {}; + static DIALECT: sqlparser::dialect::PostgreSqlDialect = + sqlparser::dialect::PostgreSqlDialect {}; let parser: sqlparser::parser::Parser<'static> = sqlparser::parser::Parser::new(&DIALECT); let expr = parser.try_with_sql(&query)?.parse_expr()?; @@ -125,6 +225,6 @@ fn main() -> Result<(), sqlparser::parser::ParserError> { eprintln!("{}", err); } } - + Ok(()) } |