DEV Community: Ramin Farajpour Cami

Trait-Driven Rust Architecture

Ramin Farajpour Cami — Sat, 30 Aug 2025 06:22:37 +0000

Trait-Driven Rust Architecture

This project demonstrates clean architecture principles in Rust using traits, structured error handling, and domain modeling. It's designed to showcase professional Rust development patterns and best practices.

Key Features

Trait-first Architecture: Contracts separated from implementation details
- Feature-gated Serialization: Choose your serialization format (JSON or Bincode)
- Robust Error Handling: Clear error management using thiserror
- Domain Modeling: Business models with state enums
- Clean Layering: Well-separated application layers

Building and Running

# Run tests with bincode serialization
cargo test --features bincode

# Run tests with JSON serialization  
cargo test --features json

# Run CLI application with bincode
cargo run --bin cli --features "cli bincode"

# Run CLI application with JSON
cargo run --bin cli --features "cli json"

# Check syntax and compilation
cargo check --features bincode

Project Structure

traity-app/
├── src/
│   ├── lib.rs              # Main library entry point
│   ├── prelude.rs          # Common imports and re-exports
│   ├── error.rs            # ErrorCode definitions and Result types
│   ├── traits/             # Trait definitions
│   │   ├── serialize.rs    # MySerialize/MyDeserialize traits
│   │   └── owner.rs        # Owner trait for access control
│   ├── domain/             # Domain models and business logic
│   │   ├── user.rs         # User struct and methods
│   │   ├── vault.rs        # Vault struct with business rules
│   │   └── state.rs        # VaultState enum for state management
│   └── infra/              # Infrastructure layer
│       └── storage.rs      # Storage trait and implementations
├── bin/
│   └── cli.rs              # Command-line interface example
└── tests/
    └── integration.rs      # Integration tests

Learning Concepts

1. Trait-based Design Pattern

Traits in Rust define shared behavior without specifying implementation details:

pub trait MySerialize {
    fn try_serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<()>;
}

pub trait Owner {
    type OwnerId: Copy + Eq + Debug;
    fn owner_id(&self) -> Self::OwnerId;
}

Why use traits?

Flexibility: Different types can implement the same behavior differently
- Testability: Easy to mock dependencies in tests
- Extensibility: Add new implementations without changing existing code

2. Feature-gated Implementations

Rust's feature flags allow conditional compilation:

#[cfg(feature = "bincode")]
mod bincode_impls {
    // Implementation using bincode for binary serialization
}

#[cfg(feature = "json")]  
mod json_impls {
    // Implementation using JSON for text serialization
}

Benefits:

Reduced dependencies: Only compile what you need
- Flexibility: Choose serialization format at compile time
- Performance: Binary vs. human-readable trade-offs

3. State Management with Enums

Rust enums are powerful for modeling business states:

pub enum VaultState {
    Uninitialized,
    Active { frozen: bool },
    Closed,
}

// Usage with pattern matching
impl Vault {
    pub fn deposit(&mut self, amount: u64) -> Result<()> {
        match self.state {
            VaultState::Active { frozen: false } => {
                self.balance += amount;
                Ok(())
            }
            VaultState::Active { frozen: true } => {
                Err(ErrorCode::VaultFrozen)
            }
            _ => Err(ErrorCode::InvalidState),
        }
    }
}

Advantages:

Type safety: Compiler ensures all states are handled
- Clarity: Business rules are explicit in code
- Maintainability: Easy to add new states and transitions

4. Structured Error Handling

Using thiserror for clean error definitions:

#[derive(Debug, Error)]
pub enum ErrorCode {
    #[error("Invalid data format")]
    InvalidData,

