Forem: David MM👨🏻‍💻

Security auditing your Linux OS with Lynis

David MM👨🏻‍💻 — Mon, 29 Jan 2024 12:15:53 +0000

System hardening is a hard (hah!) thing to do: Every computer has loads of vulnerabilities that can compromise our security. From SSH brute-force attacks to weak passwords, misconfigurations, etc. Keeping track of each potential vulnerability is a difficult thing to do unless we use things like Lynis.

Table of contents

Introduction: What is hardening?

What is Lynis?

Downloading and running our first test

Fixing our vulnerabilities

Testing our system after fixing it

Final thoughts

Resources

Introduction: What is hardening?

Systems hardening is the process of securing a computer system or network by reducing its vulnerabilities and minimizing potential attack surfaces. The goal of systems hardening is to improve the overall security of a system, making it more resistant to various cyber threats and attacks. This involves configuring and managing the hardware, software, and network components in a way that minimizes security risks.

And we can do it easily with Lynis.

What is Lynis?

Lynis is an open-source security auditing tool for Unix-based systems. First, it runs a series of tests and checks on your system and its configuration, then it gives you a score (from 0 to 100) based on your hardening level.

Then, it gives you a series of recommendations and tips to improve it even further.

Let's give it a try! First, we will download Lynis, run a first test, follow their recommendations, and then run another test to see if it improved our hardening index.

Downloading and running our first test

First, we will clone the GitHub repo:



git clone https://github.com/CISOfy/lynis.git

Then, we will move to the lynis folder, then run our first test:



./lynis audit system --quick

We ran our test on a new Ubuntu Server 22.04.3 LTS computer. It is just a fresh install, where we only did sudo apt update && sudo apt upgrade -y, so no configurations nor hardening has been applied to it yet.

After a minute or two, we will have a hardening score and a few recommendations about how to improve our score.

As you can see, our score is only XX/100. That's too low! We need to pump those numbers up. If we scroll up or read the newly created /var/log/lynis-report.dat report file, we have a few suggestions and tips about how to fix them.

Fixing our vulnerabilities

Then, let's fix them!

Let's pick a few misconfigurations and fix them. For example, the SSH-7408, tell us how to properly configure SSH to reduce known vulnerabilities:

Let's edit /etc/ssh/sshd_config with the following values:

Nice. This would improve our hardening score for sure. But if we remember, we had other vulnerabilities:

This is an easy one. apt-show-versions is a Linux package that lists all available package versions with distribution. That's it. You just install this package, and then you improve your security.

Let's go for another one:

Seems like we don't have a minimum nor a maximum password age: This lets the users use the same password for years without changing it. If the password gets compromised, as they don't change it, an attacker could use it indefinitely. Let's also make umask (related to permissions) more strict.

Let's fix this problem by setting a minimum and maximum password age, and also restricting umask in the /etc/login.defs file:

That would do it!

Testing our system after fixing it

We have hardened our SSH, installed a package, improved the password's ageing controls and more.

Could this have improved our starting 63/100 score?

It did! The hardening index increased its score by 10 points with just 5 minutes of hard work!

Yes, there is still work to do (or less work, if you use scripts to automate the hardening process), but now our computer is more secure and harder to crack!

Final thoughts

Lynis and systems hardening are crucial elements in improving cybersecurity. Lynis, as a security auditing tool, identifies and addresses vulnerabilities, offering recommendations for system fortification. By regularly running Lynis audits we can keep our systems updated.

Lynis minimizes a system's attack surface, creating a robust defence strategy by mitigating or even removing known vulnerabilities and common security weaknesses, improving the overall security of your operating system, and reducing the risk of security breaches.

And, as you saw, it is pretty addicting, as you want to keep increasing your score more and more!

Resources

Creating our own Docker images

David MM👨🏻‍💻 — Mon, 15 Jan 2024 08:31:10 +0000

After learning the Docker basics, it is time to create our images. Creating our own custom Docker image allows us to have more control over application configurations, dependencies, security, and more. And it is easy and fun. Get ready for it!

Table of contents

Introduction

Doing the process steps manually

Creating our Docker image

Making public our Docker image

Final thoughts

Resources

Introduction

Custom Docker images give us control over application configurations and dependencies, improving security, and performance. We can create a custom Docker image tailored to our own needs, with the dependencies we want, and the code we want.

For example, we want everybody in our dev team to use Ubuntu 20.04 with Apache and the code in one GitHub repo. We could create a custom Docker image, upload it and tell everybody in the dev team to work using that image.

No more dependencies problem, no more "I don't know how to install X" and, especially, no more "But it works on my computer".

We just need to create one image packaged with all we need, that executes every step we want.

Doing the process steps manually

One tip before creating our own custom Docker image is to do the process manually: We get a clean Linux system (A Virtual Machine created with Vagrant it is the easy way as you can use the image and discard it later) and we run the commands we want.

Using a process of trial and error, we install and configure everything we want until it is done. We will repeat these steps on our Docker image.

