I woke up to 200 new subscribers on the newsletter of my site videiro.com, had it finally happened? Did my site finally go viral?

Sadly no. After checking the new subscribers I noticed that none had verified their email addresses, not even one, that’s definitely not a confidence.

After some quick research I understood that I had indeed been spammed. But all the emails look legit. Here are some examples:

kathyolynn@yahoo.com
lukeckins@gmail.com
dispatch@gonealinc.com
doug_fern@hotmail.com

After some initial research (entering the emails into haveibeenpwned) it looks like most of these email addresses have been in some kind of hack or breach.

So what was happening? How can I prevent it in the future?

Someone, decided to use compromised email addresses to spam my form. Either to pollute my newsletter, to see how far they could go or just because they can?

What I learned

When making anything publicly available on the internet, there will be spammers, there will be bots and there will be people trying to hack it. That is why you should always be making it as secure as possible.

It turns out that this kind of spam attack is more common that you think (especially since my blog’s newsletter also got spammed a couple weeks later). Bots crawl the web and look for forms, usually newsletter or contact forms and then start submitting “leaked” email addresses.

But why? Here are some reasons I came up with:

• To pollute your email list (if this is a personal attack, which I don’t think it is in this case)
• To test the validity of the emails??
• To annoy the leaked email addresses owners by having them subscribed to thousands of newsletters
• To annoy the website owner (me)

How I fixed it

I have a couple solutions to this problem.

Step 1: Enable Double Opt-in

The fist and most important step is to make sure that all your newsletters are ‘double opt-in’ meaning that the user has to confirm their email address before getting subscribed

On listmonk (the newsletter software I am using) make sure that the list that you are subscribing your users to is double opt in

This means that even if your form gets spammed you can just remove all the addresses that haven’t verified their email (after a couple of days/weeks).

Want to learn how to set up your own self-hosted newsletter with Listmonk?
Check out my guide: How to set up a self-hosted newsletter using Listmonk

Step 2: Add Captcha or Cloudflare JS challenge

The second step I took was to enable some sort of catcha. Initially I setup an hcaptcha via listmonk. But I don’t think that is the best solution as it’s kind of annoying. I am however using it for the videiro.com newsletter. If your interested in how to do it here’s how:

1. Open the listmonk web-ui
2. Go to settings
3. Under Security, enable captcha and enter an hCaptcha.com API key (you will first have to signup at hcaptcha.com)

However with this setup if you are using custom forms (like the email subscription form bellow) the submission process will be kind of broken.

So instead what I came up with and I am currently using on 4rkal.com newsletter is to use cloudflare JS Challenge on a specific subdomain.

The way that I have setup my email newsletter is that I have listmonk running on newsletter.4rkal.com, a seperate subdomain.

This means that I can set that specific subdomain as “under attack” on cloudflare and prompt users to sometimes complete a catcha.

To do this:

1. Head to cloudflare.com
2. Login and head to the dashboard of your specific domain
3. Under Security select WAF
4. Then click on Create rule
5. Give it any name
6. Under Field select hostname and under Operator select wildcard, in Value enter the subdomain, in my case that’s newsletter.4rkal.com. The expression should look like this (http.host wildcard "newsletter.4rkal.com")
7. Under Choose action select JS Challenge
8. Click on Save

And that’s about it

Summary

Getting your website spammed is never fun, but I hope this article might have given clarity to people going through the same problem as me.

Ever since I first got into crypto I have been building products to make using crypto easier. In early 2022 I co-founded RubyTrades a (kind of p2p) non kyc fiat on ramp that allowed users to buy and sell crypto using PayPal. Although it was not as successful as we had hoped it still gained some traction and I learned a lot from it. After that I got interested in Monero. I built MoneroOS a plug and play live operating system that mines monero on boot. I also built MoneroNodeMonitor and some other projects.

I was always fascinated by cross-chain on chain swaps (like rubic.exchange), so I decided to build something similar, but better.

What is CypherGoat?

It is a crypto swap aggregator it automatically finds the best exchange rates from our partnered exchange at no extra cost. You can then perform the swap on that exchange, without ever leaving our website!

Why it’s cool

• KYC-Free – No personal verification required.
• Non-Custodial – Direct to wallet trading (on chain swaps)
• Open Source – Our web UI is open-source.
• User-Friendly for Everyone – Unlike other aggregators with complex interfaces, CypherGoat has a clean and simple UI, perfect for both beginners and advanced users.
• Fast & Seamless – Just pick your tokens, swap, and receive.

How it works

Using CypherGoat is ridiculously simple:

1. Choose your tokens – Select the crypto you want to send the one you want to receive and that the amount you want to swap.
2. Get the Best Rate – CypherGoat “scans” exchanges and finds the best deal for you.
3. Swap & Receive – Confirm the trade, enter your address, send your funds, and get your swapped crypto in your wallet.

Final thoughts

Crypto swapping shouldn’t be complicated, and I truly believe CypherGoat makes it easier. If you have thoughts, suggestions, or just want to chat about crypto, let’s connect! You can find me and the growing CypherGoat community on Telegram and Twitter .

Head over to cyphergoat.com, to see the magic ; )

It has two parts:

1. An API that interacts with exchanges. Written in go and uses gin
2. The Web UI that is written in go and uses a combination of HTML, HTMX, tailwindcss, CSS and Javascript in templ templates. Aka the GoTTH stack. It interacts with the api in order to find rates etc.

What is extremely cool with this stack and setup is that we are able to produce a single binary with everything included for each part and ship it to the server. On the webui side this is possible since the html is compiled into go code using templ and then shipped with the binary.

In this article I will be going through my setup to make it easier for you to make something like this.

Setup

I am using a debian 12 server which will expose my application via cloudflare tunnels. All of the static files are being served via nginx and the api and website binaries are ran as systemd services.

In this guide I will show you how I set this up.

The setup

I have a single folder on my dev machine called cyphergoat: It contains

api/
web/
builds/

The api folder houses the api source code. The web the website source code.

And the builds houses all of the builds that are deployed to the server.

Tailwind

The first real challenge comes with setting up tailwindcss correctly.

In my web project I have a static folder specifically for static files. Inside of it I have two files

/web
	styles.css
	tailwind.css

The styles.css simply contains:

@import "tailwindcss";

The tailwind.css file is where tailwind-cli will save it’s stuff.

To build the tailwind stuff I simply run

npx @tailwindcss/cli -i ./static/styles.css -o ./static/tailwind.css --watch

(assuming you have tailwind-cli installed)

In my header.templ file (the header of all the pages) at the top I have

<link href="https://4rkal.com/static/tailwind.css" rel="stylesheet">

<link href="https://4rkal.com/static/styles.css" rel="stylesheet">

And the files are being served using echo’s e.Static (in my main.go file )

func main(){
e := echo.New()

e.Use(middleware.Logger())
e.Use(middleware.Recover())
e.Use(middleware.Secure())


e.Static("/static", "static") // Serves content from static folder.

// Rest of the handlers
}

Server

On my server side I have a debian 12 vm running on proxmox.

In my users home directory I have a folder with the following contents:

cyphergoat/
├── api
├── static/
└── web

The static folder contains all of the static files (including tailwind.css and styles.css) and the web and api are the binaries.

I then have two systemd services for these exectuables:

The cg-api.service /etc/systemd/system/cg-api.service

[Unit]
Description=CypherGoat API
After=network.target

[Service]
User=arkal
Group=www-data
WorkingDirectory=/home/arkal/cyphergoat
ExecStart=/home/arkal/cyphergoat/api
Restart=always
RestartSec=1

[Install]
WantedBy=multi-user.target

And cg-web.service /etc/systemd/system/cg-web.service

[Unit]
Description=CypherGoat Web
After=network.target

[Service]
User=arkal
Group=www-data
WorkingDirectory=/home/arkal/cyphergoat
ExecStart=/home/arkal/cyphergoat/web


[Install]
WantedBy=multi-user.target

Both are owned by the group www-data (this is probably not necessary for the api), in order to make it easier to serve them via nginx.

Nginx

The website is communicating with the api but I still need to make the web-ui accessible.

I have setup an nginx site with the following configuration: /etc/nginx/sites-available/cg

server {
    server_name cyphergoat.com;

    location / {
        proxy_pass http://127.0.0.1:4200;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static/ {
        alias /var/www/static/;
        expires 30d;
    }
    
    # Optional robots.txt
    location = /robots.txt {
        root /var/www/static;
        access_log off;
        log_not_found off;
    }

    listen 80;
}

I have also setup certbot to have an ssl cert.

You can setup certbot by running:

sudo apt install certbot python3-certbot-nginx -y

Generate the ssl cert:

sudo certbot --nginx -d cyphergoat.com

Read Self host your own website for a more in depth nginx setup.

Cloudflare Tunnels

I am currently making my website accessible using cloudflare pages. It is an extremely easy to use port forwarding solution

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have. The service type should be HTTP and the url should be 127.0.0.1:80 or localhost:80

Obviously there is no reason to make your api publicly accessible when deploying your website.

Deployment

In order to deploy my binaries I went ahead and created a quick bash script:

cd api
go build -o ../builds/ .

cd ../web

templ generate && go build -o ../builds/web cmd/main.go

cd ..
rsync -urvP ./builds/ user@SERVER:/home/user/cyphergoat
rsync -urvP ./web/static user@SERVER:/home/user/cyphergoat/
rsync -urvP ./api/coins.json user@SERVER:/user/user/cyphergoat/

The script will build the api, generate the templ files and build the webui and then sends everything over to my server (including the static folder)

I then ssh into my server

ssh user@ip

and then restart the services

sudo systemctl restart cg-api cg-web

And that’s it.

Join my free newsletter!

Related Articles

Simple Rate Limiting in Go (Gin)

How to build a URL shortener in Go

How to deploy django to production

Setting up the rate limiting

In my implementation I am setting a 30 request/minute limit on each IP interacting with my API.

Here is some example code:

package main

import (
	"time"

	"github.com/gin-gonic/gin"
	"github.com/ulule/limiter/v3"
	ginlimiter "github.com/ulule/limiter/v3/drivers/middleware/gin"
	memory "github.com/ulule/limiter/v3/drivers/store/memory"
)

func main() {
	router := gin.Default()

	rate := limiter.Rate{
		Period: 1 * time.Minute,
		Limit:  30, // 30 Requests/minute limit
	}

	store := memory.NewStore()

	// Create the rate limiter
	instance := limiter.New(store, rate)

	// Middleware to apply rate limiting per IP
	router.Use(ginlimiter.NewMiddleware(instance))

	// Example endpoint
	router.GET("/", func(c *gin.Context) {
		c.JSON(200, gin.H{"message": "Hello World!"})
	})

	// Start server
	router.Run(":8080")
}

We first create a new gin router called router.

After that we setup a rate limiting policy. In this case it is 30 Requests/minute

After that we create an in memory store to store all of the IP’s and their request counts.

Then we create a new rate limiting instance and use it using router.Use

After that we define a standard example route to “/” that returns Hello World and run it on port 8080

You can test this by going to your web browser to localhost:8080/ and send 30 requests (30 refreshes) in one minute and you should see Limit exceeded

That’s about it.

Join my free newsletter

Related Articles

Deploying Go + Templ + HTMX + TailwindCSS to production

How to build a URL shortener in Go

How to deploy django to production

Linux is a family of free and open source operating systems based on the Linux kernel.

Although being completely free (unlike alternatives) Linux currently only has 4.5% of the global desktop operating system market, a very low percentage.

What makes Linux great?

The core difference between Linux and other mainstream desktop operating systems (windows, macOS) is the fact that it is free and open source. This allows it to be:

1. Highly performant - Linux is often faster and more efficient than its counterparts.
2. Free from spyware and ads - Unlike Windows 11 which is adding ads to the start menu
3. Arguably more secure - Being open source often makes it more secure
4. Endlessly customizable
5. Completely free forever - Because it is published under a free and open source GPL license.
6. and much much more

Read The importance of open source software for more information about open source software and it’s superiority.

If Windows and macOS are like apartments with rules and restrictions on what you can change, then Linux is like a house that you own that you can renovate, decorate and modify any way you like.

If Linux is so great why isn’t everyone using it?

We (all Linux users) can probably agree that the main drawback of Linux is user-friendliness. The average user never cared and will never care about what bootloader their laptop is using.

The fun part however is that most people are using Linux, they just don’t know it!

Android

Android is the most widely used mobile operating system in the world. With a staggering 71% of the global mobile operating system market

A lesser known fact is that android is based on the Linux kernel.

So basically 71% of smartphones are running Linux!

Servers

Linux is the leading operating system on servers (over 96.4% of the top one million web servers’ operating systems are Linux) It also leads other systems such as mainframe computers, and is used on all of the world’s 500 fastest supercomputers.

This website is being served from a Linux server.

The majority if not all of the websites that you visit every single day are being served from a Linux server.

IoT and embedded systems

Most IoT (Internet Of Things) devices run Linux because of it’s lightweight nature and robustness. This article from 2018 suggests that 71% of IoT devices run Linux

Most embedded systems (smart TV’s, routers etc) run Linux

Conclusion

Linux is quietly running behind the scenes. It may only capture a small slice of the desktop operating system market but it’s a huge player in mobile, server and IoT spaces. In fact a majority of people are using Linux daily without even realizing it! It’s in your phone, your favorite websites and countless devices around you.

Ultimately I highly recommend anyone interested to at least try and play around with Linux (especially if you are in the IT field I feel like it’s a must)

PS: this article was written on a Framework 13 running Fedora 40 (Linux)

Join my free newsletter