    #[error("Missing required field: {0}")]
    MissingField(&'static str),

    #[error("Not owner of this resource")]
    NotOwner,

    #[error("Vault is currently frozen")]
    VaultFrozen,

    #[error("Invalid state for this operation")]
    InvalidState,
}

Best practices:

Descriptive messages: Help users understand what went wrong
- Categorization: Group related errors for better handling
- Context: Include relevant information in error variants

Getting Started

Step 1: Clone and Build

git clone <your-repo>
cd traity-app
cargo build --features bincode

Step 2: Run Tests

# Test core functionality
cargo test --features bincode -- --nocapture

# Test with different serialization
cargo test --features json -- --nocapture

Step 3: Try the CLI

# Create a new vault and perform operations
cargo run --bin cli --features "cli bincode"

Github : https://github.com/raminfp/trait-driven-rust-architecture

Learning Resources

Essential Reading

The Rust Book - Start here for Rust fundamentals
- Rust by Example - Hands-on examples
- Effective Rust - Best practices and idioms

Advanced Topics

Rust Design Patterns - Common patterns in Rust
- The Rustonomicon - Advanced unsafe Rust concepts
- Async Rust - Asynchronous programming

Design of a Push Notification Service

Ramin Farajpour Cami — Sun, 20 Jul 2025 06:25:37 +0000

A comprehensive system design for handling 1 billion notifications per day

System Requirements
Capacity Estimation
API Design
Database Design
High-Level Architecture
Component Design
Trade-offs & Technology Choices
Failure Scenarios & Mitigation
Future Improvements

System Requirements

Functional Requirements

Message Targeting: Ability to target messages based on user attributes, device, and other relevant criteria
Delivery Scheduling: System should manage delivery times, potentially scheduling notifications for optimal impact
Personalization: Notifications should be customizable for individual user preferences and characteristics
Localization: The system must support multiple languages and regional settings
User Engagement Tracking: Capability to track how users interact with notifications to facilitate continuous improvement
Performance Monitoring: Tools to monitor the speed and reliability of notification delivery
Prioritization: Capability to prioritize notifications, such as prioritizing OTPs over promotional messages

Non-Functional Requirements

Scalability: Handle high volume of notifications and users, scaling dynamically as demand increases
Reliability: High availability and fault tolerance to ensure continuous operation
Performance: Fast response times for incoming notification requests and timely delivery
Security: Secure handling and storage of user data and notification content
Maintainability: Ease of updating the system and integrating with other services

Capacity Estimation

Metric	Value	Notes
Daily Notifications	1 billion	Target volume
Notifications per Second	~11,574	Assuming constant traffic
Active Users	100 million	Concurrent connection handling required
Average Notification Size	500 bytes	Including headers and payload
Data Throughput	5.79 MB/s	Sustained data transfer rate
Storage Requirements	Scalable	For user preferences, engagement tracking, and logs

API Design

1. Send Notification

POST /notifications/send

Request:

{
  "user_id": "12345",
  "message": "Your OTP is 6789",
  "priority": "high",
  "language": "en",
  "device_id": "device123"
}

Response:

{
  "status": "success",
  "notification_id": "abc123",
  "message": "Notification sent successfully."
}

2. Update User Preferences

POST /users/{user_id}/preferences/update

Request:

{
  "preferences": {
    "language": "es",
    "marketing_notifications": false
  }
}

Response:

{
  "status": "success",
  "message": "Preferences updated successfully."
}

3. Fetch Notification Status

GET /notifications/{notification_id}/status

Response:

{
  "notification_id": "abc123",
  "status": "delivered",
  "delivered_at": "2023-04-14T12:00:00Z"
}

4. Track User Engagement

POST /engagements/track

Request:

{
  "notification_id": "abc123",
  "user_id": "12345",
  "action": "clicked"
}

Response:

{
  "status": "success",
  "message": "Engagement recorded successfully."
}

Database Design

Entity-Relationship Diagram

Database Strategy

Hybrid Approach:

PostgreSQL for USER and NOTIFICATION data (strong consistency, ACID properties)
Apache Cassandra for ENGAGEMENT data (high write throughput, scalability)

Key Design Decisions

USER table stores preferences and profile information with referential integrity
NOTIFICATION table maintains delivery status and metadata for audit trails
ENGAGEMENT table captures all user interactions for analytics and optimization
Partitioning strategy based on user_id for horizontal scalability

High-Level Architecture

Request Flow Sequence

Component Design

1. Message Queue (Apache Kafka)

Key Features:

Distributed Architecture: Horizontal scaling with multiple brokers
Priority Queuing: Separate topics for different priority levels
Partitioning Strategy: By user_id hash for load distribution
Durability: Configurable replication factor for fault tolerance

2. Delivery Service

Implementation Details:

Circuit Breaker Pattern: Prevent cascade failures
Exponential Backoff: delay = base_delay * (2^attempt) + jitter
Batch Processing: Group notifications for efficiency
Platform-Specific Handling: Dedicated services for iOS, Android, Web

3. Tracking Service

Analytics Capabilities:

Real-time Processing: Apache Flink for stream processing
Sliding Window Analysis: 1min, 5min, 1hour, 1day windows
Metrics Tracked: Click-through rates, conversion rates, engagement scores
Pattern Detection: Anomaly detection for unusual engagement patterns

Trade-offs & Technology Choices

Message Queue: Apache Kafka vs RabbitMQ

Aspect	Apache Kafka	RabbitMQ
Throughput	✅ Very High (1M+ msgs/sec)	⚠️ Moderate (100K msgs/sec)
Durability	✅ Excellent (persistent logs)	✅ Good (persistent queues)
Complexity	⚠️ High operational overhead	✅ Lower complexity
Ordering	✅ Per-partition ordering	⚠️ Limited ordering guarantees
Scalability	✅ Horizontal scaling	⚠️ Vertical scaling preferred

Choice: Kafka - Better suited for high-throughput, distributed environments

Database Strategy: Hybrid Approach

Data Type	Database	Rationale
User Data	PostgreSQL	ACID properties, complex queries, referential integrity
Notifications	PostgreSQL	Transaction support, status consistency
Engagement	Cassandra	High write throughput, eventual consistency acceptable

Microservices Architecture

Advantages:

Independent scaling of delivery services per platform
Technology diversity (different languages/frameworks)
Fault isolation and resilience

Challenges:

Increased operational complexity
Network latency between services
Distributed transaction challenges

Failure Scenarios & Mitigation

1. Message Queue Overload

Scenario: Queue becomes overwhelmed during traffic spikes

Mitigation Strategies:

Rate Limiting: Token bucket algorithm at API Gateway
Auto-scaling: Kubernetes HPA based on queue depth
Circuit Breaker: Fail fast when queue is full
Backpressure: Gradual throttling of incoming requests

2. Database Bottlenecks

Scenario: High read/write operations cause latency

Mitigation Strategies:

Read Replicas: Route read queries to replicas
Database Sharding: Partition by user_id
Redis Caching: Cache frequently accessed data
Connection Pooling: PgBouncer for PostgreSQL

3. External Service Failures

Scenario: APNS/FCM services are down or rate-limiting

Mitigation Strategies:

Exponential Backoff: Progressive retry delays
Dead Letter Queue: Store failed messages for later processing
Alternative Providers: Fallback to secondary providers
Circuit Breaker: Stop calling failing services temporarily

Future Improvements

1. Machine Learning Integration

Adaptive Delivery Timing:

Analyze user behavior patterns to determine optimal send times
Personalize delivery schedules based on engagement history
A/B testing framework for notification strategies

Implementation:

# Pseudocode for ML-based timing
def predict_optimal_time(user_id):
    user_features = get_user_engagement_history(user_id)
    timezone_offset = get_user_timezone(user_id)
    model_prediction = ml_model.predict(user_features)
    return adjust_for_timezone(model_prediction, timezone_offset)

2. Advanced Personalization

Content Personalization:

Dynamic message content based on user preferences
Sentiment analysis for tone adjustment
Multi-variate testing for message optimization

3. Location-Based Services

Geofencing Integration:

Trigger notifications based on user location
Proximity-based promotional campaigns
Location-aware content delivery

4. Performance Enhancements

Edge Computing:

Deploy notification services at edge locations
Reduce latency for global users
Implement intelligent request routing

Real-time Analytics:

Stream processing for instant feedback
Live dashboards for notification performance
Automated alerting for system anomalies

Monitoring & Observability

Key Metrics

Category	Metrics	Target SLA
Throughput	Messages/second	> 15,000/sec
Latency	End-to-end delivery time	< 5 seconds
Reliability	Delivery success rate	> 99.9%
Engagement	Click-through rate	Monitor trends
System Health	Error rate	< 0.1%

Alerting Strategy

This push notification service design provides a robust, scalable foundation for handling billions of notifications while maintaining high performance, reliability, and user engagement. The architecture leverages modern distributed systems patterns and technologies to ensure the system can grow with increasing demands while providing rich analytics and personalization capabilities.

go fiber multi core

Ramin Farajpour Cami — Sun, 24 Nov 2024 05:11:13 +0000

Design a real-time data processing

Ramin Farajpour Cami — Thu, 03 Oct 2024 07:32:34 +0000

What is Real-Time Data Processing?

The real-time data processing refers to the ability to handle and analyze data as soon as it enters the system, allowing for immediate insights and actions. This approach is crucial in scenarios where timely decision-making is essential, such as fraud detection, stock trading, monitoring systems or anti viruses.

This system allows for immediate detection of potential fraud, real-time updates to user accounts, and quick access to transaction analytics, significantly improving both security and user experience in financial services.

Benefits:

Immediate insights for faster decision-making
Ability to detect and respond to events as they happen
Improved operational efficiency and customer experience
Capacity to handle high-volume, high-velocity data

Challenges:

Ensuring low latency across the entire pipeline
Handling data consistency and fault tolerance
Scaling the system to accommodate growing data volumes
Managing the complexity of distributed systems

Detailed Flow:

Functional Requirements and Associated Technologies:

Data Ingestion:
- Capability to ingest data from various sources like IoT devices, sensors, and log files in real time and all events.
- Tech Example: Apache Kafka for streaming data ingestion.
Stream Processing:
- Ability to process data streams in real time, enabling actions based on incoming data.
- Tech Example: Apache Flink for processing data streams with low latency.
Complex Event Processing (CEP):
- Support for detecting patterns or sequences of events to trigger action.
- Tech Example: FlinkCEP for implementing complex event detection.
Real-time Analytics:
- Capability to perform real-time analytics on incoming data, allowing users to visualize and make decisions instantly.
- Tech Example: Apache Druid for real-time data visualization and querying.
Data Storage:
- Efficient storage of incoming data for both real-time processing and historical analysis.
- Tech Example: Apache Cassandra or Amazon Kinesis Data Firehose for storing streams of data.
Fault Tolerance and Recovery:
- Ensure the system can handle failures gracefully and recover from them with minimal data loss.
- Tech Example: Kafka's replication features for fault tolerance.
Scalability:
- Ability to scale horizontally to handle increased loads without degradation in performance.
- Tech Example: Kubernetes to orchestrate scaling of various components in the system.
Monitoring and Alerting:
- Implement monitoring tools to alert operators about unusual traffic patterns or system performance.
- Tech Example: Prometheus and Grafana for monitoring and alert systems.
User Management System
- Implement handling user-specific data, which may include
  - User profiles (username, email, passwords)
  - User settings
  - User activity logs
- Tech Example: PostgreSQL

In this diagram:

Data Sources are the various inputs such as IoT devices or logs that feed data into the system.
Data Ingestion Mechanism could be something like Kafka that collects this data.
The Stream Processing Engine is responsible for processing the incoming data on the fly.
From this engine, Real-time Analytics takes place to generate insights.
Dashboard displays these insights for users.
Complex Event Processing allows for identifying patterns and triggering actions based on those patterns.

To manage users in a real-time data processing system, you typically need a database that can handle high availability, scalability, and quick read/write operations. Here are a few options that you might consider:

Relational Database:
- MySQL or PostgreSQL: Both are mature relational databases that can provide ACID transactions, which are important for user management. They are great for complex queries involving relationships, but may not scale as easily for extremely high write loads compared to NoSQL options.
NoSQL Database:
- MongoDB: A document-oriented NoSQL database that allows for flexible schema design and can easily scale horizontally. It's a great fit for managing user data, particularly when the data format is less rigid.
- Cassandra: If you have a large volume of user data with a need for high write availability and fault tolerance, Cassandra offers the ability to handle high write and read throughput.
Key-Value Store:
- Redis: An in-memory key-value store that can be used for storing user sessions, caching user data for quick access, or even managing real-time features like user notifications.
Graph Database:
- Neo4j: If user relationships matter significantly (e.g., social networking applications), a graph database can help manage and query relationships efficiently.

Here's an example decision process:

If you need strong consistency and relationships between users (like user authentication, roles, and permissions), a relational database such as PostgreSQL may be best.
If you're expecting a very high volume of user data with a focus on scalability and fast access, a NoSQL database like MongoDB or Cassandra might be preferable.

How do Kafka, Flink, and Druid work for example {"data": "1"} if this data is for user A and processed in the system ?

Let's take a closer look at how Apache Kafka, Apache Flink, and Apache Druid work together in a real-time data processing pipeline, using example of the data {"data": "1"} that is associated with user A.

Flow Overview:

Data Ingestion with Kafka: Kafka acts as the message broker that ingests data from various sources into streams.
Stream Processing with Flink: Flink processes the data streams in real-time and can perform complex operations or transformations.
Analytical Querying with Druid: Druid serves as the analytical data store to provide quick access to processed data for querying and visualization.

Detailed Process:

Apache Kafka (Data Ingestion)
- The data {"data": "1"} for user A is published to a Kafka topic, let's call it "user_data".
- Kafka stores this message in a distributed, fault-tolerant manner.
- The message is now available for consumption by downstream systems like Flink.
Apache Flink (Stream Processing)
- Flink sets up a consumer to read from the Kafka "user_data" topic.
- As new messages arrive, Flink processes them in real-time.
- Flink could perform various operations, such as:
  - Enriching the data (e.g., adding a timestamp)
  - Filtering or transforming the data
  - Aggregating data over time windows
- For example, Flink might transform the data to: {"user": "A", "data": 1, "timestamp": 1633036800}
Apache Druid (Analytics and Querying)
- The processed data from Flink is ingested into Druid.
- Druid stores this data in a columnar format optimized for fast analytical queries.
- Users can now perform real-time queries on this data, such as:
  - Count of events for user A
  - Average of 'data' values for user A over the last hour
- Druid provides a SQL-like interface for querying this data efficiently.

Example Query Flow:

Data enters Kafka: {"data": "1"}
Flink processes and enriches: {"user": "A", "data": 1, "timestamp": 1633036800}
Data is stored in Druid
A user runs a query: "What's the sum of 'data' for user A in the last 24 hours?"
Druid quickly computes and returns the result

This pipeline allows for real-time data processing and analytics, enabling quick insights from large volumes of streaming data.

Step-by-step Interaction:

Publishing Data to Kafka:
- The system publishes the data {"data": "1", "user_id": "A"} to a Kafka topic, which could be called user-data-topic.
- The message will include all pertinent information, such as the user's ID and the data value.
Stream Processing with Flink:
- Flink consumes the messages from the Kafka topic user-data-topic.
- Flink processes the data, which could include filtering for specific user IDs, aggregating data, or performing transformations.
- For example, Flink might transform the incoming JSON object, store it in a specific format, or calculate metrics.
- If the processing logic facilitates event detection, it could trigger alerts or further actions based on certain conditions.
Storing Processed Data in Druid:
- Flink can then write or stream the processed data to Druid, which acts as a time-series data store optimized for real-time analytics.
- Druid is particularly good at handling large datasets with fast query capabilities, allowing users to visualize and query this information quickly.
- For instance, Druid could store the results of an aggregation like the number of occurrences of data type "1" for each user.

In a well-designed real-time data processing system, user data should be isolated so that user B cannot access the data associated with user A. This data isolation ensures privacy and security for each user. Here's how this can be enforced throughout the pipeline involving Kafka, Flink, and Druid:

Data Privacy in Kafka:
- Topic Segregation: If the application requires strong privacy, consider creating separate Kafka topics based on user groups or roles. However, in most cases, data for all users can be maintained in a single topic, while access control is enforced at the processing level.
Access Control in Flink:
- Data Filtering: When Flink processes messages from Kafka, it can implement filtering logic to ensure that operations are only applied to data associated with a specific user. For example, any aggregation or transformation performed will be scoped to the user making the request.
- Contextual Processing: Ensure that Flink jobs include a user context in their processing so they can differentiate which user's data is being worked on during transformation or calculation.
Security in Druid:
- Row-Level Security: Druid can implement row-level security, which allows it to control access to specific data records based on user permissions. User A's data will only be accessible to User A or roles that are authorized for that data.
- Access Control Lists (ACLs): Druid can use ACLs to manage which users have permissions to query certain datasets, ensuring isolated data access.

Example of User Data Isolation:

To illustrate, consider the following scenario:

User A inputs data {"data": "1", "user_id": "A"}, and User B inputs {"data": "2", "user_id": "B"}.

When the data is sent to Kafka, both messages are placed in the same topic.
Flink processes them, applying logic that ensures computations or manipulations are based only on user_id: "A" for User A's requests and user_id: "B" for User B's requests.
When data is queried or visualized in Druid, the access is controlled to guarantee User A only sees results pertaining to their own activities and not User B's.

Complex Event Processing (CEP)

CEP is a powerful capability within real-time data processing systems that allows for the analysis of events as they occur and the identification of meaningful patterns or sequences of events.

Step-by-Step Process:

Event Generation:

Each transaction by users (e.g., transfers, purchases) is recorded and sent as an event to the CEP engine:

{
  "event_type": "transaction", 
  "user_id": "A", 
  "amount": 500, 
  "timestamp": "2023-10-01T12:00:00Z"
}

Pattern Definition:

Define patterns in the CEP system, such as:
"Trigger alert if a user makes more than three transactions exceeding $500 within a 5-minute window."

Event Processing:

The CEP engine listens for incoming transaction events and analyzes them against the defined patterns.

Action Triggering:

If a user meets the defined conditions for suspicious activity (e.g., three transactions over $500 in quick succession), the CEP triggers the following actions:

Alert Notification: Send an alert to the monitoring team for further investigation.
Block Transaction: Automatically flag or block subsequent transactions for that user until manual review.

Conclusion

Real-time data processing has become an indispensable tool in today's fast-paced, data-driven world. By enabling organizations to ingest, process, and analyze data as it's generated, these systems provide immediate insights that drive quick decision-making and action. We've explored the key components of such systems, including data ingestion with Kafka, stream processing with Flink, and analytics with Druid, as well as the critical role of Complex Event Processing in detecting patterns and triggering actions.

How to write your building tools for multiple applications with cargo

Ramin Farajpour Cami — Thu, 11 Jan 2024 06:28:10 +0000

How to write your building tools for multiple applications with cargo [cargo-floki]

(You can have multiple outputs of multiple applications at the same time by executing a command.)

Building a tool for managing the build process of multiple applications can be quite complex,
and writing build tools in Rust involves creating a program that automates various tasks related to building,
testing, and packaging your Rust projects.

How to install cargo-floki :

$ cargo install --path .

Usage:

$  cargo floki --help
Usage: cargo-floki [OPTIONS] <COMMAND>

Commands:
  init    Adds a default floki.toml file to current directory
  build   Compile the client and server
  clean   Remove the target directories (in app, client and server)
  test    Run the cargo tests for app, client and server
  update  Run the cargo update for app, client and server
  run     Run app
  doc     Docs
  help    Print this message or the help of the given subcommand(s)

Options:
  -r, --release          Build artifacts in release mode, with optimizations
  -v, --verbose...       Verbosity (none: errors & warnings, -v: verbose, --vv: very verbose, --vvv: output everything)
  -c, --config <CONFIG>  Path to configuration file (defaults to './floki.toml')
  -h, --help             Print help

Below is a basic outline of how you might approach building such a tool:

Project Structure:

Create a standardized project structure to ensure consistency across different applications. This can simplify the build process by having a predictable layout.

We have 2 project for my example app and client:

$ tree
.
├── app (Project 1)
│   ├── Cargo.toml
│   └── src
│       └── lib.rs  
└── client (Project 2)
    ├── Cargo.toml
    └── src
        └── main.rs

Configuration:

Allow for configuration options so users can customize the build process for their specific needs.
Consider using configuration files, environment variables, or a configuration management system.

I define project path app and client and generate floki.toml :

$ cargo floki init
$ cat floki.toml 
[floki]
main_service = "floki_projects/app"
client_service = "floki_projects/client"

Logging and Reporting:

Implement logging and reporting features to provide detailed feedback during the build process. This helps developers identify and fix issues more efficiently.

$ cargo floki -v build

Testing:

Implement testing for your build tool itself to ensure reliability and stability.

I write a test for app project:

$ cargo test
    Finished test [unoptimized + debuginfo] target(s) in 0.02s
     Running unittests src/main.rs (cargo-floki/target/debug/deps/client-5bd14cdeb41d4264)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

$ cargo test
    Finished test [unoptimized + debuginfo] target(s) in 0.01s
     Running unittests src/lib.rs (cargo-floki/target/debug/deps/app-f55b4b7fb682729e)

running 1 test
test tests::test_add ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests app

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Documentation:

Provide comprehensive documentation to help users understand how to configure and use the build tool effectively.

Generate documentation for all projects:

$ cargo floki doc

Continuous Integration (CI) Integration:

Ensure compatibility with popular CI/CD systems like Jenkins, Travis CI, GitLab CI, or GitHub Actions. This facilitates automated builds and deployments.

Build all projects that cleans, build, testing the project directory.

$ cargo floki build
$ cargo floki -r build
$ cargo floki clean
$ cargo floki update

All these steps are for ease of work and speed of application development.

Github code : https://github.com/raminfp/cargo-floki

How to rust binding for libFuzzer

Ramin Farajpour Cami — Fri, 03 Nov 2023 08:15:13 +0000

How to Rust bindings for libFuzzer

You can use the Rust fuzz ecosystem, which provides a convenient way to integrate fuzz testing into your Rust projects

Here's a step-by-step guide on how to create Rust bindings for libFuzzer:

What is `libfuzzer`?

libFuzzer is a highly efficient coverage-guided fuzz testing tool that is part of the LLVM (Low-Level Virtual Machine) project. Fuzz testing, or fuzzing, is a software testing technique in which a program is subjected to a large volume of random, invalid, or unexpected input data to discover vulnerabilities, crashes, or other issues.

Download `libfuzzer` C++ source code :

https://github.com/llvm/llvm-project/tree/main/compiler-rt/lib/fuzzer

Rust version

[17:40] raminfp@zenbook: $ rustc -vV
rustc 1.75.0-nightly (75b064d26 2023-11-01)
binary: rustc
commit-hash: 75b064d26970ca8e7a487072f51835ebb057d575
commit-date: 2023-11-01
host: x86_64-unknown-linux-gnu
release: 1.75.0-nightly
LLVM version: 17.0.4

Building for libfuzzer c++ code in the `build.rs`