For this, of course, you need to have Docker installed (and, if not, here's how to Install Docker with 3 easy steps).

Let's start then!

We want to run a Flask web application inside an Ubuntu OS. The steps we want to do are:

Install Ubuntu
Update and upgrade Ubuntu
Install Python and its installer
Install Flask dependency
Copy our Python code
Run the Flask web application

So, let's start!

First, let's download a Docker image, then create a container using that image, and run the bash terminal:

docker run -it ubuntu bash

Now we are in the container's terminal as a root. Let's install all our dependencies:

apt update
apt upgrade -y
apt install -y python3
apt install python3-pip
pip install flask

Now we have everything we need to run our code. You can create a Flask app, search for one on GitHub that you want to use, or just use an application I have created for this tutorial.

Copy the code and paste it inside /opt/app.py.

cat > /opt/app.py

import os
from flask import Flask

app = Flask(__name__)


@app.route("/")
def main():
    return "Welcome!"


@app.route("/How are you")
def how_are_you():
    return "I'm fine, how about you?"


@app.route("/about")
def about():
    return "I'm just a small Flask app :)"


@app.route("/info")
def info():
    return "I have been created just to pass Pau's subject."


if __name__ == "__main__":
    app.run()

Everything is set, time to run the server!

FLASK_APP=app.py flask run --host=0.0.0.0

Now we can visit the URL in our Browser:

Creating our Docker image

We have our server running perfectly. Now, we want to reproduce the same steps in a Docker image so we can distribute it.

First, close everything and check the container isn't running:

docker ps

Now, let's create a folder for us to work in. Inside, create a Dockerfile (A text document that contains all the commands we want to run) where we will create a script to do all the steps we did before:

mkdir app_flask
cd app_flask

sudo vim Dockerfile

FROM ubuntu
RUN apt update
RUN apt upgrade -y
RUN apt install -y python3 python3-pip
RUN pip install flask
COPY app.py /opt/app.py
ENTRYPOINT FLASK_APP=/opt/app.py flask run --host=0.0.0.0

Now we can run Docker build to run the script and create a Docker image. But before, as we see in the COPY line, we need to have our script in the same folder. Copy it or just download it with wget:

wget https://raw.githubusercontent.com/david1707/flask-app/main/app.py

docker build . -t david1707/app-flask-caminas

Remember to change the image's name, following the convention of <YOUR_NAME>/<IMAGE_NAME>.

After a few minutes (it took me 6), you have your custom Docker image:

Making public our Docker image

Now we can distribute the Dockerfile and everybody will have the same image, with the same dependencies. But we can publish it in one Docker repo (for example, in Docker Hub). Very much like GitHub, everybody could download your image and use it on their computers.

You have to register in Docker Hub first, and then push it to the repo:

docker push david1707/app-flask-caminas

Now anyone can use your image with:


docker run david1707/app-flask-caminas

This will download the image, if it isn't on our computer, and run it. Now, we can visit the browser using the URL given:

Final thoughts

Creating our own Docker images is pretty easy. We just need the basics of using the terminal, then we can replicate all the steps in a Dockerfile to create our images, even distributing them via Docker Hub.

The benefits of using our own custom Docker files are:

Customization: Creating and using your own Docker images allows for tailored configurations, ensuring that the image contains specific dependencies, settings, and optimizations that align with the requirements of your applications.
Security Compliance: By building and managing your own Docker images, we have direct control over the inclusion and configuration of security measures.
Reduced Image Size: Customizing Docker images allows for the elimination of unnecessary components, resulting in smaller image sizes. Smaller images lead to faster deployment times and more efficient resource utilization.
Flexibility and Specialized Tooling: Building our own Docker images provides the flexibility to incorporate specialized tooling or unique requirements specific to your organization's workflows. This customization lets teams create and deploy applications with the exact environment they need for optimal performance and functionality.

Resources

Original post

Docker basics for beginners

Install Docker with 3 easy steps

GitHub: Flask App

GitHub

Docker hub

Docker basics for beginners

David MM👨🏻‍💻 — Wed, 10 Jan 2024 22:06:30 +0000

In my latest post, I talked about Vagrant and how it can help us to create Virtual Machines in minutes, but what if can do it even faster, better and more customizable? Let's learn how we can develop, deploy and run applications easily with Docker!

Table of contents

Introduction

Docker vs Virtual Machines

Installation

Basic commands

An example: Jenkins container

Data persistence

Data persistence-with volumes

Final thoughts

Resources

Introduction

If you Google Docker, you will find that Docker is a software platform that uses an OS-level virtualization to create self-contained containers.

Luckily here, I will explain to you what that means in simple English.

You may have created multiple Virtual Machines with Oracle VM or Vagrant before. Docker is something like that (but better, but more about that later).

With Docker, we select an image (think about Docker images as recipes) and download it. Then, we create an instance of that image or container, pretty similar to a Virtual Machine.

Image:

A package or template used to create one or more containers

Container:

Instances of an image, isolated from each other, with their own environment.

But let's see it in action. This is a docker image code:

FROM ubuntu:23.04 RUN apt-get update RUN apt-get install -y curl nginx

Remember what I said about a Docker image being a recipe? In this image or recipe, Docker gets the Ubuntu 23.04 version, updates the SO, and then installs curl and nginx.

Granted, this is a short Docker image version, but it helped us to visualize what Docker is about.

Now, with this image, we can create a container (imagine a Virtual Machine) and it will create a Linux Ubuntu VM-like already updated, with curl and nginx.

And all the developers in our company can use the same image to have the same programs, packages, and versions installed. No more "Bu...but it works on my computer!"; now every computer has the same specifications.

Docker vs Virtual Machines

But...if Docker creates a container that is VM-like, why don't we use just Virtual Machines?

I could explain how Docker containers are better than Virtual Machines on a low-level way, maybe even snatch some cool infographics from another site like this one and explain that Docker uses the same kernel for every container, making it light-weight and fast, only taking a few seconds to spin one container:

But there is one big benefit of using Docker and Docker containers:

Imagine you want to develop a 21.1 NodeJS: You create your own Docker image, where you get an Ubuntu image, update it, install all the NodeJS-related stuff, and then distribute the image to the developing team.

In a normal setting, you have to upload the NodeJS application, deploy it on your server and you have to make sure that the server has all the dependencies and its NodeJS is compatible with yours.

And you don't want to bet on that.

With Docker, we can create a Docker image, upload it to a Docker-compatible server and that's it.

The Docker server doesn't care about what Linux you use, what packages installed, or what it is your app's language: It only needs to run the image. That's it.

Let me emphasize this: We don't care what the server has installed. We upload and run the Docker image. That's all we have to do.

Installation

You can install Docker Desktop, a GUI Docker app, but we, rugged and tough developers use proper terminal stuff, so you will install Docker Engine, the terminal version of Docker.

Jokes aside, you can install whatever you want: Docker Desktop or Docker Engine, just make sure you are following your OS's instructions. For example, for Debian-based distros such as Ubuntu:

Uninstall previous Docker versions

sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras sudo rm -rf /var/lib/docker sudo rm -rf /var/lib/containerd

Install Docker
curl -fsSL https://get.docker.com -o get-docker.sh sudo sh ./get-docker.sh

Check that Docker is installed
sudo docker version

Let's run a test. Run the following command in your terminal:

sudo docker run docker/whalesay cowsay boo

Important: Every Docker command needs sudo permission. You can add a user to the docker group, but despite that, it still keeps asking for sudo permission. I have found that by running the command sudo chmod 666 /var/run/docker.sock , you don't get asked for sudo permissions any more (You can use a similar command, like chmod +x).

Basic commands

We have Docker up and running. Let's see a few basic commands. Your bread and butter if you want:

List all images
docker images

Download or execute a container from an image
docker run <IMAGE_NAME>

Download a specific version
docker run <IMAGE_NAME>:<VERSION>

Execute a container in the background
docker run -d <IMAGE_NAME>

Bring a container from the background to the foreground
docker run attach <ID>

Execute a command
docker run ubuntu cat /etc/*release* docker run ubuntu sleep 15

Download an image to run it later
docker pull <IMAGE_NAME>

Execute a command inside the docker container
docker exec <COMMAND>

Connect to the container's bash
docker run -it <IMAGE_NAME> bash

List all running containers
docker ps

List ALL containers, running or not
docker ps -a

Run a container with a link to other container:
docker run -p <PORT_LOCAL>:<PORT_DEFAULT> --link <IMAGE_NAME_TO_LINK>:<IMAGE_NAME_TO_LINK> <IMAGE_NAME> docker run -p 5000:80 --link redis:redis voting-app

Get details from an image or container in JSON format
docker inspect <NAME_OR_ID>

Get logs from a container running in the background
docker logs <NAME_OR_ID>

Get all the layers from an image
docker history <IMAGE_NAME>

Stop a container
docker stop <IMAGE_NAME_OR_ID>

Remove permanently a container
docker rm <IMAGE_NAME_OR_ID>

Remove permanently an image that isn't being used
docker rmi <IMAGE_NAME>

Build an image from a Dockerfile
docker build . -t <NAME>

Environment variables
docker run -e <VARIABLE>=<VALUE> <IMAGE_NAME> docker run -e APP_COLOR=blue simple-webapp-color

An example: Jenkins container

Let's use a real-life example: Using a Jenkins container.

In future posts, I will talk more in-depth about Jenkins and what it does, but Jenkins is a great DevOps CI/CD tool. Let's download Jenkins and run it on our computer:

docker run jenkins/jenkins # This downloads and runs jenkins docker ps # Get the container ID and port docker inspect <CONTAINER_ID> # Get the container IP

Open a Browser in your VM using :
docker run -p 8080:8080 jenkins/jenkins # Map the port

Open a Browser in your Host machine using :

Here, we are installing and downloading a Docker image in our Ubuntu Virtual Machine and running it. We can view Jenkins in our VM by opening a Browser and using the Docker container's IP and port, but by mapping the port we can open Jenkins in our Host computer.

The structure is:

Host with Windows -> Linux VM -> Docker container running in Linux

Now, Linux is running a lightweight Docker container we can access from our Windows machine. Isn't that great?

Data persistence

We stop the Jenkins container and the next day we resume it to keep working. But we have lost everything. What happened????

Docker alone doesn't have data permanence.

The container uses its own folders (/var/jenkins_home on Jenkins, /var/lib/mysql on MySQL, etc), but when you stop the container and run the image again, you are creating a container from scratch. What can we do about it?

We can achieve Data persistence by linking a folder in the OS running Docker, and the container's folder.

mkdir my_jenkins_data docker run -p 8080:8080 -v /home/<USERNAME>/my_jenkins_data:/var/jenkins_home jenkins/jenkins

Here, we created a folder called my_jenkins_data and we linked it with the Jenkins folder /var/jenkins_home, where Docker stores any change.

So, if we run the command again, we will create a new container, linking the stored information, as if we were resuming our container.

Data permanence with volumes

We can simplify this process. Instead of giving a long string for our folder, we can let Docker manage the volumes by creating them in /var/lib/docker/volumes/*.

Create a volume
docker volume create test_volume

This creates a volume in /var/lib/docker/volumes/test_volume
docker run -v test_volume:var/lib/mysql mysql

We can also use the modern way, which is longer but more declarative and verbose:
docker run / --mount type=bind, source=/data/mysql, target=/var/lib/mysql mysql

Final thoughts

As we just saw, Docker is great for several reasons:

Isolation: Docker allows applications to be isolated from the underlying system, ensuring consistency in different environments.
Efficiency: It optimizes resource utilization by using containerization, allowing for more efficient use of system resources.
Portability: Docker containers can run on any machine that has Docker installed, making it easy to deploy applications across different environments.
Scalability: With Docker, it's easy to scale applications by increasing or decreasing the number of containers as per the demand.
Consistency: Docker ensures that the development, testing, and production environments are consistent, reducing the "it works on my machine" problem.
Ecosystem: Docker has a rich ecosystem with a wide range of tools and services that complement containerization, making it a versatile platform for application deployment and management.
Deployment: Docker makes it easier and safer to deploy. Instead of managing packages and their versions, we upload our Docker image to a server.

Resources

Original post

Vagrant tutorial for beginners

Docker Desktop

Docker Engine

The Role of Docker in DevOps

Docker Hub

Vagrant tutorial for beginners

David MM👨🏻‍💻 — Sun, 07 Jan 2024 09:43:50 +0000

Vagrant is a tool used to simplify building and managing Virtual Machines in a very simple yet powerful way. If you, like me, are tired of installing Linux Virtual Machines as I do, you will welcome Vagrant into your life. Let's learn more about Vagrant!

Table of contents

Introduction

Vagrant installation

Vagrant basic commands

Vagrantfile

Final thoughts

Resources

Introduction

How many times have you created a Virtual Machine?

You know the drill: You download a Linux image, create a Virtual Machine, select your options, add the .iso file, start the installation process then wait for something between 15 and 30 minutes. If you did this once or twice every year, it would be ok, but sometimes you need to create a lot for Virtual Machines, and time is lost by waiting.

What if we could simplify and speed up the process?

Enter Vagrant

Vagrant is an open-source tool for building and managing virtualized development environments. Vagrant uses configuration files to define the virtual machine settings and provisions them with the required software and tools. Or you can run a few commands and install a Virtual Machine in seconds. This approach ensures that all team members work in the same development environment, reducing compatibility issues and streamlining the development process.

With Vagrant, instead of doing all the Download a Linux image, create a Virtual Machine, etc processes, we will fetch an existing image from a Vagrant repository and add it to your Virtual Machine manager in 2 minutes. It is not an expression, it takes 2 minutes.

How does it work?

Vagrant downloads a pre-existing Virtual Machine installation (Vagrant calls them boxes), adds it to your Virtual Machine manager and sets the configuration automatically.

How cool is that?

You can run the command vagrant init generic/ubuntu2204 to download an Ubuntu 22.04 Jellyfish box, and vagrant up to start the Virtual Machine. Now, you can open it in your VM or just connect to it with the command vagrant ssh.

Vagrant installation

As the installation depends on what Operating System you have, you just need to enter a few commands in your terminal. As this changes every few months/years, I'll link you to the official Vagrant Installation site.

For example, for Ubuntu/Debian, open your terminal and enter:

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg echo "deb \[signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg\] https://apt.releases.hashicorp.com $(lsb\_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list sudo apt update && sudo apt install vagrant

You also need to have installed a virtualization program, such as VirtualBox.

Downloading your first Vagrant box

Ok, you have Vagrant and VirtualBox installed, now what?

Why don't we start with a download? Download a Centos VM with

vagrant init geerlingguy/centos7

Then start it with:

vagrant up

The VM is up and running. Now you can open it on VirtualBox or, if you don't need the GUI, you can connect to it via SSH with:

vagrant ssh

As simple as that. As Vagrant manages all the processes, you don't need to enter the username or the IP to connect to it. Vagrant boxes come with a user already created (Username: vagrant, Password: vagrant) so you can log in to the machine.

Vagrant basic commands

We just saw how we can download and create a new Virtual Machine, but what more we can do with Vagrant?

Here's a list of basic commands:

Creating a VM

Install a box
vagrant init <BOX_NAME>

Managing a Vagrant VM state

Start a Vagrant VM
vagrant up

Stop a Vagrant VM
vagrant halt

Resume a Vagrant VM
vagrant resume

Reload a Vagrant VM
vagrant reload

Suspend a Vagrant VM
vagrant suspend

Delete a Vagrant VM
vagrant destroy

Vagrant VM status

Check a Vagrant VM state
vagrant status

Check all Vagrant VM states
vagrant global-status

Provisioning

Force provisioning
vagrant provision

Use the debug flag to add more verbosity
vagrant provision --debug

Restart the virtual machine and force provisioning
vagrant reload --provision

Connecting to a VM

Connect to a Vagrant VM via SSH
vagrant ssh

Connect to a specific Vagrant VM via SSH
vagrant ssh <BOX_NAME>

Managing boxes

List all boxes installed
vagrant box list

Check of updates
vagrant box outdated

Download a box
vagrant box add <BOX_NAME> <URL>

Delete a box
vagrant box remove <BOX_NAME>

Vagrantfile

We can also edit your Vagrant boxes with a Vagrantfile.

A Vagrantfile is a configuration file used to define and configure the various aspects of Vagrant-managed virtual machines. It allows us to specify settings such as the virtual machine's networking, and provisioning, among other parameters.

Then, we can use this Vagrantfile on multiple machines at the same time to create Virtual Machines with the same specs. How cool is that?

If you want to edit a Vagrantfile, open it with your IDE (Atom, Notepad++, Sublime text, VIM, VS Code...) and uncomment any text you want to use.

Examples

Add a bridged port
config.vm.network "public_network"

Add a bridged port with a static IP
config.vm.network "private_network", ip: "192.168.1.222"

Specify VM's memory and CPUs
config.vm.provider "virtualbox" do |vb| vb.memory = "2048" vb.cpus = 2 end
Share a folder from your host PC to the Vagrant VM
config.vm.synced_folder "C:\\Users\\<YOUR_USERNAME>\\Desktop\\shared_files", "/home/vagrant/vagrant_data"

Provisioning the VM
config.vm.provision "shell", inline: <<-SHELL apt-get update apt-get install -y apache2 SHELL

Of course, there are more options. You can read more about them in the official Documentation.

You can also download my Vagrant Cheat Sheets.

Final thoughts

As we already saw, Vagrant offers several benefits for developers and IT professionals, including:

Consistent Development Environments: Vagrant ensures that every team member works in an identical environment, reducing "it works on my machine" issues.
Efficiency: It streamlines the setup process for new team members, as well as the onboarding of existing projects.
Isolation: Vagrant keeps project dependencies and configurations isolated from each other, preventing conflicts between projects.
Cross-Platform Compatibility: Vagrant provides a consistent environment across different operating systems, promoting seamless collaboration.
Reproducibility: With Vagrant, it's easy to reproduce environments for testing, debugging, and production, enhancing overall reliability.
Resource Optimization: It allows for efficient resource usage by consolidating multiple development environments on a single machine.

Overall, Vagrant simplifies the development workflow, enhances collaboration, and improves the reliability of software projects.

And you just saw how easy it is to use. At the bare minimum, you can work with just 2 or 3 commands to download, run and connect to it via SSH.

Vagrant should become a tool in your belt, professionally or not.

Resources

Original post

Vagrant installation

VirtualBox installation

VagrantfileDocs

Linux File System

Vagrant Cheat Sheet

The Linux File System: A simple guide for beginners

David MM👨🏻‍💻 — Fri, 03 Nov 2023 07:15:38 +0000

If you want to master Linux, you need to know how the Linux File System works. Why not start now?

Table of contents

Introduction

Linux directories

Final thoughts

Resources

Introduction

When I started using Linux, coming from Windows, I was a bit lost with all the new directories in Linux. Sometimes their names are intuitive (/home, /boot...), but most of the time I didn't understand what they were used for.

Fear not. Today you are going to learn what are each directory for in no time. Let's go!

Linux directories

/

The root directory. This marks the start of the Linux File system and it is the highest level. All the files and directories are stored here.

/bin

Bin contains binary executables (the Linux version of Windows .exe files). These include the commands you use in the terminal (cat, mkdir, ls, cat...). As you may have guessed, the name of this directory comes from BINaries.

/boot

One of the main directories. Here are stored the files used to boot the system successfully. You shouldn't touch this directory.

/dev

This contains files of devices connected to the system. For example, when you connect a USB, but also hard drives.

/etc

As the name says, it is... etcetera. It stores configuration files required by the system. For example, /etc/shadow, /etc/passwd, etc. Again, you shouldn't touch this directory. And if you do, make a copy of the files you modify (I destroyed my Ubuntu virtual machine messing around with this. Luckily I had a snapshot saved...)

/home

Here you will find the private directory of each user. It contains user directories such as /Downloads, /Documents, /Desktop, etc. The exception is root, which has its own directory.

/lib

It contains libraries of different applications. The package manager controls and manages this directory automatically. These are essential files that you shouldn't mess around with.

/media

Contains (temporal) directories of removable media (for example, when you connect a USB, you can find it at /media//.

/mnt

This is the /media directory of the past. Here the CD ROM readers were mounted, but no longer is used.

/opt

Here are stored the software packages provided by a third party, not installed with the package manager (generally, apt-get). Each application has its own directory inside /opt, containing the files needed to run.

/proc

Contains information about running processes and your computer: CPU, RAM, kernel, etc. The files here are generated at your computer start-up and deleted when powered off.

/root

The home directory of the root account. Despite being a kind of "user directory", it has a different structure than the average user.

/run

One of the newest directories. It contains temporal files that use the RAM memory. Once the computer is powered off, the files disappear.

/sbin

Similar to the /bin directory, but for the root user. It contains special binaries and command line tools used by root. For example, the reboot file that only the admin user can use it is stored here.

/sys

Contains information about devices, drivers and kernels. This directory is managed automatically by Linux.

/srv

Contains information about services, specific to your Linux distribution. This directory is managed automatically by Linux.

/tmp

Contains temporal files, created by running applications, the system or users. Once your computer is powered off, these files are deleted.

/usr

This directory contains libraries, binaries and documentation of the installed programs, that are shared between all the users.

/var

Standing for variable, /var directory contains files that are constantly changing, such as log files, events or spool files.

Final thoughts

Understanding and remembering all the directories in Linux it will take your time. Don't try to memorise it as if you were studying for it: Just by using Linux as you should (using the terminal!) you will get used to it. When you always start in /home/, you will learn that all the users have their own directory there. When you connect a USB to your computer, you will find it at /media, and you will remember that that's the purpose of that folder.

Just keep using Linux and you'll get the hang of it in no time :)

Or you can do one of the Linux courses I'm doing right now.

https://letslearnabout.net/hacking/from-zero-to-hero/networking-and-linux-courses/

Resources

Linux courses
Original post: The Linux File System: A simple guide for beginners

Rkhunter tutorial – Protect your PC

David MM👨🏻‍💻 — Wed, 01 Nov 2023 22:57:16 +0000

In an age where cybersecurity is a daily concern, you have to protect yourself. And that's what we are going to do with Rkhunter.

Let's remove rootkits, backdoors and other exploits from your PC.

Table of contents

Introduction

Installation

Running Rkhunter

Resources

Introduction: What is Rkhunter?

But first of all, let's learn what Rkhunter is and what can it do for us.

Rkhunter is a tool that scans your computer for rootkits, backdoors, vulnerabilities, and local exploits. And, in case you don't know:

A rootkit enables access to a computer. It stays at the root (hence the name, root and kit) and gives remote access and control to a malicious person. Nothing you want to do.
A backdoor can let a hacker bypass any security system. Firewalls, antivirus, etc mean nothing once a backdoor has been established.
A vulnerability is a flaw in a computer system that can be taken advantage of.
And, finally, exploits are pieces of software that can take advantage of existing bugs, errors or vulnerabilities in a system. From taking your bank data to stealing your passwords, and encrypting your data... anything is possible.

You don't want this. And, to solve it, we are going to use Rkhunter, a great and easy-to-use tool.

Installation

To install Rkhunter, first update your Linux packages list, then install Rkhunter:

sudo apt-get update
sudo apt-get install rkhunter

Shortly, you will be prompted with this screen:

I picked Local only, but if you want to get emails from Rkhunter, select your preferred option and configure it.

After everything is installed, check that Rkhunter is properly installed:

rkhunter -V

As I'm running this code on October 2023, I got the following message:

Rootkit Hunter 1.4.6

You may have a newer version. But now, let's configure it.

vim /etc/rkhunter.conf

And change the following lines:

107 UPDATE\_MIRRORS=1 122 MIRRORS\_MODE=0 1190 WEB\_CMD=""

We set up the mirror options to let Rkhunter update. Let's update it now:

sudo rkhunter --update
sudo rkhunter --propupd

Everything should be set up now, as we have updated everything. Time for the fun stuff.

Running Rkhunter

To run Rkhunter, simply run:

sudo rkhunter --check

First, it will check general, shareable files in the /usr/ directory. After that, it will check for known rootkits (remember to update before running Rkhunter!), then, additional rootkit checks, malware checks, Linux-specific checks, your network and local host, etc.

At the end, you'll be prompted with a summary:

Luckily, you won't have any warning, but I do. I'm going to run again the check with a special flag:

sudo rkhunter --check --rwo

This will run Rkhunter silently, only displaying any warning messages, in case it finds one or more of them.

Compared to the previous command, this one is way less verbose.

The only warnings I have are the ones regarding lwp-request, a false positive that gets flagged because it allows making HTTP requests, and an SSH misconfiguration. But nothing major.

P.S. If you don't want to get a warning every time on safe files you run Rkhunter, you can add this to your /etc/rkhunter.conf file:

SCRIPTWHITELIST=/usr/bin/lwp-request

Keep running Rkhunter from time to time to keep your computer safe and rootkit free :)

Resources

Rkhunter docs

What is a rootkit?

Vulnerabilities

Original post: Rkhunter tutorial

Vue 3: Options API vs Composition API

David MM👨🏻‍💻 — Sun, 21 Nov 2021 16:16:55 +0000

I used to use Vue to create my FrontEnds and, after one year and a half without using it, I'm re-learning it.

The first thing that hit me, was that Vue 3 finally was a reality. I used the 2nd version, now I'm learning the 3rd.

Right now I'm learning about the Composition API and I have a few questions that I would like to solve by Vue3 users:

1) Do you use Composition API in your day to day?
2) If yes, in which cases do you use Composition API? In which ones, the Options API?
3) What are the drawbacks of the Composition API over Options? And benefits?

How to rebuild a ListView on Flutter using Provider async?

David MM👨🏻‍💻 — Tue, 29 Jun 2021 11:01:38 +0000

TL;DR: My Provider class doesn't trigger a rebuild, but I don't know what I'm doing wrong. Code provided below.

Hi,

I have a ListView.builder nested inside a Consumer.

While it creates as many MyProvider instances I have, if I delete or update an element, it does delete/update that element on the database, but it doesn't trigger a rebuild on the ListView builder, despite using notifyListeners().

This is (a simplified version of) my code:

genre_list.dart

class GenreListScreen extends StatefulWidget {
  static const routeName = '/genre-list';

  @override
  _GenreListScreenState createState() => _GenreListScreenState();
}

class _GenreListScreenState extends State<GenreListScreen> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: ...
      ),
      body: Consumer<GenreProvider>(
        builder: (context, data, index) {
          var genres = data.getGenres;

          return ListView.builder(
            itemCount: genres.length,
            itemBuilder: (context, index) {
              var genre = genres[index];
              return ListTile(
                title: Text(genre['title']),
                subtitle: IconButton(
                  icon: Icon(Icons.edit),
                  onPressed: () async {
                    try {
                      GenreProvider().updateGenre(genre['id'], 'Testing');
                    } on Exception catch (_) {
                      showSnackBar(
                        text: 'Unknown error updating the genre.',
                        color: Colors.red,
                        context: context,
                      );
                    }
                  },
                ),
              );
            },
          );
        },
      ),
    );
  }
}

genre_provider.dart

class GenreProvider with ChangeNotifier {
  static List<Map<String, dynamic>> _genres = [];

  Future fetchGenres() async {
    try {
      QuerySnapshot<Map<String, dynamic>> genres =
          await FirebaseFirestore.instance.collection('genres').get();

      _genres = [];
      genres.docs.forEach((genre) {
        _genres.add({'id': genre.id, 'title': genre['title']});
      });
      notifyListeners();
    } catch (e) {
      print(e);
    }
  }

  Future updateGenre(String id, String title) async {
    try {
      await FirebaseFirestore.instance
          .collection('genres')
          .doc(id)
          .update({'title': title});
      var updatedGenre = _genres.firstWhere((element) => element['id'] == id);
      updatedGenre['title'] = title;
      notifyListeners();
    } catch (e) {
      throw (e);
    }
  }

  List<Map<String, dynamic>> get getGenres {
    return _genres;
  }
}

After a successful login, I call fetchGenres to get the data. Then, I move to GenteListScreen and I can see all the genres I have on my Database.

Clicking on the 'Edit' button, I edit the Genre on the Database (normally a Dialog with a TextFormField, but for the example it is just a fixed string), but it doesn't trigger an UI rebuild on the ListView.

Calling setState(() {}) after the function, triggers a rebuild, and everything is fine, but this call should be done automatically by the Provider package via Consumer.

So the question is: What I am missing on the code to trigger the automatically rebuild?

Looking for Remote Jobs During the Pandemic

David MM👨🏻‍💻 — Wed, 03 Feb 2021 19:15:02 +0000

Looking for a job always has been not an easy task. Now, with the Covid Pandemic, is even harder. And seems that it won't be better anytime soon.

Luckily, this has forced many business to open their mind to hiring remotely, making it easier to find a remote job, from anywhere in the world. Let's see how and where we can do it!

Introduction

Looking for a new job is always a stressful task: Lots of time spent in searching, comparing, sending CV and emails, waiting for an answer...

Since 2020 this has been even harder: Business closed, people getting fired, and having a website has become less of a priority than before.

But enough of negative things.

This has forced (finally!) business to open to hiring people for remote positions. Now you can look for jobs, not only in the city you live in but anywhere in the world.

But this is not the only benefit of working from home...

Why work from home?

Working remotely doesn't (just) mean being able to pick any job, regardless of the location of the company. It also offers:

No commute. Save time, money and stress.
Better eating habits. Instead of packing sandwiches or going to the nearest McDonalds, you can eat better from home.
Fewer distractions. Yes, kids may annoy you a bit, but once you set rules with your kids and/or partner, you'll have fewer distractions than working from home. And fewer questions from coworkers when you're about to crack that problem :-)
More freedom. Business normally enforces a set of (arbitrary) rules, from what to wear to even how to cut your hair (yeah, I know...) or if you can wear jewellery or display tattoos. Ignore that working from home.
Flexible schedule. Some business lets you manage your schedule: As long as you work your hours and produce results, you can choose when to work, leaving time for you to play with your kids, relax or do chores, improving your work-life balance.
More productivity. Contrary to how many bosses think, working from home increases your productivity. No one is there to stop your train of thought to show you another cat video (just leave it on Slack and I'll see it when I have free time!).
Easier phone calls. If you share your office, you know that calling your clients is torture. People trying to talk to you, people talking between them, printers, doors, more people yelling... From your own home, you don't have all that distractions.

While this takes self-discipline and it is lonely, a lot of people prefer working remotely than driving one hour to work in an office.

Let's see now where to find that dreamy job.

Search engines

Without a further ado, here is a list of places where you can search for a remote job:

Jooble

Jooble lets you search for jobs anywhere in the world.

Select what are you looking for (Node.JS dev, Flutter programmer, Web design) and add a location (a country, a city...or 'remote'!), and you'll find a lot of job offers.

As an example, here's what you will find if you are looking for a Remote React job.

984 vacancies seems a good number, right?

You can also add your email to get notified when a new job is open!

Jooble has been online for more than 10 years, offering hundreds of jobs in different technologies.

Remotive

Remotive focuses in only remote jobs.

A search box with a drop-down menu to filter by category (Sales, DevOps, QA, Software developer...) is all you need to find a job here.

Clean UI and easy to apply by login with LinkedIn or Github.

We work remotely

We Work Remotely is another search engine focused on remote jobs.

It has a nice and simple (yet powerful) advance search system, that lets you filter jobs.

Stack Overflow

If you have been programming for more than one week, you already know Stack Overflow. What you might not know is that it has its own Remote Developer Jobs listing.

It offers one of the best advanced search filtering system, being focused in just programming jobs, with even a voting system.

Indeed

While not focused on just remote (or programming) jobs, you'll find plenty at Indeed.

As you can see, at this time it is listing thousands of remote jobs. What are you waiting for?

Remote Hunt

Remote Hunt, at its own name implies, is a remote job search engine with daily new jobs.

While it is not big (yet!), it is updated with new jobs daily.

Their advanced search system is very powerful, as you can select what benefits are you looking for (Equity, Pair Coding, Crypto...).

Final thoughts

Talking about working remotely, we are living in an interesting time.

A lot of business are open to hiring remote workers and, as you saw, you have a lot of websites where you can search for jobs. And you are aware of the benefits of working from home.

Don't procrastinate and start searching for the job of your dreams!

NodeJS Tutorial – 01 – Creating your first server

David MM👨🏻‍💻 — Wed, 22 Jul 2020 17:00:02 +0000

Learning NodeJS is a great opportunity for every web developer: Tons of jobs, easy to learn and, as Javascript is a MUST on web developing for the FrontEnd, you already know the language!

With this tutorial, you will create your first NodeJS server in less than 10 minutes.

In this video you will learn:

How to install NodeJS in your computer
What NPM is
How to create your NodeJS configuration file
How to create your first server and the base file
How to create routes to your server
How to install Nodemon

What exactly is Node.js?

Pros and Cons of Node.js

My Youtube tutorial videos

Final code on Github

Reach to me on Twitter

6 + 1 Free Django tutorials for beginners

David MM👨🏻‍💻 — Mon, 06 Jul 2020 15:46:39 +0000

You have just finished the Django poll tutorial, and you don't know what should be your next step? Or are you looking for inspiration to improve your recently acquired Django skills?

Don't you worry, as I've listed down the best Django tutorials I have found when I was still learning. Here they are:

A proper blog, by Corey Schafer

Yes, we know there are a lot of Django tutorials focused on blogs. But this one does it professionally. Deploying, AWS, enabling SSL certifications, users management, etc.

Start here:

Customer management app, by Dennis Ivy

Build a Customer management app from scratch. Manage customer information, orders, multi-parameter filtering, authentication, password reset, role permission, etc. Pretty neat.

Ecommerce Website with Django and Stripe, by JustDjango

With Django we can do things that are cool, but also profitable. Check this tutorial to learn how to create an Ecommerce Website with Django, using Stripe as a payment platform.

Refunds, discount codes, creating and deleting items. Everything!

Twitter-like app with Django and React, by CodingEntrepreneurs

If just using Django (and maybe even Bootstrap!) feels a bit short or clunky, you can take up a notch and merge Django with React to create a great Twitter-like App.

Ecommerce Website with Django and React, by JustDjango

An improvement from the previous Ecommerce Website, now using React too.

Django Chat application, by JustDjango

This one is a bit more advanced. Here, we are using Django Channels to provide your Django project with WebSockets to update our website in real-time.

Django Full course, by FreeCodeCamp

Did you get excited by seeing the projects but you don't know Django and want to start? For the very beginners, I have an (almost) 4 hours crash course, so you can start right now:

My Youtube tutorial videos

Reach to me on Twitter

My Github

Contact me: DavidMM1707@gmail.com

Creating a Python virtual environment

David MM👨🏻‍💻 — Sat, 04 Jul 2020 17:34:21 +0000

Many people use Anaconda to write Python code. But it is so cumbersome for small scripts and hard to manage.

Instead, we can create our own virtual environments (like our own world) where we only have the packages we want to install.

In about 6 minutes we will be creating a Python virtual environment with Pipenv.

Table of contents

What we will learn here

1- Creating a virtual environment

2- Installing packages on our Virtual Environment

3- Creating a Scrapy spider on our new Virtual Environment

Final Thoughts

What we will learn here

In this video you will learn how to:

What Virtual Environments are
Why we use them
How to create our own Virtual Environment
To install packages on our Virtual Environment
How to create a small project from our Virtual Environment

1- Creating a virtual environment

What's a Virtual Environment?

Many people use Anaconda, a Free Python distribution. While this helps when dealing with complex things by installing a series of packages (such as Machine Learning, Data Science, etc), sometimes is a bit cumbersome, especially when we want to control our environment by installing/removing packages, updating, etc.

What can we do instead of using Anaconda?

We can create a Virtual Environment and install the packages we need, manually.

But first... What's a Virtual Environment?

Real Python has a good definition here:

At its core, the main purpose of Python virtual environments is to create an isolated environment for Python projects. This means that each project can have its own dependencies, regardless of what dependencies every other project has.

Imagine that you created a Django project in 2019, using Django 2.2. Now, on mid-2020. you want to update to Django 3. After doing it, your older Django project doesn't work because it was for Django 2.2!

By using a Virtual Environment, each project has its own local packages list, with its own version.

We can have an older project using Django 2.2, and a newer one using Django 3. Each time we work on one or other project, we just load their own Virtual Environment. This way we use their local packages.

As everything, the best way to understand it is by practicing, so let's do it!

Creating our Virtual Environment

If you have installed Python (and you should, because you're reading this post!), you have already the virtualenv package installed. But on this tutorial, we are going to use pipenv.

We need to install pipenv on our computer, to have access anywere:

pip install pipenv

After that, move to the folder where you want to create your project, and create a Virtual Environment with 'pipenv shell':

After a few seconds, this will create a Python virtual environment:

You can use the commandos 'pip list' and 'pip freeze' to list the packages you have installed on the current Virtual Environment: 'Pip list' will list every package installed (even the ones installed by default such as setuptools, pip and wheel) while 'pip freeze' ONLY the ones you installed manually:

As you can see, we have no packages installed. Let's install them!

2- Installing packages on our Virtual Environment

On this tutorial, we will create a basic Scrapy project.

You don't need to know how to use Scrapy, as this is just an example, but Scrapy is a framework that lets you extract data from websites. I have a few blogpost tutorials on Scrapy if you want to learn it, but as I said, you don't need to know it.

Anyway, we need to install Scrapy. If we go to their website we can see that installing it is quite easy:

After a little bit, you'll have everything you need installed. Let's see if everything is correct:

Scrapy, along a bunch of helper packages, has installed.

Let's write a basic Scrapy spider to see if everything is in order.

3- Creating a Scrapy spider on our new Virtual Environment

Let's create a Scrapy spider by following the docs tutorial:

On the folder you are, run:

scrapy startproject tutorial

Under tutorial/spiders folder, create a spider file (for example, quotes_spider.py) and copy the following:

import scrapy

class QuotesSpider(scrapy.Spider):
    name = "quotes"

    def start\_requests(self):
        urls = \[
            'http://quotes.toscrape.com/page/1/',
            'http://quotes.toscrape.com/page/2/',
        \]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        page = response.url.split("/")\[-2\]
        filename = 'quotes-%s.html' % page
        with open(filename, 'wb') as f:
            f.write(response.body)
        self.log('Saved file %s' % filename)

Save the file, and run the code. Remember to move inside the project's folder:

If everything is working correctly, you'll have 2 .HTML files on the root folder, proof that everything has worked without a problem:

Final Thoughts

As you saw, creating a Virtual Environment, is not only easy, but useful.

This way we each project with its own packages, and we can use the newest version on future projects without compromising the older ones.

You just need to create a Virtual Environment, install the packages and you are set!

Remember that if you want to learn easily how to use Scrapy to extract data from different websites, you can learn with my Scrapy tutorials: Creating your first spider with Scrapy.

My Youtube tutorial videos

Reach to me on Twitter

My Github

Contact me: DavidMM1707@gmail.com