This is a great weekend project especially if you’re new to go.

What is a url shortener?

A URL shortener is a tool that takes a long URL and shrinks it down into something much shorter and easier to share. Instead of copying and pasting a long string of letters, numbers, and symbols, you get a compact version that leads to the same destination. For example, a long URL like www.somelongwebsite.com/articles/this-is-a-super-long-link could become something like bit.ly/abc123. It’s super handy for sharing links on social media, in texts, or anywhere space is limited. And most url shorteners provide analytics like link clicks.

Requirements

1. Go installed on your system.
2. A code editor, eg vs code, neovim

In this project I will be using echo as the http server and the standard html library.

Project Setup

Create a new directory to house our project

mkdir project-name
cd project-name

Assuming you have golang installed.

Create a new go module (project):

go mod init project-name

Before we start writing any code we first have to install echo:

go get github.com/labstack/echo/v4

Now create a new file called main.go

touch main.go

And open it in your favorite editor.

Creating url handlers

func main() {

	e := echo.New()
	
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	e.Use(middleware.Secure())
	
	e.GET("/:id", RedirectHandler)
	e.GET("/", IndexHandler)
	e.POST("/submit", SubmitHandler)
	
	e.Logger.Fatal(e.Start(":8080"))

}

This will create three different routes/handlers.

The /:id, which will redirect the user to the required website

The / which will display a url submission form for new urls to be added

Finally the /submit which will handle url submissions from the form in /

Redirect Handler

The most important part of our application is the redirect handler, which will redirect the user to the url that was specified.

Before we create any urls we first have to declare some variables and make a helper function

In order to have a random ending to our url. eg /M61YlA, we will create a new function called GenerateRandomString

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

func generateRandomString(length int) string {
	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))
	
	var result []byte
	
	for i := 0; i < length; i++ {
	index := seededRand.Intn(len(charset))
	result = append(result, charset[index])
	}
	
	return string(result)

}

This will select length random characters from the charset. If you want your slugs (urls), to not contain any capital letters, you can remove them from the charset.

Now we will need to have a place to store all of our links. In this example we will be storing them in memory and not a database.

Create a new struct called Link and a map called LinkMap:

type Link struct {
	Id string
	Url string
}

var linkMap = map[string]*models.Link{}

You can also add some sample data to it.

var linkMap = map[string]*Link{ "example": { Id: "example", Url: "https://example.com", }, }

Now we can (finally) create our RedirectHandler, which will handle all of the redirects for our url shortener.

func RedirectHandler(c echo.Context) error {
	id := c.Param("id")
	link, found := linkMap[id]
	
	if !found {
	return c.String(http.StatusNotFound, "Link not found")
	}

	return c.Redirect(http.StatusMovedPermanently, link.Url)
}

This function will get the id of the link eg /123 and will look for it in the global LinkMap, if it is not available it will return an error that the link was not found. Otherwise it will redirect the user to the specified url using a 301 Permanently Moved http response code.

Recap #1

The code so far should look something like this:

package main

import (
"math/rand"
"time"
"github.com/labstack/echo/v4"
"github.com/labstack/echo/v4/middleware"
)

type Link struct {
	Id string
	Url string
}

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

var linkMap = map[string]*Link{ "example": { Id: "example", Url: "https://example.com", }, }

func main() {
	e := echo.New()
	
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	e.Use(middleware.Secure())
	
	e.GET("/:id", RedirectHandler)
	//e.GET("/", IndexHandler)
	//e.POST("/submit", SubmitHandler)
	
	e.Logger.Fatal(e.Start(":8080"))
}

func RedirectHandler(c echo.Context) error {
	id := c.Param("id")
	link, found := linkMap[id]
	
	if !found {
	return c.String(http.StatusNotFound, "Link not found")
	}
	
	return c.Redirect(http.StatusMovedPermanently, link.Url)
}

func generateRandomString(length int) string {
	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))
	
	var result []byte
	
	for i := 0; i < length; i++ {
	index := seededRand.Intn(len(charset))
	result = append(result, charset[index])
	}
	
	return string(result)

}

Run the server

go run .

You might also want to install any missing dependencies:

go mod tidy

If you head to localhost:8080/example you should be redirected to example.com

Submission Handlers

We will now define two new routes inside of our main function

e.GET("/", IndexHandler)
e.POST("/submit", SubmitHandler)

These two handlers will handle the default page displayed in / which will contain a form that will be submitted to /submit in a post request.

For the IndexHandler our code will look something like this:

func IndexHandler(c echo.Context) error {
	html := `
		<h1>Submit a new website</h1>
		<form action="https://4rkal.com/submit" method="POST">
		<label for="url">Website URL:</label>
		<input type="text" id="url" name="url">
		<input type="submit" value="Submit">
		</form>
		<h2>Existing Links </h2>
		<ul>`
	
	for _, link := range linkMap {
		html += `<li><a href="https://4rkal.com/` + link.Id + `">` + link.Id + `</a></li>`
	}
	html += `</ul>`
	
	return c.HTML(http.StatusOK, html)
}

When we visit / a submission for will be rendered, to submit a new website. Under the form we will see all registered links from our Linkmap

PS it is not recommended that you use html like this. You should be separating the html file or using a library like templ.

The submission handler SubmitHandler should look something like this

func SubmitHandler(c echo.Context) error {
	url := c.FormValue("url")
	if url == "" {
		return c.String(http.StatusBadRequest, "URL is required")
	}
	
	if !(len(url) >= 4 && (url[:4] == "http" || url[:5] == "https")) {
		url = "https://" + url
	}
	
	id := generateRandomString(8)
	
	linkMap[id] = &Link{Id: id, Url: url}
	
	return c.Redirect(http.StatusSeeOther, "/")
}

This handler will take a url from the form that was submitted, do some (simple) input validation and then append it to the linkMap.

Final Recap

The code for our url shortener is:

package main

import (
	"math/rand"
	"net/http"
	"time"
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

  

type Link struct {
	Id string
	Url string
}

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

var linkMap = map[string]*Link{"example": {Id: "example", Url: "https://example.com"}}

  
func main() {

	e := echo.New()
	
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())
	e.Use(middleware.Secure())
	
	e.GET("/:id", RedirectHandler)
	e.GET("/", IndexHandler)
	e.POST("/submit", SubmitHandler)
	
	e.Logger.Fatal(e.Start(":8080"))
}

  
func generateRandomString(length int) string {
	seededRand := rand.New(rand.NewSource(time.Now().UnixNano()))

	var result []byte 
	
	for i := 0; i < length; i++ {
		index := seededRand.Intn(len(charset))
		result = append(result, charset[index])
	}

	return string(result)
}

  
func RedirectHandler(c echo.Context) error {
	id := c.Param("id")
	link, found := linkMap[id]

	if !found {
		return c.String(http.StatusNotFound, "Link not found")
	}

	return c.Redirect(http.StatusMovedPermanently, link.Url)
}

  
func IndexHandler(c echo.Context) error {
	html := `
		<h1>Submit a new website</h1>
		<form action="https://4rkal.com/submit" method="POST">
		<label for="url">Website URL:</label>
		<input type="text" id="url" name="url">
		<input type="submit" value="Submit">
		</form>
		<h2>Existing Links </h2>
		<ul>`
	
	for _, link := range linkMap {
		html += `<li><a href="https://4rkal.com/` + link.Id + `">` + link.Id + `</a></li>`
	}
	html += `</ul>`
	
	return c.HTML(http.StatusOK, html)
}

  

func SubmitHandler(c echo.Context) error {
	url := c.FormValue("url")
	if url == "" {
		return c.String(http.StatusBadRequest, "URL is required")
	}
	
	if !(len(url) >= 4 && (url[:4] == "http" || url[:5] == "https")) {
		url = "https://" + url
	}
	
	id := generateRandomString(8)
	
	linkMap[id] = &Link{Id: id, Url: url}
	
	return c.Redirect(http.StatusSeeOther, "/")
}

Closing words

This is a great small project if you are new to/learning go.

It can be very helpful if you extend beyond this tutorial. For example here are some other ideas that you can add to the project:

1. Enhance the input validation
2. Track link clicks + Statistics Page
3. Improve UI (html)
4. Dockerizing the application
5. ++

I did all of those and my url shortener (called shortr) can be accessed under the url app.4rkal.com and the source code is here

Join my mailing list

Setup

I am using a debian 12 server which will expose my application via cloudflare tunnels. All of the static files are being served via nginx and the Django project is being ran by gunicorn.

In this guide I will show you how I set this up.

Preparing the Django project

The first thing you will have to do is open the settings.py and change the following

Debug = False
ALLOWED_HOSTS = ['yourdomain.tld']
CSRF_COOKIE_SECURE = True
CSRF_TRUSTED_ORIGINS = [
    'yourdomain.tld',
]

You should also change the SECRET_KEY to a long random string, that you should never share with anyone.

After that create a new file called .gitignore and paste the following:

db.sqlite3
*.pyc

This will make sure that the database is not uploaded to our server and that no pyc files are either.

Now you can upload your project to a new github repository (or gitea repository). If you don’t want everyone to have access to your source code make sure to set the repository as private.

If you want to make sure that your source code stays private I recommend you setup a selfhosted gitea instance, read Selfhost your own gitea instance - selfhosted, lightweight github alternative, to learn how to do that.

git init
git branch -M main
git add .
git commit -m "initial commit"
git remote add origin https://...
git push -u origin main

Now that you we have done that you should login to your server

Server setup

Before configuring anything make sure that you don’t allow any ssh logins with a password. Follow Securing ssh with Key-Based authentication to secure your server from those kinds of attacks.

Login to your server

ssh user@server.ip

Make sure that your packages are up to data

sudo apt update && sudo apt upgrade

Now install python, pip, git and nginx

sudo apt install python3 python3-pip git nginx

Now clone your project into your home directory.

git clone https://...
cd my-project

Once you’re in install the following:

pip install django django-crispy-forms 

Now try to run the project:

python3 manage.py runserver

if you get an error that a package is missing install it and re run.

Configuring gunicorn

Now we will setup gunicorn

First install it

pip install gunicorn

Now create a new file called gunicorn.service with your favorite text editor:

sudo vim /etc/systemd/system/gunicorn.service

And paste the following:

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=YOURUSER
Group=www-data
WorkingDirectory=/home/YOURUSER/PROJECT
ExecStart=/path/to/gunicorn --access-logfile - --workers 3 --bind 127.0.0.1:8000 PROJECTNAME.wsgi:application

[Install]
WantedBy=multi-user.target

Change YOURUSER to your user.

To find the path to gunicorn run:

which gunicorn

And your project name is the name of the folder inside of your project that contains the settings.py file.

Now run the following commands to start and enable gunicorn (start on boot)

sudo systemctl daemon-reload
sudo systemctl start gunicorn.service
sudo systemctl enable gunicorn.service

Now if you head to 127.0.0.1:8000 you should see your project running.

But were not finished yet

Setting up nginx

Now we need to serve our static content via nginx.

First create a new file nginx configuration file with your favorite text editor:

sudo vim /etc/nginx/sites-available/PROJECT

Change PROJECT to whatever you want

Now paste the following content:

server {
    listen 80;
    server_name YOURDOMAIN;

    location /static/ {
	alias /var/www/staticfiles/;
    }

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Just change YOURDOMAIN to the domain that this will be hosted on.

Create a symbolic link to enable your website:

sudo ln -s /etc/nginx/sites-available/PROJECT /etc/nginx/sites-enabled/

Start and enable nginx:

sudo systemctl start nginx
sudo systemctl enable nginx

Setup static files

The first thing you will have to do is cd into your (django) project

cd project

Now run the following command:

python3 manage.py collectstatic

This will create a new folder called staticfiles

Now to set up the static files we have two options:

1. Change the user in /etc/nginx/nginx.conf to your user (less secure)
2. Copy over the staticfiles to /var/www/ (more secure)

I will be doing the 2nd option:

First create a new file called staticfiles in /var/www

sudo mkdir -p /var/www/staticfiles

Now copy over all of the staticfiles from your project there:

sudo cp staticfiles/* /var/www/staticfiles

Now cd into /var/www

cd /var/www

Change the ownership of all the files

sudo chown www-data:www-data staticfiles
sudo chown www-data:www-data staticfiles/*

Restart the nginx service:

sudo systemctl restart nginx

Now if you head to:

127.0.0.1

You should see your website running with all of the static files being served!

Exposing via cloudflare tunnels

Now to make your website publicly accessible.

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have. The service type should be HTTP and the url should be 127.0.0.1:80 or localhost:80

Now if you head to the domain that you specified you should see your app up and running.

Congratulations!

If you enjoyed this post and want to support my (mostly unpaid) work , you can donate here.

Join my free newsletter!

Listmonk is a selfhosted newsletter and mailing list manager. It is free and opensource, so you have full control over your data. It also offers a super clean webui:

Why choose listmonk over mailchimp, buttodown etc

For me, running a newsletter means owning my email list.

When people create newsletters they want to break free from the big platforms like Twitter or YouTube. When you use a proprietary service like Mailchimp, you’re still tied down to their rules and limitations. With Listmonk, you get more control and independence, which for me is a huge win.

The other reason is that listmonk is completely free (if you don’t count electricity bills/vps hosting bills). Even if you include the cost of your email host + hosting fees it is still tiny compared to mailchimp or buttondown.

Listmonk feature overview

1. Analytics - Tracking email opens, link clicks and bounces
2. Templates - Advanced html templates with template variables
3. Public subscription page - See mine here
4. Subscribers import - Import subscribers from other platforms using CSV.
5. Media Uploads - Upload images etc
6. Email lists - Separate lists eg Weekly roundup and new posts.

And more

Requirements for running listmonk

1. A server running linux, either in the cloud or at home. We will be using debian 12, but you can use any other distribution.
2. An email address to send the newsletter from. Can either be a gmail or a custom one.

Server Setup

Before doing anything I highly recommend that you disable password logins for ssh. See Securing ssh with Key-Based authentication for more info on how to do that.

Login to your server via ssh

ssh user@server.ip

Make sure that all packages are up to date

sudo apt update && sudo apt upgrade

You will also have to have docker installed, if you don’t install it, instructions for debian

Create a new directory to host listmonk’s configuration files

mkdir listmonk && cd listmonk

Download the listmonk docker-compose file

curl -O https://github.com/knadh/listmonk/blob/master/docker-compose.yml

Run it using docker:

docker compose up -d

Now if you head to

localhost:9000

You should see listmonk up and running

But first we should change some settings in the configuration files

vim config.toml

Here you can change the default admin password. I also changed the address to 0.0.0.0 so that I can access it via the servers ip.

Listmonk customization

Now head to the webui at

localhost:9000

Login and head to the settings

In the General tab you can customize the default from email, root url, site name, favicon and admin notification emails

Here’s what my settings look like:

You can customize the page to your liking.

Save by clicking on the save button in the top right corner.

Email setup

For the next part you will either need a gmail account or any other email provider that give you smtp connection

If you want a great custom email I recommend ionos, you can get up to 10$ in credits by using my link Ionos - Email & Office 10$ credits that is the provider that I am currently using.

In this guide I will show you how to set this up for these two providers, but the setup should be similar for others too.

IMPORTANT: Both of these hosts have a limit on how many emails can be sent out per hour or per day. For ionos that is 500/hour. Setting up a Sliding Window Limit is very important.

Setup for gmail

I recommend that you use a different gmail account from your personal one.

The first thing you will have to do is generate an app password, to do that head to Create and manage app passwords and create a new one called listmonk. Copy the password that is generated and save it somewhere safe.

Now head over to the listmonk webui

In the SMTP tab in settings you will find this:

Click on the gmail option as circled.

Now enter your full email address (including @gmail.com) in the username field

And in the password field enter the app password we generated before.

Now click on the Test connection button in the bottom right corner, enter a test email and click on Send e-mail.

If you configured everything correctly you should now get a test message to the email specified.

Don’t forget to save!

Setup for ionos

You should probably generate a new email for the newsletter, eg `newsletter@yourdomain.tld.

Head over to the listmonk webui

Now in the SMTP tab in the settings you see this

The ionos smtp server settings are:

Host: smtp.ionos.com

Port: 465

TLS: SSL/TLS

IMPORTANT: If you’re using IONOS UK or another specific regional version, you need to adjust the host name. For example, if you’re on IONOS UK, you should use smtp.ionos.co.uk instead of the global smtp.ionos.com.

Now in the username field you should enter the full email address newsletter@yourdomain.tld and the password is the normal user password.

Now to test the connection click on the Test connection button in the bottom right corner, enter a test email and click on Send e-mail.

If you configured everything correctly you should now get a test message to the email specified.

Don’t forget to save!

Sliding window limit

This is very important to setup when email providers limit the amount of email to be sent per hour or per day. You can access the Sliding window limit in Settings under the performance tab. For ionos I have it set at 500 emails/hour

Exposing via cloudflare tunnels

I will be making my instance publicly accessible using cloudflare tunnels.

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have.

The service type should be HTTP and the url should be yourserverurl:9000, in my case that’s 127.0.0.1:9000

Now if you head to the domain that you specified you should see gitea up and running.

In my case you can access my newsletter page here

Listmonk feature overview

These are all of the features that listmonk offers:

Templates

Listmonk offers amazing built in template support.

All templates are written in HTML.

You can access the templates by going to Campaigns > Templates.

Don’t forget to always include {{ template "content" . }} (for the main content) and also an unsubscribe button in all of your templates

Campaigns

You can create a new campaign (email) by going to Campaigns > All Campaigns

Here you can select a campaign name, subject the list’s you want to target and the template

Email lists

You can create new lists by going to Lists > All Lists.

For example I have two lists:

1. New posts - Receive an email every time I post something new on my blog
2. Weekly Roundup - Join my weekly roundup, where I share what I’ve been up to that week, including articles I’ve published, cool finds, tips and tricks and more!

Not everyone wants to receive an email every time I post a new article, so I created two lists!

HTML Forms

Listmonk also offers embeddable html forms, to subscribe to the email list. You can access the form builder by going to Lists > Forms

Public subscription page

Except for the HTML forms listmonk also has a public subscription page. For example here is mine.

It can also be accessed under `Lists > Forms

Campaign analytics

You can track the views, clicks and bounces of your email campaigns by going to Campaigns > Analytics.

Import subscribers

You can import subscribers from other platforms by going to Subscribers > Import. It currently supports CSV or ZIP files.

These are the most important features that listmonk offers (I’m sure I forgot some).

That’s all folks

If this article helped you out, consider joining my (listmonk) newsletter bellow:

What is gitea?

Gitea is a painless selfhosted Git service. It is written in Go and is extremely lightweight. I run a gitea instance on my Le Potato and it barely uses any resources.

Why use gitea (vs GitHub, GitLab etc)

I started running my own Gitea instance because I wanted a private place to host my Obsidian notes. I did not want to have them in a private GitHub repository since it’s not on my own hardware. GitLab is harder to spin up and has a lot of features that I do not need.

If you want an easy to spin up, private git service gitea is your way to go.

Setup

In this guide I will be using debian 12. The setup should be the same on any other distribution since we will be using docker.

Installing and setting up docker

The first thing you will need is docker installed on your system.

Install docker on debian

Also make sure to add your user to the docker group. This will allow you to run docker commands without sudo.

usermod -aG docker $USER

Now reboot

Docker-compose.yml

Once docker is installed. We have to get gitea up and running

First create a new directory. This will host our docker-compose file.

mkdir gitea

Then create/edit docker-compose.yml in your favourite text editor.

vim docker-compose.yml

Then paste the following content:

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

You can change any of the default ports eg switching 3000 to 8000 can be done like this:

ports:
- "8080:3000"

You can setup gitea using a PostgreSQL or MySQL database. But at least for my needs a simple SQLite3 database is more than enough.

Since I want my repositories to still exist even if the container is deleted I will use named volumes. The configuration file with named volumes should look something like this:

version: "3"

networks:
  gitea:
    external: false

volumes:
  gitea:
    driver: local

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    restart: always
    networks:
      - gitea
    volumes:
      - gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

Starting the container and additional configuration

Now you can start the container by typing:

docker compose up -d

The -d flag will run it in detach mode. If you want to see the logs live you can remove it.

After docker is done pulling, gitea should be up and running.

Now open up:

localhost:3000 or yourserverip:3000

And you should see something like this:

Fill in all of the required information. Since I will be using my subdomain git.4rkal.com I set the server domain and gitea base url to that.

Here you will also have the option to enable sending emails for email verification and notifications. I will be enabling that by using a free (shitposting) email from cock.li.

After you have entered all the required info click on Install Gitea.

After the installation is complete you should be up and running

Make publicly accessible with cloudflare tunnels (optional)

I will be making my instance publicly accessible using cloudflare tunnels.

To do this you will need a cloudflare account and a domain pointed to cloudflare.

First head to the Zero Trust Dashboard

Under Networks click on Tunnels and then Create a tunnel

Once created you should Install and run a connector, follow the instructions on the page for your specific setup.

After the connector is running you should click on the Public Hostname tab and Add a public hostname.

Now you should see something like this:

Fill in the info as I have.

You can create a new subdomain eg git or gitea

The service type should be HTTP and the url should be yourserverurl:3000

Now if you head to the domain that you specified you should see gitea up and running.

In my case you can access my public gitea instance at git.4rkal.com

Congratulations, you now have your very own gitea instance!

If you enjoyed this article, consider supporting me

I recently started working on a cryptocurrency exchange aggregator. Basically I send out requests to a bunch of different exchanges and compare rates. This has to be made as fast as possible. In this post, I’ll some show some tweaks that I made in order to boost my performance significantly.

However keep in mind that I am not an expert (especially in go) and I am just sharing my findings from my own personal project.

Improvements

These improvements come in order of biggest improvement of runtime.

1. Using goroutines

In any Go program, goroutines are essential for speed. The biggest boost I made was by sending requests concurrently. Since I need to hit up 12 different exchanges, sending these requests at the same time dropped my runtime from around 24 seconds to just ~3.

Goroutines are amazing and extremely easy to use. You should include them wherever possible. But always be careful of Data Races

2. Upgrading the JSON Library

I swapped out encoding/json for github.com/json-iterator/go. jsoniter is a fast JSON processing library that works as a drop-in replacement for the standard library, so I didn’t have to change any code, just a library switch.

Benchmark Results

To measure the performance improvements, I ran some benchmarks comparing encoding/json and jsoniter. Here’s a summary of the results:

goos: linux
goarch: amd64
pkg: apiSpeedImprove
cpu: AMD Ryzen 5 7640U w/ Radeon 760M Graphics      
BenchmarkEncodingJSON-12          140383              7381 ns/op
BenchmarkJSONIter-12              974605              1217 ns/op
PASS
ok      apiSpeedImprove 3.216s

So, jsoniter is about 6 times faster than the standard library.

3. Reusing HTTP Handlers

I started reusing HTTP handlers instead of creating new ones for each request. By setting up a handler once and reusing it, I cut down on the overhead of making new handlers for each request.

Benchmark Results

Here are the results of the benchmarks comparing reused handlers versus creating new handlers for each request:

goos: linux
goarch: amd64
pkg: apiSpeedImprove/httpReuse
cpu: AMD Ryzen 5 7640U w/ Radeon 760M Graphics      
BenchmarkNewHttpClientEachRequest-12                3360            300058 ns/op
BenchmarkReuseHttpClient-12                         6470            175472 ns/op
PASS
ok      apiSpeedImprove/httpReuse       4.010s

Reusing HTTP handlers gave a solid performance boost compared to making a new handler for each request.

Conclusion

With these tweaks I managed to cut the time it took to gather all the info from 24 seconds initially to about 2 seconds. Pretty solid improvement!

If you are interested the code for my benchmarks, it is available here

If you enjoyed this post and want to support my work, you can donate here.

Obsidian

Obsidian is a feature packed markdown editor. But it’s not just a markdown editor. It’s a way to manage knowledge. It’s great for organizing your thoughts in a flexible, non-linear way.

Obsidian works on all platforms. So you can write articles from basically any platform.

I have been taking all of my notes in it for a couple of months now and it’s amazing!

Hugo

Hugo is an ultra fast static website generator made in golang. I have been using hugo for my blog for almost 2 years now. I recently switched the theme of my my blog. Read more about the change New Look, new start.

Using Obsidian with Hugo

In this guide, I’ll show you how to get Obsidian and Hugo working together. I won’t cover the initial setup of either tool, but I’ll explain how to integrate them for a smooth blogging workflow.

If you need help setting up Hugo, check out my guide: How I Setup This Blog for Free (Domain, Hosting, SSL) Complete Guide. And if you’re new to Obsidian, check out this Getting Started Guide .

Goals for Using Hugo with Obsidian

My goals for the setup are:

1. Using a single obsidian vault
2. Have an easy to use obsidian template that I can use for my blog posts.
3. Keep my personal vault folders private.
4. Auto publish using obsidian hotkeys.
5. Have all markdown files in a public github repository, so that people can propose changes

Existing setup

Here’s how my current workflow with Obsidian and Hugo looks:

1. I write and edit articles directly in Obsidian, within the content folder of my Hugo project.
2. I run the Hugo command to generate the static site.
3. I push the changes to GitHub.
4. Render.com automatically picks up the changes and deploys the updated site.

Journey

If you want to skip the journey part you can go straight to The Sauce

I will be going through a couple of mistakes that I made while setting this up.

Mistake #1

The first idea that I had was to create a simple symlink (I use linux btw) that would link the two folders together.

Basically I have two folders:

blog/
vault/

The blog folder contains all the blog folders and the vault is my personal vault.

The symlink would link these folders

blog/content
vault/Blog

However the problem with a symlink is that the folder content is not visible in my git repo. This means that people can not propose changes to any of my articles

Mistake #2

I wanted to have my folders synced. I tried writing a couple of bash scripts that automatically synced the two folders using a cronjob. However having that constantly running the background is a waste of resources when I am not writing. Simply running the scripts via cli is just not that smooth.

The Sauce

Basically the way that I have set this up is I have two folders:

blog
vault

The blog folder contains all the necessary hugo files and also has a sub directory called content that houses all of the markdown blog files.

I created a new folder inside of my vault called Blog

blog/content
vault/Blog

After that I copied over all of my files from the content directory to the Blog.

I then started writing this very article

Obsidian templates

I needed some way to setup a simple obsidian template to contains all of the required hugo front matter.

That is quite easy.

Read about how to setup templates Templates - obsidian.md

I created a file called Blog Post in my templates folder

My Blog Post template contains the following:

---
title: "{{Title}}"
description: 
date: "{{date:YYYY-MM-DD}}T{{time:HH:mm:ss}}+00:00"
draft: true
---


**If you enjoyed this article consider [supporting me](https://4rkal.com/donate)**

I have all the required front matter including a title, description and a date in the format that hugo asks.

I also added a small donation text that I include at the bottom of every article.

This means that I can automatically insert this template into any file and start writing!

Folder Syncing

Now I want all of my files in my vault/Blog directory to be copied over to the blog/content. Essentially connecting Hugo and Obsidian.

Thank’s to a helpful discord user I found the obsidian-shellcommands plugin.

NOTE: this plugin does not currently work very well with the flatpak version of obsidian (since flatpak isolates the environment) . Using another alternative (.deb or appimage) seems to work.

It allows you to run shell commands in the background with a hotkey.

The steps to set this up are the following:

1. Install the plugin
2. Enable the plugin
3. Go to the plugin options
4. Click on New shell command
5. Now you will need to enter a shell command to copy the files from the one folder to the other.

On Linux/MacOS that is:

cp -a ~/folder1/. ~/folder2/

in my case that is cp -a ~/Documents/vault/Blog/. ~/Documents/blog/content/

On windows it most probably is:

robocopy "%USERPROFILE%\folder1" "%USERPROFILE%\folder2" /E /COPYALL

After that we need to set a hotkey that will run the command

Click on the (+) icon to go to the hotkey settings and assign a hotkey

My hotkey is CTR + 0, simply because that was available.

Now every time that I run the hotkey it copies over all of my files to the hugo folder ready to be published

Auto publishing scripts

I also want to be able to automatically publish my articles. But I want it to happen when hitting a hotkey.

I wrote a small script that does exactly that:

#!/bin/bash
cd ~/Documents/blog

hugo

git add .
git commit -m "new"
git push -u origin main

This script will build my website, commit and push to my github repo, where it is picked up and published. Read How I setup this blog for free (domain, hosting, ssl) Complete Guide to learn how to setup your own blog for free.

Don’t forget to make the script executable by running

chmod +x ./YOURSCRIPT.sh

Then create a new shell command for the shellcommand plugin (as we did before) and enter the path to your script.

In my case that is:

~/Documents/blog/push.sh

Then enter a hotkey and you’re done!

Conclusion

I can now simply open my obsidian vault, create a new file, insert my template and have all the info automatically entered.

I then write my article inside of obsidian

Run my hotkey and copy all the files into the hugo directory

Hit another key and my blog is published!

If you enjoyed this article consider supporting me

Why the switch?

• The LoveIt theme hasn’t been updated in 2+ years.
• PaperModX has a more modern look
• LoveIt doesn’t work that well with obsidian.

The overall switch went pretty smoothly. You can see the changes I made in this commit.

For anyone wondering this what the website used to look like

More articles to come!

The theme wasn’t the only change that I made. After a pretty long break, I have decided to start publishing articles regularly again!

I will also start to update any outdated articles

So, stay tuned - There’s more content to come!

Subscribe to my RSS feed to stay up to date here

There’s also going to be a mailing list soon™️

Requirements

1. An old laptop/computer with a webcam (to be kept offline). Called offline or cold computer.
2. An android smartphone.
3. Your main computer

Required reads

Before starting this article you must read:

1. Key concepts
2. Monero offline transaction signing details

Cold computer setup

Your offline computer/laptop will be signing all of the transactions. It should always be kept offline i.e cold. It can not be used for other tasks.

I highly recommend that you use a linux distribution and NOT windows for cold storage. Linux is free and opensource. I highly recommend pepermintOS or MX linux as they are lightweight and pretty easy to setup.

I will not be guiding you on how to install [[linux]]. But here are some resourses to help you get started:

• Installing PeperMintOS <– somewhat 32 bit support, lightweight

• Installing LinuxMint <– better for newer computers

• Installing MX Linux <– 32 bit support, pretty lightweight

Downloading & Installing necessary software

The first thing that we will need to do is download the required software.

We will need featherwallet

and that’s about it.

Taking the device offline

It is highly recommended that you disable the wifi and bluetooth modules on your cold computer. This can be by physically detaching the wifi and bluetooth module or disabling it in the bios. The later is less secure if you’re going full on tinfoilhat.

Here’s a guide on how to physically disable them from malvarma.org

A guide on how to disable it via BIOS can be found by searching your specific hardware on your favorite search engine.

Computer cold wallet setup

Now we will have to setup our wallet. Ensure that your device is completely offline and then open featherwallet.

1. Click on Create a new wallet. Then click on Next. You will be presented with your seedphrase. Write it down!! on physical paper.
2. Select a name for your wallet and click Next
3. Select a wallet password and click Next.
4. Now that the wallet is open in the bottom right corner there will be a dot. Click on it and select the offline box and then click Disable all network connections (offline)

Phone

We will now be installing the anonero software. We will be using NERO from the ANON/NERO suite.

1. Download and install fdroid. Apk can be downloaded from the F-Droid website

2. Download and install orbot. Can be installed from google play store here

3. Open orbot. Select VPN Mode, click on the onion logo that says start

4. Open fdroid and in the settings scroll down and enable Use Tor option

5. Again in the settings that click on the repositories section and add the following:

   http://anonero5wmhraxqsvzq2ncgptq6gq45qoto6fnkfwughfl4gbt44swad.onion/fdroid/repo?fingerprint=C5705FF724538F6925B6093517F53C6C6BB6CF82518ED40EB4B8CBBB87DC0D1D

   Source: anonero.io

6. Click on latest and then search for NERO

7. Click on install That’s it ; )

Updating NERO

If you want to update NERO you will have to turn orbot on, open fdroid and refresh the updates tab

NERO setup

To set up NERO, follow these steps:

1. Once NERO is successfully installed, open the application.

2. Click on RESTORE WALLET option and select RESTORE FROM KEYS

3. Proceed to establish a node connection. You can find a lot of Monero nodes here.

   Random clearnet node:

   • http://xmr.monopolymoney.eu:18089

   Random Tor node:

   • http://xmrsalty4hg7lq5ci4kzc2xxcic57azapolbunmkiypnmr3wp7uvqnyd.onion:18089

Copy the node address into the node field. By default you shouldn’t need a username or password

By default tor connectivity is enabled in NERO. You can disable it by going into the proxy settings and deleting everything.

4. Click on Connect. It will try connecting. If it fails check your internet connection or try another node

Importing view-only wallet

Now you will have to import your wallets Primary address , Secret-View key and Restore height into NERO. To import that info to nero:

On your offline computer open featherwallet and navigate to Wallet then View-Only. Enter your password and click on the Show QR

Now in nero in the View only keys screen click on the square icon to scan the qr. Then scan the qr displayed by featherwallet. All the info should be filled in after scanning the qr code. Click Next.

Set a pin. After that your wallet should be imported into NERO.

Receiving monero

To receive monero you can follow these steps

1. Open NERO and enter your pin
2. Click on the receive tab (the one with the qr code icon)
3. Long hold on the address
4. Select one of the SubAddreses and click on the copy icon.
5. Transfer any amount of monero to that address.

After 10 confirmations it should be spendable. Proceed to the next step.

Signing transactions

Signing/Broadcasting transactions is easy with the NERO/Feather duo. No usbs are needed it is all done via animated QR codes.

To sign/broadcast a transaction follow these steps On your phone:

1. Open NERO and enter your pin
2. In the send tab enter the desired address and amount
3. Click on continue, you should now see an animated QR code.

On your cold computer

1. Open feather and enter your password
2. Click on Tools > Offline transaction signing. You should now see your camera
3. Show your phone to the computers camera so that it can read the QR code.
4. After it has been picked up by your computer you should see a QR code displayed on your computers screen

In NERO.

1. Click on SCAN KEY IMAGES
2. Scan the QR code from the computer’s screen
3. Once it has been picked up you can see the Address, Amount, Fee and Total. Click on confirm
4. You should now see the unsigned TX screen.

In feather click on Next. Then scan the QR code displayed by NERO to your computer. Once the bar is at 100%, you should again see the Address, Amount, Fee and Total. If your ok with that click on SIGN.

In NERO

1. Click on SCAN SIGNED TX
2. Scan the QR displayed by feather wallet.
3. Click on Yes, once asked whether or not to broadcast transaction

You have now sent the transaction.

if this article helped you out consider supporting me

Requirements

1. An archlinux install
2. A usb

Setup

In this guide I will show you how to build a custom archlinux iso with monerogui installed. I will not be providing any pre-built images.

The first thing you will have to do is install archuseriso. You can install it from the aur using this command:

yay -S archuseriso

Now open a terminal and navigate to any directory. Then run the following command:

sudo aui-mkiso -m 'img' --add-pkg=monero-gui xfce --verbose

This will build a new gpt image with persistense, add the monero-gui package and use xfce as the default desktop. The –verbose flag is optional.

After that is finished building you can use your favourite image writter to write the image. I will be using dd sudo dd if=out/aui-xfce*.img of=/dev/CHANGEME

You will have to write that to your usb, so in /dev/CHANGEME just put your usb. You can find it by running lsblk Don’t be stupid If you enter the wrong device this could lead to data loss. Be careful!

After the image is written you will have to boot to your usb.

First however it is recommended that you disconnect any ethernet/other cables plugged in so that it is trully offline.

You can also disable wifi and bluetooth from the bios . “Advanced” users only don’t be retarded

Now only plug in your usb drive and reboot into the usb. You will generaly have to press either F8,F9,F10,F11 upon booting and then select your usb.

Now you have two options

1. Boot into persistent.
2. Boot into memory.

When booting into persistent your files will be saved. This however does also involve your wallet file.

For the more secure option you can select boot into memory. This will delete all the traces of the wallet after reboot. You will have to write the seed down and manually enter it upon every boot if you want to authorize transactions.

I will boot into persistent since I will use a strong password and will keep the usb in a safe place. If you want to be extra paranoid use the second option.

After the os has fully booted you will have to click on the Applications icon > internet > Monero GUI. Alternatively open a terminal and type monero-wallet-gui

You will now be greated by the monero gui setup guide.

Select your language etc.

Select advanced > Click on Create a new wallet . You can select whatever you want in the wallet name and location > Click next.

Now you will be prompted with your recovery phrase. Write it down on PHYSICAL PAPER and keep it in a safe place. Also note the height and or creation date.

Write it down! If you don’t write down your seed and keep it in a secure place you will lose access to your monero!

Then click next. Now select a strong password. Alteast 12 chars!. Remeber it!

Click next. Then click on Connect to a remote node but don’t add one, we don’t need it.

Then click on create wallet.

After you have opened your wallet, click on settings and then Create view-only wallet. Then click on ok. Logout of your wallet. Click on Open wallet from file and select the new file called WALLETNAME_viewonly.

Once you have logged into your view only wallet click on settings again and select Show seeds and keys. Scroll down to the botton and import your view only wallet via qr to your mobile wallet. Here are some guides for every wallet:

• Cake wallet
• Monerujo

What have we acomplished?

You now have a cold wallet for offline signing on your usb and a view-only wallet on your phone. Basicly you can view all incoming transactions on your phone but can’t spend them there. Only your computer booted into the usb can sign them.

Signing transactions

I won’t cover doing this in this article. But you can find out more about how to send transactions from cold storage here

Requirements:

1. A computer “server” (running linux)
2. A internet connection
3. Another computer to connect to your server (running linux)

Why?

If you want to access your server without portforwarding in a extremely secure fashion you will want to follow this tutorial. You will be connecting to the server via tor which will make it harder for anyone to find the url of the server and ill show you how to setup keybased auth for even more security!

Setup

You will have to install the following packages (ssh, tor)

On debian

sudo apt install openssh-client

On arch

sudo pacman -S openssh

After that enable the ssh service

Debian:

sudo systemctl enable ssh

Arch:

sudo systemctl enable sshd

If you want to check if this worked just use another computer and run

ssh USER@IP

for example I run

ssh arkal@192.168.1.69

After this you can enable KeyBased authentication for more security

Here is my article how to enable that :

Enable keybased authentication

Now we need to install tor:

On debian

sudo apt install tor

On arch

sudo pacman -S tor

Then start and enable the tor service with

sudo systemctl start tor && sudo systemctl enable tor

After you have done that you want to edit your torrc file. Using your favorite text editor

sudo vim /etc/tor/torrc

Now you will want to navigate to the part that says HiddenService. And paste the following

HiddenServiceDir /var/lib/tor/ssh/
HiddenServicePort 22 127.0.0.1:22

Save your file and exit the editor (for nano cntrl s, cntrl x)

Now you want will have to restart the tor service

sudo systemctl restart tor

After that run the following:

sudo cat /var/lib/tor/ssh/hostname

You should see a string of letters and characters ending in .onion 

Now on your other machine:

Connecting to the server

On your main machine you will have to do the following:

Have ssh, tor, and socat installed

After you have installed them you will have to edit the ssh config

vim .ssh/config

And paste the following

Host NAME
 Hostname URL.onion
 User USER
 Port 22
 Proxycommand socat - SOCKS4A:127.0.0.1:%h:%p,socksport=9050

You will have to change the NAME, URL and USER. The user is the user you want to connect as to your server and the url is the url you that ends in .onion from above.

Now save the file and exit.

Now edit the torrc file. Using your favorite text editor:

vim /etc/tor/torrc

Find the line that says SOCKSPort and uncomment it

SOCKSPort 9050

Restart the tor service

systemctl restart tor

To connect to the server run the following command:

ssh NAME

With NAME being the name that you gave to the server in the config file.

If this article helped you out consider supporting me

What is hugo?

Hugo is a fast and popular open-source static site generator used for creating static websites without requiring a database or dynamic components.

Hugo setup

Download and install hugo

On debian type

sudo apt install hugo

On arch type

sudo pacman -S hugo

On fedora type

sudo dnf install hugo On windows:

Navigate to https://github.com/gohugoio/hugo/releases/latest

Find the windows version and download it.

Unzip the file to your desired directory

Add this directory to the PATH environment variable

Read more: https://gohugo.io/installation/windows/

Creating the hugo site

Open up a terminal and type:

hugo new site my_website

And then cd into that directory

cd my_website

After that we will have to install a theme. I will be using the LoveIt theme but you can use any other theme

All hugo themes https://themes.gohugo.io/

NOTE: I now use a completely different theme New look, new start

For the LoveIt theme:

The first thing we will have to do is type

git clone https://github.com/dillonzq/LoveIt.git themes/LoveIt

You will have to have git installed if you don’t, follow the instructions on the page to download it.

Now we will have to create some basic configuration. Every theme has its own so you should first check your themes documentation. Some basic settings work for all themes.

Here is an example of the most basic settings for the LoveIt theme. (it has to be saved in config.toml)

baseURL = "http://example.org/"

# Change the default theme to be use when building the site with Hugo
theme = "LoveIt"

# website title
title = "My New Hugo Site"

# language code ["en", "zh-CN", "fr", "pl", ...]
languageCode = "en"
# language name ["English", "简体中文", "Français", "Polski", ...]
languageName = "English"

# Author config
[author]
  name = "xxxx"
  email = ""
  link = ""

# Menu config
[menu]
  [[menu.main]]
    weight = 1
    identifier = "posts"
    # you can add extra information before the name (HTML format is supported), such as icons
    pre = ""
    # you can add extra information after the name (HTML format is supported), such as icons
    post = ""
    name = "Posts"
    url = "/posts/"
    # title will be shown when you hover on this menu link
    title = ""
  [[menu.main]]
    weight = 2
    identifier = "tags"
    pre = ""
    post = ""
    name = "Tags"
    url = "/tags/"
    title = ""
  [[menu.main]]
    weight = 3
    identifier = "categories"
    pre = ""
    post = ""
    name = "Categories"
    url = "/categories/"
    title = ""

# Markup related configuration in Hugo
[markup]
  # Syntax Highlighting (https://gohugo.io/content-management/syntax-highlighting)
  [markup.highlight]
    # false is a necessary configuration (https://github.com/dillonzq/LoveIt/issues/158)
    noClasses = false

You can find my configuration here

You can view your page live by running

hugo serve

Let’s move on to the next step.

Adding articles to our blog

The first thing we will have to do is create a new file with any name ending in .md inside of our content folder. I like to separate my posts from other sections so I will create another folder inside of the content one called posts.

You can run this command to add the file

hugo new posts/first_post.md

Now open the file that was just created using your favorite text editor.

You should see something like this:

---
title: "Epic title"
date: 2023-03-23T18:13:03+03:00
draft: true
---

If you want the post to be publicly visible on your blog delete the draft line. or set it to false.

Now if we want to add some content we will have to write it in markdown. Heres a great guide on some basic markdown syntax https://hugoloveit.com/basic-markdown-syntax/

Heres an example of some content

---
title: "My First Post"
date: 2023-03-23T18:13:03+03:00
draft: false
---

# Welcome to my blog!

This is my first post. Here's a picture of my cat:

![My cat](/images/cat.jpg)

Using the above steps you can add all of your articles to the blog.

Now that we are done with that let me show you how we will publish our blog.

Domain

More like a sub-domain. Head to eu.org and get a free domain. Create an account and submit a request for a new domain. It might take some time even months to get accepted.

I have already registered 4rkal.eu.org from there.

Now we will have to get some ssl certificates using cloudflare.

SSL certificates just make your site use https instead of http this is really great for seo and doesn’t make your site look sus.

Head over to cloudflare.com and create an account for free.

After you are done with that go to your dashboard and select websites and then add a site.

You should see something like this

Enter your websites url and click on add site.

After that select the free plan and continue.

Now it will review your dns records. Just select continue and confirm

Now you will have to change your domain’s name servers.

To do that head back to eu.org select your domain and click on the nameservers tab and select server names.

Now in the input fields enter the name servers.

The name servers will most probably be:

nancy.ns.cloudflare.com
uriah.ns.cloudflare.com

Here’s how it should probably look:

Now click on the submit button.

You should probably get

No error, applying changes...

Done

If you get an error you probably screwed up one of the above steps. Just try again.

After your name servers have been changed and everything is done, in your domain dashboard select SSL/TLS. Just select full encryption.

Hosting our site.

First create a github account. Head to github.com for that. You will also have to install git

After you have done that navigate to your blog’s root directory and type:

git init
hugo
git add .
git commit -m "first commmit"
git branch -M main

Now go to github and create a new repository.

You should now type:

git remote add origin YOURURL

instead of YOURURL enter the url to your github repo and add a .git ending

eg

git remote add origin https://github.com/4rkal/blog.git

Now push the changes with

git push -u origin main

After that if you refresh the page of your github repo you should see everything there.

Now head to render.com and create an account

On your dashboard select +New and then static site.

Now you will be prompted to connect a github repository. Just connect your account and add that repository.

eg

Now enter a service name eg myblog and in the publish directory just add

public

Then click on create static site.

After it has been deployed successfully head over to the settings and in the custom domains tab click on add custom domain.

In the field enter the domain that we registered with eu.org previously.

Now go to cloudflare and in your domain dashboard select dns and click on add a new record.

In the type dropdown select CNAME in the name field add @ and in the target add your blog’s url from render. Mine is https://blog-ygtj.onrender.com/. Also untick the proxy status.

Now we will have to do the same but with the www.

Just do the same steps as above but instead of @ just add www

That’s it. After a couple of minutes your blog should be live.

SEO Google and bing

If you want to get your website on google and bing it’s pretty easy

If you want to get your website on google follow the guide listed here https://developers.google.com/search

For bing it should be pretty much the same process on https://www.bing.com/webmasters/

*If you enjoyed this article consider supporting me

In this course/article I will be talking about why someone should use Python. Later on, I will be tackling the basics of Python. But let’s start by explaining what coding is.

What is coding?

Coding means writing instructions for computers and a finished set of instructions is known as a program. Computer programs control everything from smartphones to space rockets.

What is Python?

Python is a text-based computer language which means it’s made up of words and symbols (such as * and = ). Its language elements and object-oriented approach are meant to assist programmers in writing clear, logical code for both small and large-scale projects.

Why Python?

Python is one of the most popular computer languages and it’s very concise — that is, you don’t need to type much in order to create programs that do a lot.

Advantages of python

1. Simple to read, learn, and write

Python is a high-level programming language with a syntax that is similar to English. This makes the code easier to read and comprehend.

Python is really simple to pick up and understand, which is why many people suggest it to newcomers. When compared to other prominent languages like C/C++ and Java, you require fewer lines of code to accomplish the same purpose.

2. Improved Productivity

Python is an extremely useful programming language. Python’s simplicity allows developers to concentrate on solving the problem.

They don’t need to spend a lot of time learning the programming language’s syntax or behaviour. You write less code and accomplish more.

3. Free and Open-Source

Python comes under the OSI-approved open-source license. As a result, it is both free to use and distribute. You can get the source code, change it, and even share your own Python version.

4. Portability

In many languages like C/C++, you need to change your code to run the program on different platforms. With Python, however, this is not the case. You only have to write it once and it may be used wherever.

Downloading Python

On Linux You probably already know how to install it but I’m gonna show it anyways.

Open your terminal and type python or python3; if it does not work then run: (depending on your distro) sudo apt install python3

Windows 10 1 . First check if you already have Python installed. Go to the ‘Start’ menu and click on the ‘All programs’. If you see the word “Python” it means that you already have it installed. If you don’t already have it installed go to https://python.org, download the correct version for your computer and then install it.

2. Python comes in different versions. This course uses version 3 and upwards. I recommend always installing the latest version.

What is an IDE?

IDE stands for the integrated development environment (IDE) and is software for building applications that combine common developer tools into a single Graphical User Interface (GUI).

The IDE that we will be using in this series is called VS Code.

Downloading VS Code

Go to https://code.visualstudio.com/ and download the version that you want. Vs Code is available for Windows, Mac, and Linux. Follow the instructions on the website for installation.

Starting in Python

It’s traditional in the programming world to make the computer say ‘Hello World’ with your very first piece of code. In Python, this is very simple.

1. Open Vs Code and click on File > New File and name your file helloworld.py. The .py tells the computer that this is a Python program.
2. In your project, in VS Code type : print("Hello World!")
3. Save your project and click on the run button at the top of your screen
4. If you have done everything correctly you should see a Hello World message in your terminal.

If it didn’t work you should get a red error message something like this:

SyntaxError: invalid syntax

If that happens make sure that you have copied it exactly like above.

Playing With numbers in Python

Python makes it easy to do maths. You just type in a question and get the answer

Adding Up

Open an empty project and type:

print(2+2)

You should see the answer: 4

Subtracting(and more) If you want to subtract, use the ‘-’ symbol like this:

print(2 - 2)

To multiply use the ‘*’ symbol:

print(2 * 2)

To divide, use the ‘/’ symbol

print(2 / 2)

Variables

A variable is like a labelled box that stores information. You can change this information but the label stays the same.

Creating a variable:

To tell the computer what you want your variable to be, you use the = sign. This is called assigning a value to a variable. It’s very simple, here’s an example using fish.

1. Open a new VS Code project and type: fish = 5

Imagine a cat gets hungry and eats two fish. To create another variable for the amount eaten, write the following:

fishEaten = 2

Press enter and then type:

print(fish - fishEaten)

Save and run your code and you should get the answer: 3

Input in Python

You can use the input() function to ask for information from the user.

1. Open a new VS Code project and type:

name = input("What is your name? ")

2. Run the program and you should get the following message:

What is your name? 3. Now let’s try printing your name.

Add the following to your program:

print(name)

You have successfully created an input field!

This can be very useful in creating decision games.

Making Decisions

To write a program that allows you to make decisions the computer needs to react differently to different answers. For this, you need conditions to compare pieces of information, and conditionals to create different paths through the program.

What are Conditions?

A condition is a bit of code that compares two pieces of information. Conditions use operators to make these comparisons. For example, the operator == checks if two pieces of information are the same.

1. Open a new Vs Code project and type:

age = 10
if age == 12:
 print("True")
else:
 print("False")

2. Save and run and you should get False

That is because ‘age’ is set to 10 and not 12

What are conditionals

To use a condition in your code you need a command called a condition. Conditionals use conditions. Conditions show if something is True or False.

IF

One important condition is known as an if statement which tests whether a condition is true. If it is, the computer will follow the instructions after the if statement. If not, the computer will just skip it. In Python, if is a keyword. Dont use it as a variable name because the computer will think that it’s an if statement and get confused.

Implementing the if condition

1. Create a new VS Code project and type the following:

user_reply = ("Do you like python? (Type yes or no) ")

2. Then we will implement the if condition by typing the following:

if user_reply == "yes"
   print("Python likes you to ! ")

ELIF

elif is short for else if. If the conditions of the if code isn’t met it “sweeps up” whatever is left.

3. Now type the following:

elif user_reply == "maybe":
  print("Make up your mind!")

ELSE

When conditions for the if and elif code arent met, else goes into action and “sweeps up” whatever is left.

Let’s implement that: 4. Now type the following:

else:
  print("Well python doesn't like you either")

The complete code should look something like this:

user_reply = ("Do you like python? (Type yes or no) ")
if user_reply == "yes"
   print("Python likes you to ! ")
elif user_reply == "maybe":
  print("Make up your mind!")
else:
  print("Well python doesn't like you either")

Don’t forget to press the tab after if statements.

Randomness in python

In python we can use the random function in order to generate random numbers. This can be extremely useful in a variety of things.

The first thing we will have to do is import the random function

import random

After that we can print out a random number with the following

print(random.randint(1,10))

This will output a random number from 1–10

randint stands for random integer.

Here is the full code.

import random
print(random.randint(1,10))

Loops in python

There are two types of loops in python

1. While loop
2. For loop

While loops only stop when something changes. If it doesn’t change they could go on forever.

With for loops on the other hand you can define exactly when you want them to stop

The most popular example of a while loop is

while True:

Which will run forever eg

while True:
    print("hi")

This will run forever.

With while loops on the other hand you can define exactly how many times you want the loop to run.

for x in range(0,10):
   print("Hi")

This will print Hi exactly 10 times

Guessing game

Now lets combine what learned from above and from our previous articles to create a game

The computer will select a random number from 1–10 and you will have to guess it.

The first thing we will have to do is

import random

After that we will create a variable called number

number = random.randint(1,10)

After that we will create another variable called your_guess

your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))

We are using int as you will have to enter a number

Now we will create a while loop that will keep the game running until you guess the number

while your_guess != number:

The code so far is

import random
number = random.randint(1,10)
your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))
while your_guess != number:
    if your_guess < number:
        print("Your number was too low")
    else:
        print("You number was to high")

And the following

print("GG you found it")

You code should now look like this

import random
number = random.randint(1,10)
your_guess = int(input("Im thinking of a number from 1 to 10, can you guess which one?"))
while your_guess != number:
    if your_guess < number:
        print("Your number was too low")
    else:
        print("You number was to high")
    your_guess = int(input("Please try again... "))
print("GG you found it")

Thats it for now

Stay tuned for more

If you enjoyed this article consider supporting me

PocketBase is an open source backend made in go consisting of embedded database (SQLite) with realtime subscriptions, built-in auth management, convenient dashboard UI and simple REST-ish API.

Install PocketBase

The first thing that you will have to do is head to https://pocketbase.io and select the file for your operating system. Since I am using linux I will show how to set this up on linux but it should be pretty similar for any other os.

Unzip the file and open up a terminal to the path that you extracted the file to and type:

./pocketbase serve

If you want to serve some static content you can create a new directory called pb_public

mkdir pb_public

Then paste any content into that directory

eg.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Epic Website</title>
</head>
<body>
    <h1>My epic website</h1>
</body>
</html>

And save that as index.html inside of the pb_public folder

Now if you head to http://127.0.0.1:8090/ you should see the website that we entered above.

If you go to http://127.0.0.1:8090/_/ it will take you to an admin portal. There you should create a account. After you have setted up your account you should see something like this.

Here you can add and create users

And also create custom collections eg

If you click on the settings icon you can see that you will be able to add applications, mail settings, file storage (s3) , export/import collections, add or remove auth providers, token options and add/remove admins.

That’s it for now if you want to learn more check out https://pocketbase.io/docs/

If you enjoyed this article consider supporting me

What is Monero?

Monero is a decentralized cryptocurrency. It uses a public distributed ledger with privacy-enhancing technologies that obfuscate transactions to achieve anonymity and fungibility. Observers cannot decipher addresses trading Monero, transaction amounts, address balances, or transaction histories.

Monero works like any other currency but with some privacy and decentralization innovations.

Monero uses stealth addresses alongside ring signatures and ring CTs to “hide” the transaction and transaction amounts, enhancing transaction privacy. To further decentralize the network, Monero uses the RandomX algorithm to discourage the use of ASICs.

The Main Problems with Bitcoin and Other Cryptos

Bitcoin may seem like a perfect currency. However, under the hood, Bitcoin has many flaws.

One of the main problems with Bitcoin is that it isn’t actually censorship-resistant. A central bank or government can blacklist your address and block exchanges from accepting it. While there are ways to get around that, it isn’t easy. Monero, on the other hand, is censorship-resistant as it doesn’t display transaction amounts or receivers.

Another problem with Bitcoin and other PoW currencies is that they are actually controlled by a small number of people since they are really hard to mine, among many other factors. Monero is a relatively easy currency to mine and is ASIC-resistant, which makes it even more decentralized as anyone with a computer and an internet connection can start contributing to the network.

Bitcoin has a block size limit, which results in more expensive transactions and longer waiting times. Monero uses a dynamic block size.

Also, Bitcoin has a high block time, which means that transactions take longer to be confirmed and executed. Bitcoin’s block time is ~10 minutes, while Monero’s block time is ~2 minutes.

Bitcoin has halving once every 4 years. The halving halves the amount of mined (printed) Bitcoin in every block. This, by itself, increases price volatility and transaction fee volatility.

Monero has chosen a 0.6 XMR block reward forever. Any good currency wants to have as little volatility as possible. Monero is a currency, not a “number go up coin.”

Conclusion

Monero is basically what people think Bitcoin is. Here’s a great video about it.

Disclaimer

Tech has nothing to do with price. This article reviews the tech of this project and is thus not financial advice. Please DYOR when investing.

Support Me

If you enjoyed this article, consider supporting me:

Monero:

8AztDJtwb7iKaqP4KXRG39VibAacCY1mMfH3bNsVjhYMYbohtT5LKoTSRP6vJGtjeBSPEpFdHZx3ZL3iVowYdkqeQwPAG2o

Ventoy is a free and open-source utility used for writing image files such as .iso, .wim, .img, .vhd(x), and .efi files onto storage media to create bootable USB flash drives. Once Ventoy is installed onto a USB drive, there is no need to reformat the disk to update it with new installation files; it is enough to copy the .iso to the USB drive and boot from them directly. Ventoy will present the user with a boot menu to select one of these files.

With ventoy, you don’t need to format the disk over and over, you just need to copy the ISO files to the USB drive and boot them directly.

Requirements

1. a computer
2. a internet connection (pretty hard without one)
3. a usb (min 8gb)

Installation

Ventoy is available on both linux and windows.

The first thing you will have to do is head to ventoy.net . On the download page select your operating system and click on download.

On linux

After you have extracted the file open the folder and click on the VentoyGUI .

Depending on your processor type select the file ending in either aarch64 i386 mips64el or x86_64. (It will most probably be x86_64).

After that you should see something like this:

Select your device from the devices tab

Then click on install.

On windows

Download the file and unzip it

Then click on the file called Ventoy2Disk.exe

You should see something like this

Select your usb device from the drop down and click on install.

Using ventoy

To use ventoy all you have to do is paste your iso files inside of the usb. No need for formatting etc.

When you boot into your usb you will be prompted which of the iso’s to use. That’s about it.

Enjoy not having to reformat your usb for each iso/OS.

Join my free newsletter!

What is nmap

Nmap (Network Mapper) is a network scanner created by Gordon Lyon . Nmap sends packets and examines the answers to find hosts and services on a computer network. For probing computer networks, Nmap offers a variety of functionalities, including host discovery, service detection, and operating system detection. Scripts that offer more sophisticated service discovery, vulnerability detection, and other features can extend these features. During a scan, Nmap can adjust to changing network conditions, such as latency and congestion.

Installation

Nmap is available for linux, windows , mac os and even bsd

If you are using linux you can install it using your package manager.

On apt

sudo apt install nmap

On dnf

sudo dnf install nmap

With pacman

sudo pacman -S nmap

On windows you have to download the executable from the nmap website.

https://nmap.org/download.html

The same goes for mac and any other os

Getting Started

The first thing I will show you how to do is find all the ip addresses connected to your local network.

The first thing you will have to do is find your inet ip

On Linux type

ip a

On windows

ipconfig

You should see a lot of information, try to find inet. It should look something like this

inet 192.168.1.28/24

and copy the ip

Now type

nmap -sn IP

Instead of ip type the ip we found from above

Now you should see a large list of all the ips connected to your network.

-sn flag stands for no port scan

Now we can also get all the ports open on all the ips on your local network

To do that type

nmap IP

Instead of ip type the ip we found from above

Now if you have any computers on your local networks with open ports you should see them now

Eg.

I have a ssh port open on one of my machines so I can see

PORT   STATE SERVICE
22/tcp open  ssh

If you are running a web server ports 80 and 443 should be open.

Now lets say that you want to find out what operating system a specified device on your network is running.

To do that type

sudo nmap -O IP

Eg.

sudo nmap -O 192.168.1.16

In my case my device is running linux and you can even find out what kernel version your device is running

PORT   STATE SERVICE
22/tcp open  ssh
Device type: general purpose
Running: Linux 2.6.X
OS CPE: cpe:/o:linux:linux_kernel:2.6.32
OS details: Linux 2.6.32

You can press enter while running a scan to see how much time is left

Lets say that you dont want anyone monitoring a network be able to trace back the scan to you.

For that we can use decoy mode

To use decoy mode add -D followed by any random ip to any nmap command.

eg

sudo nmap -D 192.168.1.11 192.168.1.16

This will make it so that it looks like both your ip and 192.168.1.11 are performing a port scan on 192.168.1.16

You can also add multiple ips by adding commas

eg

sudo nmap -D 192.168.1.11,192.168.1.12 192.168.1.16

Thats all for now

GG You have now learnt the basics of nmap ***If you enjoyed this article consider supporting me

What is Github Copilot

GitHub Copilot is an artificial intelligence tool developed by GitHub and OpenAI to assist users of Visual Studio Code, Visual Studio, Neovim, and JetBrains integrated development environments (IDEs) by autocompleting code. Currently available by subscription to individual developers, the tool was first announced by GitHub on 29 June 2021, and works best for users coding in Python, JavaScript, TypeScript, Ruby, and Go.

How does copilot work?

GitHub Copilot is powered by the OpenAI Codex, an artificial intelligence model created by OpenAI. The Generative Pre-trained Transformer 3 (GPT-3) language model, which uses deep learning to create text that resembles human speech, is improved and used in production as the OpenAI Codex.

Github copilot was trained on a selection of the English language, public GitHub repositories, including 59 gigabytes of Python code sourced from 54 million public GitHub repositories.

There still is a lot of controversy about whether GitHub should be allowed to do so, as most open source licences obviously don’t contain anything against analyzing your code with AI and selling it. Also, as AI is analyzing the code base it is not classified as derivative work which seems to be legal. However, it seems quite unethical by Microsoft as Copilot is a paid service that relies on analyzing other people’s code. Read more: https://www.theverge.com/2021/7/7/22561180/github-copilot-legal-copyright-fair-use-public-code

If copilot was free to use it would make a lot more sense as it utilizes FOSS(Free and open sourced software) in order to work. However with Microsoft’s decision to make copilot payed they are monetizing most off GitHub’s code base which is an illegal grey zone.

Analyzing a huge amount of code without any security features has led to many problems like GitHub leaking phone numbers (I even encountered it while testing copilot out).

https://github.com/community/community/discussions/9584?sort=top?sort=top

Last but not least by using GitHub copilot you agree to the ToS which clearly states

GitHub Copilot gives you certain choices about how it uses the data it collects. User engagement data, including pseudonymous identifiers and general usage data, is required for the use of GitHub Copilot and will continue to be collected, processed, and shared with Microsoft and OpenAI as you use GitHub Copilot. You can choose whether your code snippets are collected and retained by GitHub and further processed and shared with Microsoft and OpenAI by adjusting your user settings.

Conclusion

I personally don’t use or will ever use GitHub Copilot or recommend it to anyone for the following reasons:

1. Doesn’t help you learn. Instead does the opposite.
2. Recommends other peoples’ phone numbers, emails and even aws keys. No features have been implemented to stop this as far as I know.
3. Tracks your usage and collects a lot of data. Like Source code that you are editing, related files and other files open in the same IDE or editor, URLs of repositories and files paths.
4. Is paid and proprietary. (You pay to be tracked)
5. Monetizes Open Source Software in an unethical way.
6. Github CoPilot generates vulnerable code 40% of the time

PS if you don’t want GitHub to legally index your code, you could try one of these licenses They might work

***If you enjoyed this article consider supporting me

What You’ll Need

1. A Computer for Your Server: Ideally running Linux (Debian is a solid choice).
2. Internet Connection: Pretty essential for accessing your server remotely.
3. Another Computer with Git Installed: This is what you’ll use to interact with your server.

Step-by-Step Setup Guide

1. Install Git on Your Server

First, you need to install Git on your server. Depending on your Linux distribution, use one of these commands:

• For Debian-based systems (like Ubuntu):

  sudo apt install git
  

• For Fedora-based systems:

  sudo dnf install git
  

• For Arch-based systems:

  sudo pacman -S git
  

2. Create a Git User

Next, create a dedicated user for Git operations:

sudo useradd git

You’ll be prompted to enter some information. Feel free to leave everything blank except for the password.

3. Secure Your Server with SSH Keys

Log in as the new Git user:

su git

Then, enhance security by setting up SSH keys:

mkdir .ssh
chmod 700 .ssh/
touch .ssh/authorized_keys
chmod 600 .ssh/authorized_keys

4. Generate and Add SSH Keys

On your main machine (the one you’ll be committing from), generate an SSH key:

ssh-keygen

Copy the SSH public key to your server:

ssh-copy-id git@your-server-ip

To find your server’s IP, use:

ifconfig

Now, you should be able to log in to your server without needing a password:

ssh git@your-server-ip

5. Set Up Your Git Repository Directory

Create a directory to store your Git repositories. For example:

mkdir ~/git

Give ownership of this directory to the Git user:

chown git:git ~/git

6. Create a New Repository

For each project, create a separate directory:

mkdir ~/git/my_cool_project.git

Initialize the repository as a bare repository (suitable for sharing):

cd ~/git/my_cool_project.git
git init --bare

7. Test Your Setup

To test your new Git server, try cloning the repository from another machine:

git clone git@your-server-ip:~/git/my_cool_project.git

You might see:

warning: You appear to have cloned an empty repository.

That’s because you haven’t added any files yet. Go ahead and add a file:

touch stuff.txt

Commit your changes:

git add .
git commit -m "first commit"

Now, try cloning again, and everything should work smoothly.

Congratulations!

You’ve successfully set up your own Git server! Now you have full control over your code and can collaborate without relying on third-party services.

Enjoyed this guide? Consider supporting me to help me create more content like this!

What is searX?

Searx is a free and open-source metasearch engine, available under the GNU Affero General Public License version 3, with the aim of protecting the privacy of its users. In order to do this, Searx does not provide the search engines from which it receives results with users’ IP addresses or search histories. Tracking cookies served by the search engines are blocked, preventing user-profiling-based results modification.

Users can run private instances of Searx on their own computer, but there are also many public, user-run, Searx instances.

In this article i will show you how to run your own searX instance.

What is a metasearch engine?

A web search engine’s data is used by a metasearch engine, an online information retrieval tool, to create its own results. Metasearch engines automatically query search engines eg Google after receiving user input. The users are shown sufficient data that has been gathered, sorted, and presented.

Requirements

1. An computer (preferably running linux). Check out my article on how to install linux here https://4rkal.medium.com/install-a-debian-server-54add9133eec
2. an internet connection

Installing on windows

To install on windows you will have to install wsl and follow the setup guide for linux bellow

To see how to install wsl head to https://docs.microsoft.com/en-us/windows/wsl/install

Installing on Linux (debian)

First update your system sudo apt-get update && sudo apt-get upgrade Now install required packages sudo apt install -y python3-dev python3-babel python3-venv uwsgi uwsgi-plugin-python3 git build-essential libxslt-dev zlib1g-dev libffi-dev libssl-dev Now you will have to create a new user called searx

sudo -H useradd --shell /bin/bash --system \
    --home-dir "/usr/local/searx" \
    --comment 'Privacy-respecting metasearch engine' searx

sudo -H mkdir "/usr/local/searx"
sudo -H chown -R "searx:searx" "/usr/local/searx"

Now change user to searx

git clone "https://github.com/searx/searx.git" "/usr/local/searx/searx-src"t

Now create a virtual environment

echo ". /usr/local/searx/searx-pyenv/bin/activate" >> "/usr/local/searx/.profile"

To install searx’s dependencies, exit the searx bash session you opened above and restart a new. Before install, first check if your virtualenv was sourced from the login (~/.profile):

Update dependencies

pip install -U pip
pip install -U setuptools
pip install -U wheel
pip install -U pyyaml

Jump to searx’s working tree and install searx into virtualenv

cd "/usr/local/searx/searx-src"
pip install -e .

Now go back to your default user

exit

And type sudo -H mkdir -p "/etc/searx"

Then

sudo -H cp "/usr/local/searx/searx-src/utils/templates/etc/searx/use_default_settings.yml" \
             "/etc/searx/settings.yml"

Now you can edit your settings file

sudo nano /etc/searx/settings.yml

You can change the secret_key

I will change the port and bind_address but you can change whatever you want.

Now log back in to your searx user

sudo -H -u searx -i

Change directory

cd /usr/local/searx/searx-src

Export the settings path

export 
SEARX_SETTINGS_PATH="/etc/searx/settings.yml"

Finally run the web app python searx/webapp.py Now if you head to 127.0.0.1:8888 you should be able to see something like this GG you did it enjoy privacy (in search engines)

*If you enjoyed this article consider supporting me

What is tails?

Tails, or The Amnesic Incognito Live System, is a security-focused Debian-based Linux distribution aimed at preserving privacy and anonymity.It connects to the Internet exclusively through the anonymity network Tor. The system is designed to be booted as a live DVD or live USB, and leaves no digital footprint on the machine unless explicitly told to do so.

What is the tor network?

Tor, short for The Onion Router, is free and open-source software for enabling anonymous communication. It directs Internet traffic through a free, worldwide, volunteer overlay network, consisting of more than six thousand relays,to conceal a user’s location and usage from anyone performing network surveillance or traffic analysis. Using Tor makes it more difficult to trace a user’s Internet activity.

Who is tails intended for?

As the tails website states (https://tails.net). Tails is intended for Activists who use Tails to hide their identities, avoid censorship, and communicate securely. Journalists and their sources use Tails to publish sensitive information and access the Internet from unsafe places. Domestic violence survivors use Tails to escape surveillance at home. You whenever you need extra privacy in this digital world.

Requirements

1. A computer (minimum of 2GB ram , 64-bit x86–64 compatible processor)
2. A usb stick with 8GB+ of space

Read more https://tails.boum.org/doc/about/requirements/index.en.html

Installation

Back up all your files USB files as they will get deleted!

The first thing you will have to do is to head to https://tails.boum.org/install/index.en.html Now select your operating system

Ill walk you through the installation for windows and linux. This should probably bethe same with linux After you have clicked on the windows logo you should be prompted with the requirements and a step by step guide.

The first thing you will have to do is to download the tails usb image.

After that i highly recommend that you verify your download

Just click on select and select it.

Now you will have to download balena etcher. Just click on download balena etcher and double click the installer.

At this moment plug in your usb (if you have any important files on the usb you have to back the up or they will be lost)

Now click the flash from file button and select the file you downloaded (it ends in .img)

Click the Select target button to select your USB stick.

And now select flash.

This could take a while so just sit back and relax.

Using tails

After your installation is finished just reboot your computer and hit F12 or F2 depending on your computer.

Now you should see a screen thats says something like please select your boot device. You will have to select your usb and hit enter

Now you should see the grub loader

Select Tails and hit enter

Now you should be booted into tails

You will probably see a screen that looks something like this

Here you will have to set your language and region. We can also press on the + icon to add a admin password mac address anonymization etc. I will just put the admin password and the unsafe browser. You can select anything you want. However remember that changing some of these settings will make you less anonymous.

Once you are ready select start tails

Now you will see

Here you can select anything you want. I will just select the first option.

Now you should see this:

GG you did it. One more step though

I like to have a persistent volume so that i don’t lose all my files when i reboot. To do that open the configure persistent volume app and follow the steps there.

That’s it for now

*If you enjoyed this article consider supporting me

What is Pi-hole?

Pi-hole is a Linux network-level advertisement and Internet tracker blocking application that acts as a DNS sinkhole and optionally a DHCP server, intended for use on a private network. It is designed for low-power embedded devices with network capability, such as the Raspberry Pi, but can be installed on any Linux machine. Pi-hole has the ability to block traditional website advertisements as well as advertisements in unconventional places, such as smart TVs and mobile operating system advertisements.

Requirements

1. A computer with Linux (preferably something Debian-based)
2. Preferably an Ethernet cable
3. Access to your router’s admin portal
4. A static IP
5. An internet connection (it’s pretty difficult without one, trust me)

Installation

The first thing we have to do is download the installer.

To do that, type:

wget -O basic-install.sh https://install.pi-hole.net

Now, install it with:

sudo bash basic-install.sh

Now you should see something like this:

Just press OK.

Just press OK again.

As I said before, you have to have a static IP in order to set up the Pi-hole, so if you have one configured, just press Yes.

Otherwise, you will have to set one up.

Now you will be prompted to select your upstream DNS provider. You can select any of the DNS providers on the list. I will just select Google.

And press OK.

After that, you will have to select your list. I will just select the default one.

Now you will have to select whether you want a web admin interface. Select On and then OK.

Now just select On and press OK.

After that, you can select if you want to log queries. You can select any option you want.

Now, I recommend that you leave this as default, but you don’t have to.

Now it should start installing everything.

After the installation is finished, you should see something like this:

You have now successfully installed Pi-hole. You can head to the admin portal by going to the specified IP.

To be able to use Pi-hole, you have two options:

1. Make the IP the default DNS for your whole network
2. Manually add it on any device

I’ll go with the second option.

On Windows:

DNS settings are specified in the TCP/IP Properties window for the selected network connection.

1. Go to the Control Panel
2. Click Network and Internet > Network and Sharing Center > Change adapter settings
3. Select the connection for which you want to configure
4. Right-click Local Area Connection > Properties
5. Select the Networking tab
6. Select Internet Protocol Version 4 (TCP/IPv4) or Internet Protocol Version 6 (TCP/IPv6)
7. Click Properties
8. Click Advanced
9. Select the DNS tab
10. Click OK
11. Select Use the following DNS server addresses
12. Replace those addresses with the IP addresses of your Pi
13. Restart the connection you selected in step 3
14. Repeat the procedure for additional network connections you want to change

On Linux:

In most modern Linux distributions, DNS settings are configured through Network Manager.

1. Click System > Preferences > Network Connections
2. Select the connection for which you want to configure and press Edit
3. Select the IPv4 Settings or IPv6 Settings tab
4. If the selected method is Automatic (DHCP), open the dropdown and select Automatic (DHCP) addresses only instead. If the method is set to something else, do not change it.
5. In the DNS servers field, enter your Pi’s IP addresses
6. Click Apply to save the changes

Warning: If you are not using Network Manager, your DNS settings are specified in /etc/resolv.conf.

Now, if we head over to any websites with ads, you should see that no ads appear.

Let’s try speedtest.net.

If you have followed the steps correctly, you should see something like this:

NO ADS

Enjoy the ad-free web.

If you enjoyed this article, consider supporting me.

SSH Password Based VS Key Based Authentication

Clients can be authenticated by an SSH server in a variety of ways. The most basic is password authentication, which is simple to use but not particularly secure. The more advanced and secure way is via ssh keys.Brute-forcing a password-protected account is quite possible thanks to modern computing power and automated scripts. The solution to that is ssh key based authentication.

How does Key Based Authentication work?

SSH key pairs are two cryptographically secure keys that allow a client to connect to an SSH server. A public key and a private key make up each key pair.The client keeps the private key, which should be kept completely confidential.

If the attacker has access to the private key, they will be able to enter into servers using the corresponding public key without requiring further authentication. A passphrase can be used to encrypt the key on disc as an extra precaution.

The related public key can be freely shared without causing any harm. The public key can be used to encrypt communications that can only be decrypted with the private key. This attribute is used to verify the authenticity of the key pair. The public key is placed on a distant server that you wish to use SSH to access. The key is saved in a special file called /.ssh/authorized keys in the user account you’ll be login into.

When a client uses SSH keys to authenticate, the server can check if the client has the private key. A shell session is started or the requested command is executed if the client can verify ownership of the private key.

Setting up

The first thing we will have to to do is generate an SSH key pair on your local computer.

To do that type

ssh-keygen

You should see something like this

Generating public/private rsa key pair.
Enter file in which to save the key (/home/4rkal/.ssh/id_rsa): 
Enter passphrase (empty for no passphrase):

If you want to you can enter a passphrase to encrypt the private key.

After that your key should be generated.

Now you will have to copy your public key to your server.

To do that type

ssh-copy-id username@host_ip

(find your servers ip by typing ifconfig in your server)

eg.

`ssh-copy-id server@192.168.1.13'

Try to ssh into your server by typing

ssh username@host_ip

You should be able to login into your server without the password. However, brute force attacks continue to threaten your server. Now we have to disable password based authentication.

First login to your ssh server by typing ssh username@host_ip

Now we have edit the ssh config

sudo nano /etc/ssh/sshd_config

You should see a large file that starts with

#       $OpenBSD: sshd_config,v 1.103 2018/04/09 20:41:22 tj Exp $

At this point press cntrl w and search for PasswordAuthentication

Uncomment the line that says

#PasswordAuthentication yes

And change it to

PasswordAuthentication no

Now press cntrl s to save and cntrl x to exit

After that restart the ssh service with

sudo service ssh restart

Now try to ssh into your server from another machine or a vm and you should see something like this

server@192.168.1.13: Permission denied (publickey)

GG you have now secured your server

*If you enjoyed this article consider supporting me

What is Tor?

Tor — short for the Onion Routing project — is an open-source privacy network that enables anonymous web browsing. The worldwide Tor computer network uses secure, encrypted protocols to ensure that users’ online privacy is protected. Tor users’ digital data and communications are shielded using a layered approach that resembles the nested layers of an onion.

Why use Tor?

Tor is useful for anyone who wants to keep their internet activities out of the hands of advertisers, ISPs, and websites. That includes people getting around censorship restrictions in their country, people looking to hide their IP address, or anyone else who doesn’t want their browsing habits linked to them.

The Tor network may also host webpages that only other Tor users can view. In other words, you’ve entered the Dark Web, which consists of websites that aren’t indexed by the standard crawlers you use to look for products to purchase, and quiz answers etc . On the Dark Web, you can discover everything from free textbooks to drugs — and worse — as long as you know the secret URL that leads to these sites.

Tor Websites

Just like any other website, you will need to know the address of an onion service in order to connect to it. An onion address is a string of 56 mostly random letters and numbers, followed by “.onion”.

Requirements

1. A linux machine (debian preferably)
2. An internet connection (pretty hard without one,trust me)

Installation

The first thing we will have to do is install Tor

apt install tor

Now we will have to enable tor hidden service(which is the website) for that type:

sudo nano /etc/tor/torrc

You should see a large configuration file, search for HiddenService

You will have to uncoment:

#HiddenServiceDir /var/lib/tor/hidden_service/
#HiddenServicePort 80 127.0.0.1:80

Now press cntrl s and then cntrl x to exit

After that start the tor service by running

sudo service tor start

or

sudo systemctl start tor

Now we also have to install nginx to be able to run our website to do that type

sudo apt install nginx

Start the nginx service with the systemctl or service command

Now we also have to install nginx to be able to run our website to do that type

sudo cat /var/lib/tor/hidden_service/hostname

You should see a address that looks something like this

tiur7p652svsaemdewbsxnnkrj3b35ny2rx454od5wk5ivfqhijm2qd.onion

Now open your tor browser and paste your address and press enter.

You will most probably be greeted by the default nginx site.

This page is easily customized, you can check out my article: here

GG you did it you are now running a pretty anonymous website on the tor network.

*If you enjoyed this article consider supporting me

What is open sourced software?

Open-source software is computer software that is distributed under a license that allows users to use, study, modify and distribute the program and its source code to anyone and for any purpose. Open-source software may be created in a public, collaborative environment. Open-source software is a good example of open collaboration since it allows any skilled user to engage in development online.

“Certainly there’s a phenomenon around open source. You know free software will be a vibrant area. There will be a lot of neat things that get done there.” -Bill Gates

Why open source?

There are several advantages to using open-source software.

1. Trust. One of the most important advantages is trust. As users can examine your code and make sure its not doing anything they don’t want it to. They are also able to change things they don’t like. Most cryptocurrency projects are open sourced to be able to develop trust with their community.

2. Community A open source community allows more developers to build around the project . Bitcoin is the greatest example of such a community. As soon as bitcoin source code was published many utilities for bitcoin were made like wallets and more which would never have been made if bitcoin wasn’t open sourced.

3. Transparency Anyone can read your source code and see if they want it to do what it is doing. That way your company gains a lot of trust.

“Talk is cheap show me the code” Linus Torvalds

4. Continuous evolution Your project will continue to be developed even if you give up on it. Again the greatest example for this kind of project is bitcoin. Even though the founder of bitcoin has vanished for more than 10 years, cryptocurrency technology is “changing” the world.

5. Lower Development costs (For companies) You can reduce your costs by using open source software. You can save money on licensing and maintenance. The only costs you’d have to deal with are those for documentation, media, support etc.

6. Controll With open source YOU are ultimately in controll. If you dont like something you can modify the source code to your liking.

If you enjoyed this article consider supporting me

Requirements

1. A computer or microcomputer to host the website
2. The computer needs to run linux
3. An internet connection (Its pretty hard without one, trust me)

Lets get started!

Installation

The first thing that we will have to do is setup our nginx site.

We first have to be root

sudo su

If you dont have sudo installed try:

su -

Now we will have to install nginx

apt install nginx

If you are using any other package manager install it using the package name nginx

Now we will have to start the nginx service

systemctl start nginx

or

service nginx start

Lets find your ip with:

ip a

or

ifconfig

If you open a web browser and go to your ip you should see the default welcome to nginx site.

Since we want to make our website as secure as possible we can hide the nginx version

To do that type

`sudo nano /etc/nginx/nginx.conf

Now you should see the nginx configuration file.

under

http {
##
        # Basic Settings
        ##
sendfile on;
        tcp_nopush on;
        types_hash_max_size 2048;
        # server_tokens off;

uncomment server_tokens off;

Now restart your nginx service

systemctl restart nginx

We can now enter our html files inside of /var/www/html

To do that type:

cd /usr/share/nginx/html

and now we can create the index.html file

nano index.html

and paste/write your html code to index.html

Now restart the nginx service again

systemctl restart nginx

Certbot

Now we will install cerbot in order to get https

To install certbot simply type

apt install certbot python-certbot-nginx

Now we will have to run certbot

certbot --nginx

Enter all the inf oand agree to the terms

After that you will have to enter the name you would like to activate https for

Just select the names

After that select to redirect http to https

Port forwarding

There are a few ways to port forward. In this article we will use noip.com.

Head over to noip.com to get started (Use my referal https://www.noip.com/?fpr=4rkal)

Create an account and register a hostname

After that we will have to build the noip client on our computer for that paste these commands to your terminal

cd /usr/local/src
wget http://www.no-ip.com/client/linux/noip-duc-linux.tar.gz
tar xzf noip-duc-linux.tar.gz
cd noip-2.1.9–1
make
make install

When you run make install you will be prompted to answer some questions like your login information and the update interval

In the update interval just set it to 30

Then if you don’t want to run something at a successful update type n if you do then type y.

You will now also have to edit the nginx default settings

to do that type

`sudo nano /etc/nginx/sites-available/default

Now you will have to change the server_name to the domain you registered at noip.com

You can check if your configuration was successful by running

nginx -t

You can now restart the nginx service

systemctl restart nginx

Now if you head to your domain it should be working and ssl should be installed

*If you enjoyed this article consider supporting me

Requirements

1. Raspberry pi or any other computer
2. Web cam
3. Any kind of debian based distro installed on the pi/computer

Setup

In this article we will be using the motion package (https://motion-project.github.io/)

To get started power on your raspberry pi and ssh into the machine or just connect it to a monitor and a keyboard. Also connect your web cam to the raspberry pi usb port.

The first thing we will have to do is install motion, for that type the following command:
apt install motion
Now start motion with:
systemctl start motion
or
service motion start
Now we are going to change some of the default settings . To do that type:
nano /etc/motion/motion.conf
The first thing that we are going to change is
webcontrol_localhost off
This will enable us to access the stream from other computers.

To view the stream run:

motion

If you get a permission denied error try running

sudo motion

If you got to http://YOUR_IP:8080 you should see a live feed of the web cam

You can change the port under webcontrol_port in the config file eg. webcontrol_port 1234

If you only want the live stream port you can go to http://your_ip:8081

Again you can change that under stream_port.

Now everything should be working fine. All motion detection files will be saved in /var/lib/motion

You can also change loads of other settings. Here are my settings:https://pastebin.com/WGn0NfcW

Read the documentation here: https://motion-project.github.io/motion_guide.html

*If you enjoyed this article consider supporting me

1. The transport layer
2. The connection layer
3. The authentication layer

During and after authentication, the transport layer establishes safe and secure communication between a client and a server. It is in charge of data encryption, decryption, and integrity assurance. It also provides data compression and caching, which helps to speed up data communication.

The authentication layer informs the client about the available authentication methods. It’s also in charge of the whole user authentication procedure.

After the authentication is successful, the connection layer oversees the communication between the machines. It manages communication channel opening and closure, as well as multiple channels for multiple sessions.

Session Encryption

The server sends the client a list of supported encryption protocols after receiving a connection request. The public key is used by the server as an authentication technique.

The client compares the protocols to the ones it already knows. If there are two protocols that are compatible, the machines agree to use one of them to establish the connection.

On the first connection attempt, the client compares the server’s public key to the private key saved in its system. If the keys are identical, the client and server agree to communicate using symmetric encryption during the SSH session. They communicate utilizing an asymmetrically encrypted mechanism based on the Diffie-Hellman (DH) key exchange algorithm for this purpose. There are different ciphers that can be used for SSH depending on the applications being used. Some of them include:

• CHACHA20
• AES-GCM
• Blowfish-CBC
• AES128-CTR
• AES192-CTR
• AES256-CTR
• Arcfour
• Cast128-CBC

Different Encryption Techniques

SSH uses a variety of data manipulation techniques at various points in the transaction to ensure the security of information transmission. These include symmetrical and asymmetrical encryption, as well as hashing.

Symmetrical Encryption

Symmetric encryption creates a single key that is exchanged between two machines. The key is then used by the machines for both encryption and decryption. This approach is rapid and resource-light, and it is used by SSH for each session. When the client and server are deciding which algorithm to employ for an SSH session, the first algorithm on the client’s list that the server supports is always used.

Asymmetrical Encryption

Any party can have access to the public key. Although it is linked to its paired key, the private key cannot be deduced from the public key. The public key and private key have a mathematical relationship that allows the public key to encrypt messages that can only be decrypted by the private key. This is a one-way ability, which means that the public key cannot decode the communications it sends or decrypt anything the private key sends it.

The private key should be kept completely confidential and never shared with anybody else. This is a necessary condition for the public key paradigm to function.The only component that can decrypt communications encrypted with the accompanying public key is the private key. Any entity capable of decrypting these messages has demonstrated control over the private key as a result of this fact.

Hashing

r key defining characteristics are that they are never supposed to be reversed, that they are nearly hard to predictably alter, and that they are practically unique.

If you use the same hashing function and message, you should get the same hash; if you change any part of the data, you should get a completely different hash. A user should not be able to deduce the actual message from a hash, but they should be able to determine whether a message produced a hash.

Session Encryption Negotiation

The server sends the client a list of supported encryption protocols after receiving a connection request. The public key is used by the server as an authentication technique.

The client evaluates the protocols in comparison to its own. The machines choose one to create the connection using if there are any compatible protocols.

On the initial connection attempt, the client checks the server’s public key to the saved copy of its own private key. The client and server consent to using symmetric encryption to communicate during an SSH session if the keys match. They converse utilizing an asymmetric encryption method that makes use of the Diffie-Hellman (DH) key exchange algorithm.

Using a public network, machines can safely collaborate to build a cryptographic key thanks to the DH algorithm. The machines go through the following processes to create a key:

• The machines agree on two numbers: a modulus and a base number. To prevent brute force key decryption, the chosen modulus is a prime number of at least 600 digits.
• In order to solve the equation involving the two public numbers, the machines independently select one number.
• The calculated values are exchanged between the server and the client.
• Now, utilizing the information obtained from the other machine, each machine computes something.

By carrying out the above processes, both machines determine the identical value, which is their secret key. The server then makes an attempt to verify the user’s identity who made the access request.

***If you enjoyed this article consider supporting me

In this tutorial, we’ll learn how to use Python and Selenium to automate a web browser. This is an updated version of my previous article which unfortunately doesn’t work anymore. If you’re a complete beginner, read my python article to understand the basics. (https://4rkal.com/posts/python/)

What is selenium?

Selenium is an open source umbrella project for a range of tools and libraries aimed at supporting browser automation. You can use selenium in multiple programming languages including JavaScript (Node.js), C#, Groovy, Java, Perl, PHP, Python, Ruby and Scala and with multiple web browsers including firefox, internet explorer, safary, opera, chrome and edge. Selenium can be very useful for web scraping, automating boring and manual tasks and so much more.

Setup

To install selenium you first have to install a browser driver. Here is the list of supported web browsers :

• Firefox
• Internet Explorer?
• Safari
• Opera
• Chrome
• Edge In this article we will be using firefox geckodriver. But you can use any of the browser drivers above.

Downloading geckodriver

To get started go to github.com/mozilla/geckodriver/releases Scroll down and select the package for your computer. I’ll use geckodriver-v0.31.0-linux64.tar.gz because I’m using a linux 64-bit computer.

Installing geckodriver

The setup varies depending on your operating system.

If you are using Arch Linux: You can install geckodriver from the aur. Using your favourite aur helper

On linux:

1. Unzip the file
2. Make the file executable chmod +x geckodriver
3. Add the driver to your PATH so other tools can find it: export PATH=$PATH:/path-to-extracted-file/ On windows:
4. Unzip the file
5. Paste the file in the directory that your script will run

Installing selenium

To install selenium you have to have python and pip installed.Check out my article on python for more To install selenium open your cmd or terminal and type:
pip install selenium That should install it.\

Basics of selenium

The first thing we have to do is to create a new file with the .py ending eg. main.py
After you have created it open it in your ide or editor of choice.\

The first thing that we have to do is to import the selenium webdriver : from selenium import webdriver
After that we have to specify what webdriver we are using. In our case its firefox browser = webdriver.Firefox()
Now we need to specify the url that we want it to go to eg python.org

browser.get('https://python.org')
The full code so far is:\
import selenium
from selenium import webdriver
browser = webdriver.Firefox()
browser.get('https://python.org')

Now we might want it to click on the Downloads button

There are a few ways to do this

Method 1 of clicking a button

The first is with XPATH
To find the xpath of a button / object on a website you have to open your web browser go to the desired website and hit F12 to get the development tools. Now you should click on the select tool (See below) Click on it and after that hover above the downloads button with your mouse and click it. After that you should see a bit of code getting highlighted. Right click on the bit of code and select Copy then select Xpath Now go back to the python file and type:
driver.find_element(By.XPATH, 'XPATH_HERE')
This will throw an error, to fix that error simply add this at the top of the file
from selenium.webdriver.common.by import By
Your code so far should look like this

import selenium
from selenium import webdriver
from selenium.webdriver.common.by import By
browser = webdriver.Firefox()
browser.get('https://python.org')
browser.find_element(By.XPATH, '/html/body/div/header/div/nav/ul/li[2]/a').click()

Method 2

XPATH with text The second method is a bit simpler but not as reliable as the first as there might be many objects with the same name.
To use this method type: browser.find_element(By.XPATH, "//*[contains(text(), 'Downloads')]").click() Your code should look something like this

import selenium
from selenium import webdriver
from selenium.webdriver.common.by import By
browser = webdriver.Firefox()
browser.get('https://python.org')
browser.find_element(By.XPATH, "//*[contains(text(), 'Downloads')]").click()

. . . . .

There many methods on how to locate elements but the above i believe are the easiest. The methods are the following

• By.ID
• By.NAME
• By.XPATH
• By.LINK-TEXT
• By.TAG_NAME
• By.CLASS_NAME
• By.CSS_SELECTOR\

Read more here: https://selenium-python.readthedocs.io/locating-elements.html

Typing text into input fields.

Typing text into input fields is pretty straight forward.
For that we will use any of the above methods. I’m going to use xpath.
Find the xpath of any input field, I’m going to use the google.com search field
Copy the xpath and type:
a = browser.find_element(By.XPATH, "XPATH_HERE") Paste the xpath in XPATH_HERE

To send keys we need to import the selenium.webdriver.common.keys library for that paste this line of code at the top of your file
from selenium.webdriver.common.keys import Keys
Now type:
a.send_keys("python")
After that we want to press the enter key for that type:
a.send_keys(Keys.RETURN)
The full code should look something like this:

import selenium
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
browser = webdriver.Firefox()
browser.get('https://google.com')
a = browser.find_element(By.XPATH, "/html/body/div[1]/div[3]/form/div[1]/div[1]/div[1]/div/div[2]/input")
a.send_keys("python")
a.send_keys(Keys.RETURN)

GG you just automated your first google search! You might first need to accept cookies for that just follow the steps on how to click a button from above.
Read more about selenium here: https://selenium-python.readthedocs.io/\

*If you enjoyed this article consider supporting me

Here is a screenshot of it in python3

Your first thought might be that this is just some kind of error. Well its not

Why does this happen?

Fractions can be represented precisely in the base 10 system (used by humans) if a prime factor of the base is used (10).

• 2 and 5 are the prime factors of 10.
• 1/2, 1/4, 1/5 (0.2), 1/8, and 1/10 (0.1) can be expressed precisely as a result of denominators use prime factors of 10.
• Whereas, 1/3, 1/6, and 1/7 are repeating decimals as a result of denominators use a prime factor of 3 or 7. On the other hand, fractions can be represented precisely in the base 2 (binary) system (used by computers) if a prime factor of the base is used.
• 2 is the only prime factor of 2.
• So 1/2, 1/4, 1/8 can all be expressed precisely because the denominators use prime factors of 2.
• Whereas 1/5 (0.2) or 1/10 (0.1) are repeating decimals. When you perform math on these repeating decimals, you end up with leftovers which carry over when you convert the computer’s base-2 (binary) number into a more human-readable base-10 representation.

Read more: 0.300.com Wikipedia:
https://en.wikipedia.org/wiki/Floating-point_arithmetic

If you enjoyed this article consider donating