        let mut build = cc::Build::new();
        let sources = ::std::fs::read_dir("libfuzzer")
            .expect("listable source directory")
            .map(|de| de.expect("file in directory").path())
            .filter(|p| p.extension().map(|ext| ext == "cpp") == Some(true))
            .collect::<Vec<_>>();
        for source in sources.iter() {
            build.file(source.to_str().unwrap());
        }
        build.flag("-std=c++11");
        build.flag("-fno-omit-frame-pointer");
        build.flag("-w");
        build.cpp(true);
        build.compile("libfuzzer.a");

Add wrapper function `LLVMFuzzerTestOneInput` This wrapper function is designed to call a Rust function `rust_fuzzer_test_input` with input data obtained from the fuzzer.

use std::slice::from_raw_parts;

extern "C" {
    fn rust_fuzzer_test_input(data: *const u8, len: usize);
}

#[no_mangle]
pub extern "C" fn LLVMFuzzerTestOneInput(data: *const u8, size: usize) -> i32 {

    let _ = unsafe { from_raw_parts(data, size) };

    unsafe {
        rust_fuzzer_test_input(data, size);
    }
    0
}

Now starting fuzzing your libs with libfuzzer in rust.

$ cargo new --bin example
$ cd example

Then add a dependency on the fuzzer

[dependencies]
myfuzzer = { path = ".." }
your_crate_libs = "*"

And change code in your case ex: `src/main.rs` to fuzz my code:

#![no_main]
extern crate myfuzzer;

#[export_name="rust_fuzzer_test_input"]
pub fn fuzz(data: &[u8]) {
    // your fuzz code here
    // println!("{:?}", data);
    if data == b"A" {
        panic!("Oops!");
    }
}

Finally, run the following commands:

$ [04:09] raminfp@zenbook:example (main) # pwd
/home/raminfp/Projects/Develop/libfuzzer/example
$ [03:18] raminfp@zenbook:example # cargo rustc -- \
    -C passes='sancov-module' \
    -C llvm-args='-sanitizer-coverage-level=3' \
    -C llvm-args='-sanitizer-coverage-inline-8bit-counters' \
    -Z sanitizer=address
$ ./target/debug/example

Output:

[03:55] raminfp@zenbook:example # ./target/debug/example
INFO: Seed: 1157038402
INFO: Loaded 1 modules   (239 inline 8-bit counters): 239 [0x5556c7f79a80, 0x5556c7f79b6f), 
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
INFO: A corpus is not provided, starting from an empty corpus
#2  INITED ft: 15 corp: 1/1b exec/s: 0 rss: 36Mb
#5  NEW    ft: 17 corp: 2/66b exec/s: 0 rss: 36Mb L: 65/65 MS: 3 CopyPart-CopyPart-InsertRepeatedBytes-
#58 REDUCE ft: 17 corp: 2/44b exec/s: 0 rss: 36Mb L: 43/43 MS: 3 InsertByte-InsertRepeatedBytes-EraseBytes-
#72 REDUCE ft: 17 corp: 2/25b exec/s: 0 rss: 36Mb L: 24/24 MS: 4 InsertByte-InsertByte-ChangeByte-EraseBytes-
#78 REDUCE ft: 17 corp: 2/24b exec/s: 0 rss: 36Mb L: 23/23 MS: 1 EraseBytes-
#80 REDUCE ft: 17 corp: 2/15b exec/s: 0 rss: 36Mb L: 14/14 MS: 2 CopyPart-EraseBytes-
#81 REDUCE ft: 17 corp: 2/14b exec/s: 0 rss: 36Mb L: 13/13 MS: 1 EraseBytes-
#133    REDUCE ft: 17 corp: 2/11b exec/s: 0 rss: 36Mb L: 10/10 MS: 2 ChangeBit-EraseBytes-
#171    REDUCE ft: 17 corp: 2/8b exec/s: 0 rss: 36Mb L: 7/7 MS: 3 ChangeBinInt-ChangeBit-EraseBytes-
#182    REDUCE ft: 17 corp: 2/6b exec/s: 0 rss: 36Mb L: 5/5 MS: 1 EraseBytes-
#184    REDUCE ft: 17 corp: 2/5b exec/s: 0 rss: 36Mb L: 4/4 MS: 2 InsertByte-EraseBytes-
#196    REDUCE ft: 17 corp: 2/3b exec/s: 0 rss: 36Mb L: 2/2 MS: 2 ChangeByte-EraseBytes-
thread '<unnamed>' panicked at src/main.rs:9:9:
Oops!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
==44905== ERROR: libFuzzer: deadly signal
    #0 0x5556c7e6eaf1 in __sanitizer_print_stack_trace /rustc/llvm/src/llvm-project/compiler-rt/lib/asan/asan_stack.cpp:87:3
    #1 0x5556c7eac540 in fuzzer::Fuzzer::CrashCallback() /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:233:38
    #2 0x5556c7eac3c6 in fuzzer::Fuzzer::StaticCrashSignalCallback() /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:206:19
    #3 0x5556c7edb561 in fuzzer::CrashHandler(int, siginfo_t*, void*) /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerUtilPosix.cpp:36:36
    #4 0x7efed284251f  (/lib/x86_64-linux-gnu/libc.so.6+0x4251f) (BuildId: a43bfc8428df6623cd498c9c0caeb91aec9be4f9)
    #5 0x7efed28969fb in __pthread_kill_implementation nptl/./nptl/pthread_kill.c:43:17
    #6 0x7efed28969fb in __pthread_kill_internal nptl/./nptl/pthread_kill.c:78:10
    #7 0x7efed28969fb in pthread_kill nptl/./nptl/pthread_kill.c:89:10
    #8 0x7efed2842475 in gsignal signal/../sysdeps/posix/raise.c:26:13
    #9 0x7efed28287f2 in abort stdlib/./stdlib/abort.c:79:7
    #10 0x5556c7ef8226 in std::sys::unix::abort_internal::haadb6d01b1ce5dcc /rustc/75b064d26970ca8e7a487072f51835ebb057d575/library/std/src/sys/unix/mod.rs:376:14
    #11 0x5556c7ddf7a6 in std::process::abort::hb7281d0b80ebbd50 /rustc/75b064d26970ca8e7a487072f51835ebb057d575/library/std/src/process.rs:2279:5
    #12 0x5556c7e945c5 in myfuzzer::test_input_wrap::_$u7b$$u7b$closure$u7d$$u7d$::h2f53ba4c17f7bd40 /home/raminfp/Projects/Develop/libfuzzer-rs/src/lib.rs:19:22
    #13 0x5556c7e94495 in core::option::Option$LT$T$GT$::map::h90a0dc092a0a2b55 /rustc/75b064d26970ca8e7a487072f51835ebb057d575/library/core/src/option.rs:1066:29
    #14 0x5556c7e94419 in LLVMFuzzerTestOneInput /home/raminfp/Projects/Develop/libfuzzer-rs/src/lib.rs:16:5
    #15 0x5556c7eadc73 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:515:15
    #16 0x5556c7ead6d1 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:440:18
    #17 0x5556c7eae727 in fuzzer::Fuzzer::MutateAndTestOne() /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:648:25
    #18 0x5556c7eaf3ae in fuzzer::Fuzzer::Loop(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, fuzzer::fuzzer_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&) /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerLoop.cpp:775:21
    #19 0x5556c7e9b3ac in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerDriver.cpp:754:10
    #20 0x5556c7e94962 in main /home/raminfp/Projects/Develop/libfuzzer-rs/libfuzzer/FuzzerMain.cpp:20:30
    #21 0x7efed2829d8f in __libc_start_call_main csu/../sysdeps/nptl/libc_start_call_main.h:58:16
    #22 0x7efed2829e3f in __libc_start_main csu/../csu/libc-start.c:392:3
    #23 0x5556c7de07f4 in _start (/home/raminfp/Projects/Develop/libfuzzer-rs/example/target/debug/example+0x127f4) (BuildId: 12917cdb5ef03b01c21eb307af3c31bd5867b94e)

NOTE: libFuzzer has rudimentary signal handlers.
      Combine libFuzzer with AddressSanitizer or similar for better crash reports.
SUMMARY: libFuzzer: deadly signal
MS: 1 ChangeByte-; base unit: adc83b19e793491b1c6ea0fd8b46cd9f32e592fc
0x41,
A
artifact_prefix='./'; Test unit written to ./crash-6dcd4ce23d88e2ee9568ba546c007c63d9131c1b
Base64: QQ==

Crash file:


[03:20] raminfp@zenbook:example # exa
Cargo.lock  Cargo.toml  crash-6dcd4ce23d88e2ee9568ba546c007c63d9131c1b  src  target


[03:20] raminfp@zenbook:example # hexdump crash-6dcd4ce23d88e2ee9568ba546c007c63d9131c1b
0000000 0041                                   
0000001

Thanks,

Source code : https://github.com/raminfp/libfuzzer-rs

Task scheduler interval in the rust

Ramin Farajpour Cami — Tue, 17 Oct 2023 09:52:38 +0000

Tasks Schedule

Task scheduler in code that runs a function at specific intervals,

Example

use task_schedule::{schedule_tasks, ScheduledTask};
use task_schedule::utils::*;

fn task_without_params() {
    println!("I am running sec task.");
}

fn task_min() {
    println!("I am running min task.");
}

fn task_hours() {
    println!("I am running hours task.");
}

fn task_days() {
    println!("I am running days task.");
}

fn task_week() {
    println!("I am running week task.");
}

fn task_with_params(a: i32, b: &str) {
    println!("Task with parameters: a = {}, b = {}", a, b);
}

fn task_with_params_wrapper() {
    task_with_params(42, "Hello");
}


fn main() {
    let mut tasks = vec![
        ScheduledTask::new(convert_duration_to_seconds(1), task_without_params as fn()),
        ScheduledTask::new(convert_duration_to_seconds(2), task_with_params_wrapper as fn()),
        ScheduledTask::new(convert_duration_to_minutes(1), task_min as fn()),
        ScheduledTask::new(convert_duration_to_hours(1), task_hours as fn()),
        ScheduledTask::new(convert_duration_to_days(1), task_days as fn()),
        ScheduledTask::new(convert_duration_to_weeks(1), task_week as fn()),
    ];

    schedule_tasks(&mut tasks);
}

Output

I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.
Task with parameters: a = 42, b = Hello
I am running sec task.
I am running sec task.

Github : https://github.com/raminfp/schedule-tasks

A small library for writing line-oriented command interpreters in the Rust

Ramin Farajpour Cami — Sat, 14 Oct 2023 13:19:24 +0000

cli-rs

What is line-oriented command interpreters?

A line-oriented command interpreter, also known as a command-line interpreter or shell, is a software program or interface that allows users to interact with a computer or operating system by entering text-based commands. Users type commands and arguments in a sequential, line-by-line manner, and the interpreter processes these commands and carries out the requested operations.

Example

use std::cell::RefCell;
use std::rc::Rc;
use cli_rs::cli::cmd::CommandHandler;
use cli_rs::cli::cmd::Cmd;
use cli_rs::about;
use cli_rs::hello;

struct QuitCommand;
struct HelpCommand;

impl CommandHandler for HelpCommand {
    fn execute(&self, _cmd: Rc<RefCell<Cmd>>, _args: String) {
        println!("Help");
    }
}

impl CommandHandler for QuitCommand {
    fn execute(&self, _cmd: Rc<RefCell<Cmd>>, _args: String) {
        std::process::exit(0);
    }
}

fn main() {
    let mut cmd = Cmd::new();
    cmd.intro = Some("Welcome to Rust command interpreter!".to_string());

    cmd.add_command("hello", Rc::new(hello::HelloCommand));
    cmd.add_command("quit", Rc::new(QuitCommand));
    cmd.add_command("help", Rc::new(HelpCommand));
    cmd.add_command("about", Rc::new(about::AboutCommand));

    cmd.cmdloop();
}

Output

# cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/cmd-rs`
Welcome to Rust command interpreter!
[cli-rs] help
Help
[cli-rs] hello world! 
Hello world!
[cli-rs] about
About me
[cli-rs] quit

Code :

https://github.com/raminfp/cli-rs

Symbolic Execution Fuzzing With KLEE

Ramin Farajpour Cami — Tue, 10 Oct 2023 12:23:16 +0000

What is Symbolic Execution?

symbolic execution is a means of analyzing a program to determine what inputs cause each part of a program to execute.
An interpreter follows the program, assuming symbolic values for inputs rather than obtaining actual inputs as normal execution of the program would.

KLEE Symbolic Execution Engine

KLEE is a dynamic symbolic execution engine built on top of the LLVM compiler infrastructure

How to install KLEE with Docker

$ git clone https://github.com/klee/klee.git
$ cd klee
$ docker build -t klee/klee .
$ docker run --rm -ti --ulimit='stack=-1:-1' klee/klee

Let's me start fuzzing OSS(Open Source Software)

1- Download source code

$ git clone https://github.com/kokke/tiny-bignum-c

2- Add main to code bn.c

From 174727a8d41cf1276849e5d4524f8cd4c4955afd Mon Sep 17 00:00:00 2001
From: raminfp <ramin.blackhat@gmail.com>
Date: Sun, 18 Jul 2021 03:04:40 +0000
Subject: [PATCH] Change code for fuzzing KLEE

---
 bn.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/bn.c b/bn.c
index 6526ea7..f71474d 100644
--- a/bn.c
+++ b/bn.c
@@ -663,3 +663,45 @@ static void _rshift_one_bit(struct bn* a)
 }


