Forem: RB

Introduction to SSH setup

RB — Sun, 22 Sep 2024 16:03:22 +0000

In todays world, security is paramount, especially when it comes to communication over networks. In order to protect sensitive data and unauthorized access, it is important that all interactions over internet occur through secure channels. Especially when comes to running commands remotely on a server, we need secure methods to avoid risks such as man-in-the-middle (MITM) attacks. Just as HTTPS secures communication in web application, Secure Shell (SSH) provides a secure channel to access terminal of a remote server. ssh ensures that your commands and encrypted and safely transmitted over the network.

In this block, we'll explore on setting up a ssh server, creating users and authentication based on passwords and ssh keys. In this blog we will leverage docker and OpenSSH (open source implementation of ssh protocol).

Creating SSH Server

Here we will use sshd which is a OpenSSH server program.

FROM ubuntu:20.04
RUN apt update \
    && apt install openssh-server -y \
    && apt clean \
    && rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/* \
    && service ssh start
EXPOSE 22
CMD ["/usr/sbin/sshd","-D"]

Creating SSH Client

In practice, this would be the machine of any one of the user.
Here we will use OpenSSH client program ssh.

FROM ubuntu:20.04
RUN apt update \
    && apt install openssh-client -y \
    && apt clean \
    && rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*

Combine Using Docker compose file

networks:
  ssh_network:

services:
  ssh-server:
    container_name: ssh-server-container
    image: ssh-server
    build:
      context: .
      dockerfile: Dockerfile
    networks:
      - ssh_network
    ports:
      - 2022:22
  ssh-client:
    container_name: ssh-client-container
    image: ssh-client
    stdin_open: true #Keep stdin open, so that container doesn't exit
    build:
      context: .
      dockerfile: ClientDockerfile
    networks:
      - ssh_network

Deployment

Run the docker compose file from your terminal and you can see the containers running in your machine.

Creating a User

sh into the ssh server container

  $ docker exec -it ssh-server-container sh

create a ssh user, once the user is created check the home directory, it should contain a directory with the name of the user on it.

  # adduser ssh-user1

Run tail commands of /etc/passwd and /etc/shadow to see if the user and password is created for that user.

Now that we have a user, let sh into client container. In real scenario this would actually be the machine of the user.

  $ docker exec -it ssh-client-container sh

Now lets login to ssh server.

  # ssh ssh-user1@ssh-server-container

Note: if this is your first time connecting to this server it will prompt you with either a ECDSA or ED25519 fingerprint of the ssh server. Before accepting, verify the fingerprint. if you have access to the server you can run the following command on the server and compare it with the one on the ssh prompt.

  # ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
  # ssh-keygen -lf /etc/ssh/ssh_host_ecdsa_key.pub

Once you accept, the fingerprint will be added to the known_hosts file, and it will ask for the password for the user.

since you logged in as ssh-user1, you will be inside the home/ssh-user1 directory.

Set up public key authentication

1) Turn off Password Authentication (Optional)

install your choice of editor inside the ssh server

   # apt update
   # apt install vim
   # vi /etc/ssh/sshd_config

Make sure to read comments at the top of the file.
Find the below lines in the file

   # To disable tunneled clear text passwords, change to no here!
   # PasswordAuthentication yes
   #PermitEmptyPasswords no

uncomment PasswordAuthentication and change it to no

   # To disable tunneled clear text passwords, change to no here!
   PasswordAuthentication no
   #PermitEmptyPasswords no

save the file and restart your ssh service, or in this case restarting container will also work.

2) Make sure the default for PubkeyAuthentication is yes in etc/ssh/sshd_config file, else override it to yes.

3) generate ssh keys inside ssh client container

   $ ssh-keygen -t rsa

4) Copy the public key to home/ssh-user1/.ssh/authorized_keys of ssh server. since copying from one container to another is not supported in docker. i'll use the combination of cat and tee to copy the file.

   $ docker exec -i ssh-client-container cat /root/.ssh/id_rsa.pub | docker exec -i ssh-server-container tee /home/ssh-user1/.ssh/authorized_keys

Make sure to create .ssh folder inside the home/ssh-user1 before running above command.

5) Make sure that the ssh-user1 is the owner of the .ssh and authorized_keys inside home/ssh-user1 of the ssh server.
you can change the ownership by logging in ssh server as a root and then run the following. The Recursive flag -R makes sure everything inside ssh-user1 directory is also owned by ssh-user1.

$ chown -R ssh-user1 .ssh

6) Now from the client container you can run ssh ssh-user1@ssh-server-container to login using public key.

Instead of creating a seperate client container, you could as easily use your own host machine to connect to the ssh server with the same user or create a different one for fun.

In ssh server:

$ adduser newuser
$ cd /home/newuser
$ mkdir .ssh

In your host machine:

$ ssh-keygen -t rsa
$ docker cp ~/.ssh/id_rsa_newuser.pub ssh-server-container:/home/newuser/.ssh/authorized_keys
$ ssh new_user@localhost -p 2022

Permissions in ssh server:

$ chown -R newuser .ssh

The ssh server port 22 is mapped to the port 2022 of the host machine, so you can login from the host machine with the following command ssh -i ~/.ssh/id_rsa_newuser newuser@localhost -p 2022.

In case the ssh connection fails you can add -v or -vvv in the command for more detailed information.

source code

Git: Keeping your email safe in public repositories

RB — Mon, 19 Aug 2024 00:59:58 +0000

In today’s digital age, it’s easier than ever to share your code and contribute to public projects, often as a way to showcase your portfolio. However, the open nature of these platforms can sometimes lead to accidentally sharing personal information, like your email address. Here’s a simple guide on how to keep your personal information safe while still sharing your work publicly.

Use Dedicated Email Address: Create an email address specifically for your GitHub account or other open source activities. This way, even if your email address is exposed, your personal email remains secure.

configure your git settings to use this email address:

   git config --global user.email "dedicated-email@example.com"

Use github's Private Email Feature: Github provides a feature for developers to keep their email address private for commits.
Here's how you can do it.
- Navigate to https://github.com/settings/emails
- Add Email Address that you might not want to expose.
- Check the Keep my email addresses private option. In the description section you can find your username@users.noreply.github.com email which will be used for web based activities.
- Check Block command line pushes that expose my email option. While performing push operations, github will check if the latest commit has your private email, if yes the operation will be blocked and git will warn you about the exposing of the private email.
- Configure your local git settings to use your github noreply email.
```
     git config --global user.email "username@users.noreply.github.com"
```
what if your email is already exposed ?

WARNING ⚠️ : This option will rewrite your git history, hash values of the commits, so use carefully.

Install git-filter-repo: tool used to rewrite the git repository history.
git log --all --format='%h %ad %an <%ae> %cn <%ce>’ to check which email addresses are exposed in commits.

use the below command to rewrite your commit history and replace your exposed email.

     git filter-repo --commit-callback '
     if commit.author_email == b"your_exposed_email":
     commit.author_email = b"github-email@users.noreply.github.com"
     if commit.committer_email == b"your_exposed_email":
     commit.committer_email = b"github-email@users.noreply.github.com"
     '

This might remove your remote references, so verify it using git remote -v if removed, add the remote references back.

confirm the changes with git log --all --format='%h %ad %an <%ae> %cn <%ce>’.
since the above command rewrites the git history, you need to force push these changes.

If the repository is big, this push can give you error because of the limited buffer size for http operations.
use below command to increase your git http buffer size.
```
     git config --global http.postBuffer 157286400 # ~150MB
```

It is best to avoid third option, Since you are mostly working in groups in open source projects and it is not a wise to completely rewrite the git history. So,

Avoid hardcoding personal information.
Educate yourself About open source best practices.
Regularly review your repositories.

And be mindful of the data you share.

Custom Memory Pool: Creating memory pool for custom class

RB — Thu, 25 Apr 2024 23:03:14 +0000

In this blog we are going to see how we can implement a string pool like cache for our own custom class.

Problem statement:
I want to create a Person class that stores name, ssn, address and email. but if i create a multiple person with the same name and ssn value, it should be considered the same person and no new object should be created in the heap. It should return the memory address of the old object. but if the combination of ssn and name is unique, it should create a new Person object in the heap.

Data Structure:
From the problem statement we can see that we need to store a key value pairs. and also the key needs to be unique representing a unique person. so we will be working with HashMap.

Concept:
We will be implementing the string pool like feature where if we find object in memory, we will return memory address of that object, else create a new object and store in the memory pool.

Implementation:

Setting up a Person class

public class Person{
  private String name;
  private String ssn;
  private String address;
  private String email;

  public Person(String name,String ssn,String address,String email){
    this.name = name;
    this.ssn = ssn;
    this.address = address;
    this.email = email;
 }
}

we need a memory pool to store the Person objects

   private static final HashMap<String,Person> MEMORY_POOL = new HashMap<>();

we are using static variable because all Person objects will be sharing this variable.

we need a method to generate unique key combination for each Person object.

private static int generateKey(String name, String ssn){
  // simple key,name combination would also work
  // but you would need to change Integer to String in hashmap
  return Objects.hash(name,ssn);
}

Next we will need a method to store Person object in the memory pool.

private static void addToPool(Integer key, Person value ){
  Person.MEMORY_POOL.putIfAbsent(key,value);
}

Since constructor call always initializes new object we need to call constructor conditionally, and also we do not want anyone to call constructor directly. so making constructor private and exposing static method to create Person object, this method makes a decision to either create a new object or get from the memory pool.


private Person(String name,String ssn,String address,String email){
   this.name = name;
   this.ssn = ssn;
   this.address = address;
   this.email = email;
}
public static Person createPerson(String name,String ssn,String address,String email){
  int key = Person.generateKey(name,ssn);
  if(Person.MEMORY_POOL.containsKey(key)){
    return MEMORY_POOL.get(key);
  }
  Person p = new Person(name,ssn,address,email);
  Person.addToPool(key,p);
 return p;
}

Putting it all together.

import java.util.HashMap;
import java.util.Objects;

public class Person{
    private static final HashMap<Integer,Person> MEMORY_POOL =
            new HashMap<>();

    private String name;
    private String ssn;
    private String address;
    private String email;

    private Person(String name,String ssn,String address,String email){
        this.name = name;
        this.ssn = ssn;
        this.address = address;
        this.email = email;
    }

    private static int generateKey(String name, String ssn){
        return Objects.hash(name,ssn);
    }

    private static void addToPool(Integer key, Person value ){
        Person.MEMORY_POOL.putIfAbsent(key,value);
    }

    public static Person createPerson(String name,String ssn,String address,String email){
        int key = Person.generateKey(name,ssn);
        if(Person.MEMORY_POOL.containsKey(key)){
            return MEMORY_POOL.get(key);
        }
        Person p = new Person(name,ssn,address,email);
        Person.addToPool(key,p);
        return p;
    }

    private String getName(){
        return this.name;
    }
    public String getEmail(){
        return this.email;
    }
    public String getAddress(){
        return this.address;
    }

    public void setEmail(String email){
        this.email = email;
    }

    public void setAddress(String address){
        this.address = address;
    }

    public String toString(){
        return "Person ( name: "+ this.name + ", ssn: " + this.ssn + ", email: " + this.email + ", address: "+this.address + " )";
    }

}

Testing

public class Main {

    public static void main(String[] args){
        Person p = Person.createPerson("john","234-df-44","usa", "john@usa.email.com");
        System.out.println("Person p: " + p);

        // should not create a Person object since name and ssn are same
        Person p1 = Person.createPerson("john","234-df-44","mexico", "john@mexico.email.com");
        System.out.println("Person p1: " + p1);

        Person p2 = Person.createPerson("Johnny","776-dr4-990","canada", "johnny@canada.email.com");
        System.out.println("Person p2: " + p2);

        System.out.println();
        // checking if the p and p1 reference to the same memory location
        System.out.println("p==p1: " + (p == p1)); // true
        // can also be verified with equals method since
        // we never override the method in Person class
        System.out.println("p.equals(p1): " + p.equals(p1)); // true

        // checking if p1 and p2 are equal
        System.out.println("p1==p2: " + (p1 == p2)); // false

        System.out.println();
        System.out.println("updating the email for p1 to hello@world.com");
        p1.setEmail("hello@world.com");
        System.out.println("Person p: " + p);
        System.out.println("Person p1: " + p1);
    }
}

On running the above main method we can see the output as:

Person p: Person ( name: john, ssn: 234-df-44, email: john@usa.email.com, address: usa )
Person p1: Person ( name: john, ssn: 234-df-44, email: john@usa.email.com, address: usa )
Person p2: Person ( name: Johnny, ssn: 776-dr4-990, email: johnny@canada.email.com, address: canada )

p==p1: true
p.equals(p1): true
p1==p2: false

updating the email for p1 to hello@world.com
Person p: Person ( name: john, ssn: 234-df-44, email: hello@world.com, address: usa )
Person p1: Person ( name: john, ssn: 234-df-44, email: hello@world.com, address: usa )

From the output we can see that p and p1 are same objects. since they have same ssn and name combination, new Person object ("john","234-df-44","mexico","john@mexico.email.com") is not created. The email update of p1 is reflected on both p1 and p object, which shows that they both point to the same object in the heap.

Java Strings: Understanding string literal and new operator

RB — Thu, 25 Apr 2024 21:16:59 +0000

In java there are two ways of creating a string:

using string literal String str = "Hello world";
using new operator String str = new String("Hello world")

Lets dig deep into what happens when each of the above syntax is used to create a string.

String Template

String str = "Hello World";

In java this is equivalent to

String str = "Hello World".intern();

Let’s see what intern() method does

on invoking this function it checks if the string content “Hello World” exists in the String pool.

if it does not find same string content in the pool, it will create a new String object in heap. Since we are using string literal, java will then add this string to the string pool for reusing and return the memory address of the string object. let's assume this memory address is 50.

Next time if we add another string with string literal and the content of the string is same, then java will return the memory address of the previous string object.

String newStr = "Hello World";

But if you create a string using the new operator, it will not use the string pool, instead it will create another string object in the heap. let's assume the new memory address is 100.

String thirdString = new String("Hello World");

We can verify this with the == operator, since String checks the memory address if we try to confirm equality with == operator.

String str = "Hello World".intern();
String newStr = "Hello World";
String thirdString = new String("Hello World");
System.out.println(str == newStr); // true
System.out.println(newStr == thirdString); // false

If you want to check if the string contents are same then you would need to use equals method available in string object.

String str = "Hello World".intern();
String newStr = "Hello World";
String thirdString = new String("Hello World");
System.out.println(str.equals(newStr)); // true
System.out.println(newStr.equals(thirdString)); // true

Why does java do this ?
String is immutable Object, so everytime you perform some operation on string a new string object is created. and creating new string object everytime is very expensive, so java added this functionality to reuse the already existing string contents. But this is applicable only if you are using string literal to create string objects.

Understanding Java’s Pass by Value with Heap and Stack Frames Visualization

RB — Wed, 24 Apr 2024 21:35:48 +0000

Java is well-known for being strong and flexible, but it can be confusing, especially about how it handles passing things to methods. People often wonder if Java passes things by value or by reference. In this blog, we’ll talk about this and see how things go down when object arguments are passed.

let’s first understand what is pass by value and pass by reference.

Pass by value: When arguments are provided to a method, a copy of those arguments are passed to the method. Any modification made to that parameter inside the method’s scope, has no affect on the original variable outside the method’s scope.

Pass by Reference: When a reference or pointer to the original variables are available inside a methods scope, then it is pass by reference. Any modification made will also be reflected to the original variable.

Java strictly follows Pass By Value , the misconception generally occurs when passing objects as arguments.

Let’s look at an example to clear things up.

public class Employee{

 private String name;
 private double salary;

 Employee(String n){
  this.name = n;
 }

 public String getName(){
  return this.name;
 }

 public double getSalary(){
  return this.salary;
 }

 public void setSalary(double s){
  this.salary = s;
 }

 public String toString(){
  return "Employee: name: " + this.getName() + ", salary: "+ this.getSalary();
 }

}

public class Main{

 public static void swapValues(Employee e1,Employee e2){
  Employee temp = e1;
  e1 = e2;
  e2 = temp;
 }

 public static void changeValue(Employee e1){
  e1.setSalary(3400.99);
  e1 = new Employee("Ben");
  e1.setSalary(4500.88);
 }

 public static void main(String[] args){
  Employee e1 = new Employee("Bar");
  Employee e2 = new Employee("Foo");

  System.out.println("e1 before swap: "+e1);
  System.out.println("e2 before swap: "+e2);

  swapValues(e1,e2);

  System.out.println("e1 after swap: "+e1);
  System.out.println("e2 after swap: "+e2);

  changeValue(e1);
  System.out.println("e1 after changing value: "+e1);
 }

}

when you run the Main class the following output can be seen:

e1 before swap: Employee: name: Bar, salary: 0.0
e2 before swap: Employee: name: Foo, salary: 0.0
e1 after swap: Employee: name: Bar, salary: 0.0
e2 after swap: Employee: name: Foo, salary: 0.0
e1 after changing value: Employee: name: Bar, salary: 3400.99

Let's dig deeper and understand how things go down in the swapValues and changeValue methods. let's look at the main method.

whenever a new operator is used to create an object, a memory address is created on a heap for that object and its memory address is returned.
In the example above e1 and e2 store an address of the objects memory location in heap.

let us assume the memory address for e1 is 50 and e2 is 100.

when e1 and e2 are passed to the swapValues method, instead of passing the original value, two new Employee variables are created and passed to the method. These new variables are a copy pointing to the same memory location in heap as the original variables.

when you are performing operations on these variables inside the swapValues method you are actually operating on the copy values.

In above image we can see that e1 and e2 ( local to the swapValues ) have swapped the values but since java is pass by value, the original e1 and e2 does not reflect those changes. After the execution of the method completes the original variables remain unaffected.

let’s look at the changeValue method. Similar to swapValues method, a new Employee variable pointing to the same memory address as e1 is created and passed to the changeValue method.

now when i call e1.setSalary(3400.99) , you are performing set operation on the object stored at memory location 50. so this change will be reflected on both e1, as they point to the same object in heap.

Any reassignment to the local variable will be bound to that scope only. The reassignment e1=new Employee("Ben”); will create a new object in the heap and store the new memory location.

Moving forward any update methods on e1 will be reflected only on the new object at location 150. e1.setSalary(4500.88); can be seen on the stack and heap as follows:

After the changeValue’s method completes execution, we can see, only the salary of the original employee e1 is updated. The new Employee object assignment has no effect on the main’s e1.

we saw that any operation to the variables, had no affect to the original variables. Although we could see that setting the salary on the e1 object worked, this is only because we operated on the same object at memory location 50, but not because of pass by reference. Even when working with objects we can see that the objects are not passed by reference rather reference to the objects are passed by value.