+void factorial(struct bn* n, struct bn* res)
+{
+  struct bn tmp;
+
+  /* Copy n -> tmp */
+  bignum_assign(&tmp, n);
+
+  /* Decrement n by one */
+  bignum_dec(n);
+  
+  /* Begin summing products: */
+  while (!bignum_is_zero(n))
+  {
+    /* res = tmp * n */
+    bignum_mul(&tmp, n, res);
+
+    /* n -= 1 */
+    bignum_dec(n);
+    
+    /* tmp = res */
+    bignum_assign(&tmp, res);
+  }
+
+  /* res = tmp */
+  bignum_assign(res, &tmp);
+}
+
+int main()
+{
+  struct bn num;
+  struct bn result;
+  char buf[8192];
+
+  klee_make_symbolic(buf, sizeof(buf), "buf");
+  klee_assume(buf[sizeof(buf) - 1] == 0);
+  bignum_from_int(&num, 100);
+  factorial(&num, &result);
+  bignum_to_string(&result, buf, sizeof(buf));
+
+  return 0;
+}
+
-- 
2.17.1

3- Compile with Clang

$ clang -emit-llvm -O0 -c -g bn.c
$ llvm-dis ./bn.bc
$ vim bn.ll
$ klee bn.bc

4- Crashed.

5- Details

klee@500746a23210:~/tiny-bignum-c$ cat klee-out-0/test000001.ptr.err
Error: memory error: out of bound pointer
File: bn.c
Line: 157
assembly.ll line: 521
State: 2
Stack: 
        #000000521 in bignum_to_string (n=93858042189952, str=93858042462208, nbytes=8192) at bn.c:157
        #100002836 in main () at bn.c:703
Info: 
        address: 93858042470400
        next: object at 22510123060032 of size 1536
                MO40[1536] (no allocation info)

Fuzzer Development With Rust

Ramin Farajpour Cami — Tue, 12 Sep 2023 12:12:19 +0000

Fuzzer Development With Rust (Basic)

Each researcher needs to be able to develop their own fuzzing tools. For this reason, I have started teaching how to develop fuzzing tools from scratch in this project so that researchers can use their own fuzzer to discover security vulnerabilities of open source tools, libraries and code that companies develop internally.

In this training, we have explained all the concepts along with examples in the rust programming language so that the desired concepts can be understood correctly.

Chapter 1. Corpus

Chapter 2. Mutation

Chapter 3. Monitor

Chapter 4. Coverage

Chapter 5. Executor

Github

Thanks.
Ramin

How to fuzz java code with jazzer?

Ramin Farajpour Cami — Fri, 22 Jul 2022 17:09:00 +0000

What is fuzzing?

Modern fuzzing solutions analyze the structure of the code they are testing and generate thousands of automated test cases per second. The process is designed to reach as many new program states as possible with the generated inputs . In addition, the fuzzer also marks the individual paths followed by these inputs and thus receives detailed feedback on the test coverage achieved when executing the source code. In this way, fuzzers learn more about the structure of the expected input with each iteration.

Type Of Fuzzing

1- Dumb Fuzzer
2- Generation Fuzzer
3- Coverage Guided Fuzzer

What is `Dumb Fuzzer` ?

Dumb fuzzer works without having any knowledge about the data attempts to random input, also no understanding of file format/network protocol is required. also can take lot of time (depending up on your luck).

Ex Radmasa

What is `Generation Fuzzer`?

In contrast to Dumb Fuzzers, here an understanding of the file format / protocol is very important. It’s about “generating” the inputs from the scratch based on the specification/format.

Ex ( Peach, Sulley )

What is `Coverage Guided Fuzzer`?

Coverage guided fuzzing uses program instrumentation to trace the code coverage and monitors program flow by using instrumentation. no knowledge of the file format is required and It modifies the file using its own algorithms and check for new code path coverage/crash.

Ex ( AFL, WinAFL, HonggFuzz, LibFuzzer, Jazzer )

What is `Jazzer`?

Today, we will dive into the Java world and check out the most popular Java fuzzing solution, Jazzer is used to automatically generate malicious inputs for Java programs.

Tools setup :

We will now go through the process of installing Jazzer so you can easily follow along on my VM machine (Ubuntu 20.04).

Jazzer has the following dependencies when being built from source:

1- Install Bazel 4 or later
2- Install JDK 8 or later (e.g. OpenJDK)
3- Install Clang and LLD 9.0 or later

Compilation :

$ git clone https://github.com/CodeIntelligenceTesting/jazzer
$ cd jazzer
$ ./bazelisk-linux-amd64 run //:jazzer                                                                                                                                                                                               
Starting local Bazel server and connecting to it...
INFO: Analyzed target //:jazzer (79 packages loaded, 1410 targets configured).
INFO: Found 1 target...
Target //:jazzer up-to-date:
  bazel-bin/jazzer
INFO: Elapsed time: 43.920s, Critical Path: 7.21s
INFO: 83 processes: 4 internal, 79 linux-sandbox.
INFO: Build completed successfully, 83 total actions
INFO: Build completed successfully, 83 total actions
driver/jazzer_driver: error while loading shared libraries: libjvm.so: cannot open shared object file: No such file or directory

We have a error
libjvm.so: cannot open shared object file: No such file or directory
If you have this error for solution we should define LD_LIBRARY_PATH

$ wget https://enos.itcollege.ee/~jpoial/allalaadimised/jdk15/jdk-15.0.2_linux-x64_bin.tar.gz

$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/ubuntu/jdk-15.0.2/lib/server/

$ ./bazelisk-linux-amd64 run //:jazzer  
INFO: Analyzed target //:jazzer (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //:jazzer up-to-date:
  bazel-bin/jazzer
INFO: Elapsed time: 0.205s, Critical Path: 0.00s
INFO: 1 process: 1 internal.
INFO: Build completed successfully, 1 total action
INFO: Build completed successfully, 1 total action
Java HotSpot(TM) 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
INFO: Loaded 8 hooks from com.code_intelligence.jazzer.sanitizers.Deserialization
INFO: Loaded 1 hooks from com.code_intelligence.jazzer.sanitizers.ReflectiveCall
Missing argument --target_class=<fuzz_target_class>

Choose your java lib or code for fuzzing (Ex : generex)

1- Add "com.github.mifmif:generex:1.0.2" lib to nano maven.bzl


load("@rules_jvm_external//:specs.bzl", "maven")

JAZZER_API_VERSION = "0.10.0"
JAZZER_API_COORDINATES = "com.code-intelligence:jazzer-api:%s" % JAZZER_API_VERSION

# **WARNING**: These Maven dependencies have known vulnerabilities and are only used to test that
#              Jazzer finds these issues. DO NOT USE.
MAVEN_ARTIFACTS = [
    "junit:junit:4.12",
    "org.apache.commons:commons-imaging:1.0-alpha2",
    "com.mikesamuel:json-sanitizer:1.2.1",
    "com.google.code.gson:gson:2.8.6",
    "com.fasterxml.jackson.core:jackson-core:2.12.1",
    "com.fasterxml.jackson.core:jackson-databind:2.12.1",
    "com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.12.1",
    "com.alibaba:fastjson:1.2.75",
    "com.beust:klaxon:5.5",
    "javax.validation:validation-api:2.0.1.Final",
    "javax.xml.bind:jaxb-api:2.3.1",
    "javax.el:javax.el-api:3.0.1-b06",
    "org.hibernate:hibernate-validator:5.2.4.Final",

    "com.github.mifmif:generex:1.0.2",

    maven.artifact("org.apache.logging.log4j", "log4j-api", "2.14.1", testonly = True),
    maven.artifact("org.apache.logging.log4j", "log4j-core", "2.14.1", testonly = True),

]

2- Editing $ nano examples/BUILD.bazel to this :

java_fuzz_target_test(
    name = "GenerexFuzzer",
    srcs = [
        "src/main/java/com/example/GenerexFuzzer.java",
    ],
    target_class = "com.example.GenerexFuzzer",
    deps = [
        "@maven//:com_github_mifmif_generex",
    ],
)

3- Create java file for fuzzing GenerexFuzzer.java

$ nano /home/jazzer/examples/src/main/java/com/example/GenerexFuzzer.java

Add my code for fuzzing by Jazzer

package com.example;

import com.code_intelligence.jazzer.api.FuzzedDataProvider;
import com.mifmif.common.regex.Generex;

// Found the issues.
public class GenerexFuzzer {
  public static void fuzzerTestOneInput(FuzzedDataProvider data) {
    try {
        Generex generex = new Generex(data.consumeRemainingAsString());
        generex.random();
    } catch (IllegalArgumentException ignored) {
        }
  }
}

4- Now starting for fuzzing :

$ ./bazelisk-linux-amd64 run //examples:GenerexFuzzer
INFO: Analyzed target //examples:GenerexFuzzer (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //examples:GenerexFuzzer up-to-date:
  bazel-bin/examples/GenerexFuzzer
INFO: Elapsed time: 0.121s, Critical Path: 0.00s
INFO: 1 process: 1 internal.
INFO: Build completed successfully, 1 total action
INFO: Build completed successfully, 1 total action
exec ${PAGER:-/usr/bin/less} "$0" || exit 1
Executing tests from //examples:GenerexFuzzer
-----------------------------------------------------------------------------
Java HotSpot(TM) 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
INFO: Loaded 8 hooks from com.code_intelligence.jazzer.sanitizers.Deserialization
INFO: Loaded 1 hooks from com.code_intelligence.jazzer.sanitizers.ReflectiveCall
INFO: Loaded 8649 no-throw method signatures
INFO: Instrumented com.example.GenerexFuzzer (took 42 ms, size +37%)
INFO: libFuzzer ignores flags that start with '--'
INFO: Running with entropic power schedule (0xFF, 100).
INFO: Seed: 2735196724
INFO: Loaded 1 modules   (512 inline 8-bit counters): 512 [0x7fcec02c9010, 0x7fcec02c9210), 
INFO: Loaded 1 PC tables (512 PCs): 512 [0x7fce8abfe010,0x7fce8ac00010), 
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
INFO: Instrumented com.mifmif.common.regex.Generex (took 16 ms, size +49%)
INFO: Instrumented com.mifmif.common.regex.util.Iterable (took 1 ms, size +0%)
INFO: Instrumented com.mifmif.common.regex.util.Iterator (took 0 ms, size +0%)
INFO: New number of inline 8-bit counters: 1024
INFO: Instrumented dk.brics.automaton.RegExp (took 17 ms, size +104%)
INFO: Instrumented dk.brics.automaton.RegExp$Kind (took 2 ms, size +42%)
INFO: Instrumented dk.brics.automaton.RegExp$1 (took 1 ms, size +102%)
INFO: Instrumented dk.brics.automaton.BasicAutomata (took 11 ms, size +130%)
INFO: New number of inline 8-bit counters: 2048
INFO: Instrumented dk.brics.automaton.Automaton (took 9 ms, size +82%)
INFO: Instrumented dk.brics.automaton.State (took 2 ms, size +55%)
INFO: Instrumented dk.brics.automaton.Transition (took 2 ms, size +74%)
INFO: Instrumented dk.brics.automaton.TransitionComparator (took 1 ms, size +97%)
INFO: A corpus is not provided, starting from an empty corpus
#2      INITED cov: 71 ft: 71 corp: 1/1b exec/s: 0 rss: 114Mb
#3      NEW    cov: 176 ft: 191 corp: 2/3b lim: 4 exec/s: 0 rss: 114Mb L: 2/2 MS: 1 CopyPart-
#5      NEW    cov: 178 ft: 286 corp: 3/6b lim: 4 exec/s: 0 rss: 114Mb L: 3/3 MS: 2 ChangeByte-InsertByte-
#10     NEW    cov: 178 ft: 378 corp: 4/10b lim: 4 exec/s: 0 rss: 114Mb L: 4/4 MS: 5 InsertByte-ChangeBit-ChangeBinInt-InsertByte-CopyPart-
#21     NEW    cov: 181 ft: 384 corp: 5/13b lim: 4 exec/s: 0 rss: 114Mb L: 3/4 MS: 1 ChangeBit-
#6375   NEW    cov: 975 ft: 4248 corp: 243/1071b lim: 8 exec/s: 6375 rss: 154Mb L: 7/8 MS: 1 CrossOver-
#6391   NEW    cov: 975 ft: 4250 corp: 244/1079b lim: 8 exec/s: 6391 rss: 154Mb L: 8/8 MS: 1 CopyPart-

== Java Exception: com.code_intelligence.jazzer.api.FuzzerSecurityIssueLow: Stack overflow (truncated to likely cause)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
Caused by: java.lang.StackOverflowError
        at java.base/java.util.TimSort.countRunAndMakeAscending(TimSort.java:355)
        at java.base/java.util.TimSort.sort(TimSort.java:220)
        at java.base/java.util.Arrays.sort(Arrays.java:1232)
        at dk.brics.automaton.State.getSortedTransitionArray(Unknown Source)
        at dk.brics.automaton.State.getSortedTransitions(Unknown Source)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:340)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)
        at com.mifmif.common.regex.Generex.prepareRandom(Generex.java:366)

LibFuzzer crashing input :

MS: 2 ChangeBit-CMP- DE: "\x00\x00\x00\x05"-; base unit: b5d43fd7e3064418d903c4d27d2238f390e23c62
0x7e,0x2f,0x7d,0x0,0x0,0x0,0x5,
~/}\x00\x00\x00\x05
artifact_prefix='/root/.cache/bazel/_bazel_root/c82b104c68f93e19e57160becd18f8f0/execroot/jazzer/bazel-out/k8-opt/testlogs/examples/GenerexFuzzer/test.outputs/'; Test unit written to /root/.cache/bazel/_bazel_root/c82b104c68f93e19e57160becd18f8f0/execroot/jazzer/bazel-out/k8-opt/testlogs/examples/GenerexFuzzer/test.outputs/crash-101076ac3391a62fb4622589093c2543063de037
Base64: fi99AAAABQ==

Congratulations! We found Stack overflow Vulnerability.

I hope enjoy,
Thanks, Ramin

DEV Community: Ramin Farajpour Cami

Trait-Driven Rust Architecture

Trait-Driven Rust Architecture

Key Features

Building and Running

Project Structure

Learning Concepts

1. Trait-based Design Pattern

2. Feature-gated Implementations

3. State Management with Enums

4. Structured Error Handling

Getting Started

Step 1: Clone and Build

Step 2: Run Tests

Step 3: Try the CLI

Learning Resources

Essential Reading

Advanced Topics

Design of a Push Notification Service

Table of Contents

System Requirements

Functional Requirements

Non-Functional Requirements

Capacity Estimation

API Design

1. Send Notification

2. Update User Preferences

3. Fetch Notification Status

4. Track User Engagement

Database Design

Entity-Relationship Diagram

Database Strategy

Key Design Decisions

High-Level Architecture

Request Flow Sequence

Component Design

1. Message Queue (Apache Kafka)

2. Delivery Service

3. Tracking Service

Trade-offs & Technology Choices

Message Queue: Apache Kafka vs RabbitMQ

Database Strategy: Hybrid Approach

Microservices Architecture

Failure Scenarios & Mitigation

1. Message Queue Overload

2. Database Bottlenecks

3. External Service Failures

Future Improvements

1. Machine Learning Integration

2. Advanced Personalization

3. Location-Based Services

4. Performance Enhancements

Monitoring & Observability

Key Metrics

Alerting Strategy

go fiber multi core

Design a real-time data processing

What is Real-Time Data Processing?

Benefits:

Challenges:

Detailed Flow:

Flow Overview:

Detailed Process:

Example Query Flow:

Step-by-step Interaction:

Example of User Data Isolation:

Complex Event Processing (CEP)

Step-by-Step Process:

Event Generation:

Pattern Definition:

Event Processing:

Action Triggering:

Conclusion

How to write your building tools for multiple applications with cargo

How to write your building tools for multiple applications with cargo [cargo-floki]

How to install cargo-floki :

Usage:

Project Structure:

Configuration:

Logging and Reporting:

What is `libfuzzer`?

Download `libfuzzer` C++ source code :

Building for libfuzzer c++ code in the `build.rs`

Add wrapper function `LLVMFuzzerTestOneInput` This wrapper function is designed to call a Rust function `rust_fuzzer_test_input` with input data obtained from the fuzzer.

And change code in your case ex: `src/main.rs` to fuzz my code:

What is `Dumb Fuzzer` ?

What is `Generation Fuzzer`?

What is `Coverage Guided Fuzzer`?

What is `Jazzer`?