DEV Community: Naman Tamrakar

JWT Token authorisation in spring boot 3 without any external library

Naman Tamrakar — Fri, 26 Jul 2024 22:24:21 +0000

In this blog post, we'll walk through a Spring Boot application that sets up a secure environment using JWT authentication. In most of the blogs or tutorials you must have implemented jwt authentication using a 3rd party library, But for this implement we would use spring-oauth2-authorization-server which is provided by spring framework itself. So without wasting much time let's start.

So before starting coding let's head over to start.spring.io to get our project ready. We will mainly add

Spring web (For setting up servlet)
Spring data jdbc and h2 (For database and ORM)
Spring oauth2 authorization server (For JWT authorisation)
Lombok (To reduce boiler plate code)

Our dependencies should look like this:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-authorization-server</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Next we will create a protected REST endpoint to test our API.

class HomeController {
    @GetMapping
    String home() {
        return "home";
    }
}

Creating user model

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;
import org.springframework.security.core.userdetails.UserDetails;

@ToString
@Table("USERS") // using custom table name as user keyword reserved
class User implements UserDetails {
    @Id
    Long id;
    String username;
    String password;
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of();
    }
    @Override
    public String getPassword() {
        return password;
    }
    @Override
    public String getUsername() {
        return username;
    }
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }
    @Override
    public boolean isEnabled() {
        return true;
    }
}

Creating user repository

import org.springframework.data.repository.CrudRepository;
interface UserRepository extends CrudRepository<User, Long> {
    Optional<User> findByUsername(String username);
}

Now setting up our token authorisation

For signing our jwt token we will create RSA private/public key pair using openssl tool.

# run these command in resources/certs directory
# create rsa key pair
openssl genrsa -out keypair.pem 2048
# extract public key
openssl rsa -in keypair.pem -pubout -out public.pem
# create private key in PKCS#8 format
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in keypair.pem -out private.pem

Once we have our key in place add the following propertied in application.properties file.

rsa.private-key=classpath:certs/private.pem
rsa.public-key=classpath:certs/public.pem
# for logging add the properties
logging.level.org.springframework.security=TRACE
logging.level.org.springframework.jdbc=TRACE
server.error.include-message=always

Now add this security config

@EnableWebSecurity
@Configuration
class SecurityConfig {
    private @Value("${rsa.private-key}") RSAPrivateKey privateKey;
    private @Value("${rsa.public-key}") RSAPublicKey publicKey;
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
                .csrf(AbstractHttpConfigurer::disable)
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers("/auth/**").permitAll()
                        .anyRequest().authenticated()
                )
                .oauth2ResourceServer(oauth -> oauth.jwt(Customizer.withDefaults()))
                .sessionManagement(session -> session
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .build();
    }
    @Bean
    public UserDetailsService userDetailsService(UserRepository userRepository) {
        return username -> userRepository
                .findByUsername(username)
                .orElseThrow(() ->
                        new UsernameNotFoundException("user with username " + username + " not found!!")
                );
    }
    @Bean
    JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder.withPublicKey(publicKey).build();
    }
    @Bean
    JwtEncoder jwtEncoder() {
        JWK jwk = new RSAKey.Builder(publicKey).privateKey(privateKey).build();
        JWKSource<SecurityContext> jwks = new ImmutableJWKSet<>(new JWKSet(jwk));
        return new NimbusJwtEncoder(jwks);
    }
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Bean
    AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
        return configuration.getAuthenticationManager();
    }
}

To generate the token for logging in add a token generation service

@RequiredArgsConstructor
@Service
class TokenService {
    private final JwtEncoder encoder;
    public String generateToken(Authentication authentication) {
        Instant now = Instant.now();
        String scope = authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(" "));
        JwtClaimsSet claims = JwtClaimsSet.builder()
                .issuer("self")
                .issuedAt(now)
                .expiresAt(now.plus(1, ChronoUnit.HOURS))
                .subject(authentication.getName())
                .claim("scope", scope)
                .build();
        return this.encoder.encode(JwtEncoderParameters.from(claims)).getTokenValue();
    }
}

Adding an endpoint for logging in our controller

@PostMapping("/auth/login")
public String login(@RequestBody Map<String, String> user) {
    log.debug("User login: {}", user);
    Authentication auth = manager.authenticate(
            new UsernamePasswordAuthenticationToken(user.get("username"), user.get("password")));
    String token = tokenService.generateToken(auth);
    log.debug("JWT token: {}", token);
    return token;
}

And to create user for initial startup add this bean

@Bean
ApplicationRunner runner(UserRepository userRepository, PasswordEncoder encoder) {
    return args -> {
        User user = new User();
        user.username = "admin";
        user.password = encoder.encode("admin");
        var savedUser = userRepository.save(user);
        log.info("user: {}", savedUser);
    };
}

Now let's test our API

> curl -X POST http://localhost:8080/auth/login -d '{"username":"admin", "password": "admin"}' -H "Content-type: application/json"

output

eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJzZWxmIiwic3ViIjoiYWRtaW4iLCJleHAiOjE3MjIwMzUyOTksImlhdCI6MTcyMjAzMTY5OSwic2NvcGUiOiIifQ.SwRW7_P4xMp5-aLTcUYZyL9jncTIVHUFswaQoKupwfhaoAWYRpmP5g-Ras1gU2oAJ_saY7jt0N-WiezS977FAgDOYYmdxr2H4SBeg0qNqsSV6fOX9zRELYukdbEnT9GGaAk5u9WXd6JoHa5x_7vqXJ1Uu2ciDNxgRaBVtwoeWawZ53g0EFwjqturuQALWfBkkLafMbkY_dSqAoohmvTlVVGWiYPylGOsIhQ3CjamZVzqq8ma9WHUPx8p8luz7EBdsjm1MQYRrtC3NiH2TJaQqJTQenevZ8_YoKUUk6VddVzAxc0xycnmY-g94zEVJyjdKeOM98AjEE9C4oX5XgGuKA

and now test our protected enpoint with jwt token

> curl http://localhost:8080 -H "Authorization: Bearer eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJzZWxmIiwic3ViIjoiYWRtaW4iLCJleHAiOjE3MjIwMzUyOTksImlhdCI6MTcyMjAzMTY5OSwic2NvcGUiOiIifQ.SwRW7_P4xMp5-aLTcUYZyL9jncTIVHUFswaQoKupwfhaoAWYRpmP5g-Ras1gU2oAJ_saY7jt0N-WiezS977FAgDOYYmdxr2H4SBeg0qNqsSV6fOX9zRELYukdbEnT9GGaAk5u9WXd6JoHa5x_7vqXJ1Uu2ciDNxgRaBVtwoeWawZ53g0EFwjqturuQALWfBkkLafMbkY_dSqAoohmvTlVVGWiYPylGOsIhQ3CjamZVzqq8ma9WHUPx8p8luz7EBdsjm1MQYRrtC3NiH2TJaQqJTQenevZ8_YoKUUk6VddVzAxc0xycnmY-g94zEVJyjdKeOM98AjEE9C4oX5XgGuKA"

output

home

Source code

https://github.com/namantam1/spring-tutorial/tree/jwt-oauth

Conclusion

This code provides a comprehensive example of setting up JWT-based authentication in a Spring Boot application. It includes the creation of users, secure password storage, and JWT token generation. This setup ensures that only authenticated users can access certain endpoints, enhancing the security of your application.

Solve leetcode climbing stairs problem in x86_64 assembly language

Naman Tamrakar — Thu, 20 Jul 2023 14:54:18 +0000

Can a leetcode question be answered in x86–64 assembly language?

Technically, no, since leetcode sadly 😞 does not offer the ability to code in assembly. Fortunately 🤞, inline assembly in C still allows us to code in assembly language.

So in this post, I will let you know how you can solve a problem in assembly language in leetcode. So let’s start 🥳.

Feel free to skip this section if you are already familiar with AT&T syntax for x86–64 assembly programming. A register’s width on an x86–64 CPU is 64 bits, meaning it can store 8 bytes of data. 64-bit CPUs include 16 general-purpose registers in addition to a few special registers. The general-purpose registers rdi, rsi, rax, rbx, rcx and rdx are a few that are highly helpful. Nearly every assembly code contains these registers.

Using the mov instruction, data can be transferred from memory to these registers. The add and sub instructions can be used to add and subtract values from the register, respectively. The push and pop operations can be used to add and remove values to and from the stack, respectively.

Please check out my repository on x86 assembly on GitHub for a detailed guide on x86 32-bit and 64-bit assembly programming.

So those were some x86_64 assembly fundamentals. Once you start working with code, it will all make more sense. Therefore, we will address the “climbing stairs” topic from the _leetcode _ “dynamic programming” question today. I will thus start by writing a C implementation of the code that we will use as a guide for writing the final assembly code.

#include <stdio.h>

int climbStairs_c(int n) {
    int pre_pre = 1, pre = 1, i = 2;
    while (i<=n) {
        int tmp = pre + pre_pre;
        pre_pre = pre;
        pre = tmp;
        i++;
    }
    return pre;
}
int main() {
    int n;
    scanf("%d", &n);
    printf("%d", climbStairs(n));
}

Now to write the corresponding C function in assembly we use “attribute((naked))” before the function definition to inform the compiler that the function body contains raw assembly code and “asm()” to encapsulate the assembly string.

Below is the assembly code corresponding to the C code

#include <stdio.h>

__attribute__((naked))
int climbStairs_c(int n) {
    __asm__(
        // the paramater n value is passed in register %rdi

        // int pre_pre = 1, pre = 1, i = 2;
        "movl $1, %eax;" // pre_pre = 1
        "movl $1, %ecx;" // pre = 1
        "movl $2, %edx;" // i = 2
    "l1:;"
        // while (i<=n) {
        "cmpl %edi, %edx;"
        "jg end;"  // on condition fail jump to end

        // int tmp = pre + pre_pre;
        "movl %eax, %esi;" // tmp = pre
        "addl %ecx, %esi;" // tmp += pre_pre
        // pre_pre = pre;
        "movl %eax, %ecx;"
        // pre = tmp;
        "movl %esi, %eax;"

        // i++;
        "incl %edx;"
        "jmp l1;"    // jump to loop start again

    "end:;"
        // return pre which is already in %rax register;
        "ret;"
    );
}
int main() {
    int n;
    scanf("%d", &n);
    printf("%d", climbStairs(n));
}

Now let's understand our code step by step:

When a function (procedure) is called in C its param is passed in rdi the register.
Now, we initialize some values using the mov instruction. Since an int is four bytes in size, we prefixed the instruction with l and used eax rather than rax, and the same for other registers, because we only want to read the register’s lower four bytes.
Next, to use a loop we need a checkpoint to come back to. So we define a block named l1 to and use jmp instructions to come back to it.
We use cmp instruction to compare values and in the next line we have used jl instruction to jump to the end of the condition meets otherwise continue to the next instructions.
Once the loop exit and the program reach to end block we can return the answer using eax the register, Since the value is already stored in it we simply return by using ret instruction.

Hooray 🥳, If you reached here it means you have an interest in learning assembly programming. For this, I highly recommend you to check out my repository x86 assembly which I created with a lot of effort, There I have solved a lot of leetcode problems which uses some advanced concept like allocating memory using malloc function calling, nested loops, complex conditions, etc.

If you have any doubts or find any mistakes please let me know in the comments.

Thanks 🙏 for reading this blog, If you find it informative and useful please do like it and follow me for such awesome content.

How to take hidden password from terminal in C/C++

Naman Tamrakar — Tue, 10 Jan 2023 21:48:13 +0000

Have you every wondered, In some terminal programs when they ask for password and you enter it, so either it does not display anything or displays '**********' while typing.

So how these programs take passwords?

The default input mode of terminal is echo, So as soon as we start typing any character in the terminal it show there simultaneously. But we can change this default behavior to do our job of taking the password from terminal without being it visible.

Here is a simple program that demonstrate how we can do this. termios.h is the header file where all the struct and function related to terminal are defined.

#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <string.h>

int getch() {
    int ch;
    // struct to hold the terminal settings
    struct termios old_settings, new_settings;
    // take default setting in old_settings
    tcgetattr(STDIN_FILENO, &old_settings);
    // make of copy of it (Read my previous blog to know 
    // more about how to copy struct)
    new_settings = old_settings;
    // change the settings for by disabling ECHO mode
    // read man page of termios.h for more settings info
    new_settings.c_lflag &= ~(ICANON | ECHO);
    // apply these new settings
    tcsetattr(STDIN_FILENO, TCSANOW, &new_settings);
    // now take the input in this mode
    ch = getchar();
    // reset back to default settings
    tcsetattr(STDIN_FILENO, TCSANOW, &old_settings);
    return ch;
}

int main(void) {
    char password[100];
    int i = 0;
    int ch;

    printf("Enter password: ");
    while ((ch = getch()) != '\n') {
        if (ch == 127 || ch == 8) { // handle backspace
            if (i != 0) {
                i--;
                printf("\b \b");
            }
        } else {
            password[i++] = ch;
            // echo the '*' to get feel of taking password 
            printf("*");
        }
    }
    password[i] = '\0';

    printf("\nYou entered password: %s\n", password);

    return 0;
}

Output:

Enter password: *****
You entered password: naman

Instead of writing this whole program we can either use inbuild function getoass define in unistd.h header to take password without echoing but we don't get much control here like echoing '*' while writing.

#include <stdio.h>
#include <unistd.h>

int main(void) {
    char *password;

    password = getpass("Enter password: ");
    printf("You entered password: %s\n", password);

    return 0;
}

Output:

Enter password:
You entered password: naman

NOTE: The man page of getpass says function opens /dev/tty (the controlling terminal of the process), outputs the string prompt, turns off echoing, reads one line (the "password"), restores the terminal state and closes /dev/tty again. which means that password will not be stored in the shell history.

NOTE: Custom implementation of this program also does not store the password in the shell history even though it is taking input from stdin. The reason is that the getch function reads a character directly from the terminal without waiting for the user to press the enter key, so the password is not passed to the shell as a command.

Thank you ❤️ so much for reading this article. I'm also a student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.

Also, consider sharing and giving a thumbs up If this post helps you in any way.

Can we pass a function to a function in C as a parameter?

Naman Tamrakar — Sun, 31 Jul 2022 12:01:00 +0000

Whenever we work in high-level languages like python and JavaScript we can pass functions as parameters to a function and call it there, But is this also possible in low-level languages like C/C++?

Yes! This is also possible in C/C++ but in a little different way. We know that In C/C++ we have access to memory addresses by pointers. So using a pointer we can also point to a function the same as we do for array, int, char, or any other data type.

So let's start with a very simple program

Code

#include<stdio.h>

int add(int a, int b) {
    return a+b;
}

//                  function as param
//                ___________^_____________
int do_operation(int (* operation)(int, int), int a, int b) {
    return operation(a, b);
}

int main(int argc, char const *argv[])
{
    printf("%d\n", do_operation(add, 10, 20));
    return 0;
}

Output

What's going on in function `do_operation` in the above code?

The parameter int (* operation)(int, int) is the function signature with the name operation. Let me explain more about it.

  int  (* operation) (int, int)
   ^          ^         ^
  left    identifier   right

identifier: function name (operation)
left: function return type (int)
right: params type function accept (int, int)

So we can declare a function like this:

return_type (* function_name) (param1, param2);

But what if we have to use this function in multiple functions? We will have to declare it like this everywhere?

No. Here comes our life saver typedef. We can typedef the function signature and use it anywhere. For example, we can declare our above function signature as:

typedef int (* operation)(int, int);

int do_operation(operation op, int a, int b) {
    return op(a, b);
}

Isn't this very simple and readable?

Source: freepik.com

Now Let's take a complex example of how passing functions as parameters can be useful.

Code

#include <stdio.h>


/**
 * Defining internal functions
*/
int _multiply(int a, int b) {
    return a*b;
}

int _subtract(int a, int b) {
    return a-b;
}

int _add(int a, int b) {
    return a+b;
}


// Functions name
typedef enum {
    ADD, SUBTRACT, MULTIPLY
} Operations;

// declaring function type
typedef int (*function_t)(int, int);

// struct to hold multiple functions
typedef struct {
    Operations op;
    char name[31];
    function_t fun;
} Operation_t;

// Initialize functions array
Operation_t operations[] = {
    {ADD, "Add", _add}, 
    {SUBTRACT, "Subtract", _subtract}, 
    {MULTIPLY, "Multiply", _multiply}
};

/**
 * Function to do multiple operating by just function name
*/
void do_operation(Operations op, int a, int b) {
    for (int i=0; i<sizeof(operations)/sizeof(Operation_t); i++) {
        if (op == operations[i].op) {
            printf("Operation: %s\n", operations[i].name);
            printf("Result: %d\n\n", operations[i].fun(a, b));
            return;
        }
    }

    printf("Invalid Operation\n");
}


int main() {
    // calling the with function name to perform operation
    do_operation(ADD, 10, 20);
    do_operation(SUBTRACT, 10, 20);
    do_operation(MULTIPLY, 10, 20);
    return 0;
}

Output

Operation: Add
Result: 30

Operation: Subtract
Result: -10

Operation: Multiply
Result: 200

From the above code, We can observe that just by passing the function name we can execute it.

This article is highly inspired by the content provided by Jacob Sorber on his youtube channel.

❤️Thank you so much for reading this article. I'm a passionate engineering student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.

Also, consider sharing and giving a thumbs up If this post helps you in any way.

A simple program to detect memory leaks in our C program

Naman Tamrakar — Mon, 25 Jul 2022 17:47:00 +0000

Whenever we program in a language such as C/C++ we have to manage our memory ourselves, there is no way to free unused memory automatically as we get in other languages like Python, Java, etc.

Sometimes we write programs where we leave memory leaks, resulting in a crash of the program after some time and It is very difficult to find where the memory leak is left.

So to debug such an issue we can write a simple program to detect memory leaks in our program.

The idea here is to keep track of every allocation and check Whether it was freed during the program's runtime.

Let's start with a basic data structure to store memory allocation information during the execution of the program.

Data structure code

// We assume max 1000 allocations will take place 
#define MAX_ALLOCATIONS 1000

/* 
Data Structure to keep track of memory allocations

address -> Memory address allocated
size -> Size allocated
line -> Line number where allocation is done
*/
typedef struct {
    size_t address;
    size_t size;
    uint32_t line;
} Mem;

/*
mem -> store all the allocation in array
total_allocated_size -> Keep track total memory allocated
total_free_size -> Keep track total memory freed
*/
struct {
    Mem mem[MAX_ALLOCATIONS];
    size_t total_allocated_size;
    size_t total_free_size;
} data;

Now we will create some helper functions to find, insert and erase memory allocation in the data structure.

Helper functions code

/**
 * Find a memory by its address
 * 
 * @return: Pointer to memory
*/
Mem *find_by_address(size_t address) {
    for (uint32_t i=0; i<MAX_ALLOCATIONS; i++) {
        if (data.mem[i].address == address)
            return &data.mem[i]; // as soon as find return
    }

    // otherwise return null
    return NULL;
}


/**
 * insert memory allocated with size
*/
void insert(size_t address, size_t size, uint32_t line) {
    // check for null
    if (address == 0) {
        WARN("Memory allocation failed", line);
        return;
    }

    Mem *mem = find_by_address(0);
    // if the return value is null we need to increase the MAX_ALLOCATIONS value
    if (mem == NULL) {
        WARN("Max allocations reached", line);
        return;
    }

    // save all the allocation info
    mem->address = address;
    mem->size = size;
    mem->line = line;
    data.total_allocated_size += size;
}

/**
 * Remove the memory allocation
 * 
 * @return: -1 on failure else 0
*/
int erase(size_t address, uint32_t line) {
    if (address == 0) {
        WARN("Tried to free a null ptr", line);
        return -1;
    }

    Mem *mem = find_by_address(address);
    // if the address is not found we assume it is already deleted
    if (mem == NULL) {
        WARN("Double free detected", line);
        return -1;
    }

    // set address to null and update info
    mem->address = 0;
    data.total_free_size += mem->size;
    return 0;
}

At the end of the program, we will print a detailed report of memory leaks.

Code

void print_report() {
    printf("\nLeak Summary\n");
    printf("Total Memory allocated %lu bytes\n", data.total_allocated_size);
    printf("Total Memory freed     %lu bytes\n", data.total_free_size);
    printf("Memory Leaked          %lu bytes\n\n", 
        data.total_allocated_size - data.total_free_size);

    if (data.total_free_size != data.total_allocated_size) {
        printf("Detailed Report\n");
        for (int i=0; i<MAX_ALLOCATIONS; i++) {
            if (data.mem[i].address != 0) {
                printf("Memory leak at line %d: (%lu bytes)\n", 
                    data.mem[i].line,
                    data.mem[i].size);
            }
        }
    }
}

Now create default allocator intercepted functions to insert while memory allocation and erase while free.

Custom allocator functions

// Create allocator functions
void *_malloc(size_t size, uint32_t line) {
    void *ptr = malloc(size);

    // insert to memory data
    insert((size_t)ptr, size, line);

    return ptr;
}

void _free(void *ptr, uint32_t line) {
    // erase memory data
    if (erase((size_t)ptr, line) == 0)
        free(ptr);
}

Here we redefine the default allocator function such as malloc and free with our intercepted functions.

Redefine default allocator functions

// redefine allocator functions
#define malloc(size) _malloc(size, __LINE__)
#define free(ptr) _free(ptr, __LINE__)

That's it!

Complete Code

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#define MAX_ALLOCATIONS 100
#define WARN(msg, line) (printf("Warning %d: %s\n", line, msg))

/* 
Data Structure to keep track of memory allocations
*/
typedef struct {
    size_t address;
    size_t size;
    uint32_t line;
} Mem;

struct {
    Mem mem[MAX_ALLOCATIONS];
    size_t total_allocated_size;
    size_t total_free_size;
} data;

/**
 * Find a memory by its address
 * 
 * @return: Pointer to memory
*/
Mem *find_by_address(size_t address) {
    for (uint32_t i=0; i<MAX_ALLOCATIONS; i++) {
        if (data.mem[i].address == address)
            return &data.mem[i]; // as soon as find return
    }

    // otherwise return null
    return NULL;
}


/**
 * insert memory allocated with size
*/
void insert(size_t address, size_t size, uint32_t line) {
    // check for null
    if (address == 0) {
        WARN("Memory allocation failed", line);
        return;
    }

    Mem *mem = find_by_address(0);
    // if the return value is null we need to increase the MAX_ALLOCATIONS value
    if (mem == NULL) {
        WARN("Max allocations reached", line);
        return;
    }

    // save all the allocation info
    mem->address = address;
    mem->size = size;
    mem->line = line;
    data.total_allocated_size += size;
}

/**
 * Remove the memory allocation
 * 
 * @return: -1 on failure else 0
*/
int erase(size_t address, uint32_t line) {
    if (address == 0) {
        WARN("Tried to free a null ptr", line);
        return -1;
    }

    Mem *mem = find_by_address(address);
    // if the address is not found we assume it is already deleted
    if (mem == NULL) {
        WARN("Double free detected", line);
        return -1;
    }

    // set address to null and update info
    mem->address = 0;
    data.total_free_size += mem->size;
    return 0;
}

void print_report() {
    printf("\nLeak Summary\n");
    printf("Total Memory allocated %lu bytes\n", data.total_allocated_size);
    printf("Total Memory freed     %lu bytes\n", data.total_free_size);
    printf("Memory Leaked          %lu bytes\n\n", 
        data.total_allocated_size - data.total_free_size);

    if (data.total_free_size != data.total_allocated_size) {
        printf("Detailed Report\n");
        for (int i=0; i<MAX_ALLOCATIONS; i++) {
            if (data.mem[i].address != 0) {
                printf("Memory leak at line %d: (%lu bytes)\n", 
                    data.mem[i].line,
                    data.mem[i].size);
            }
        }
    }
}

// Override allocation functions
void *_malloc(size_t size, uint32_t line) {
    void *ptr = malloc(size);

    // insert to memory data
    insert((size_t)ptr, size, line);

    return ptr;
}

void _free(void *ptr, uint32_t line) {
    // erase memory data
    if (erase((size_t)ptr, line) == 0)
        free(ptr);
}

// redefine allocator functions
#define malloc(size) _malloc(size, __LINE__)
#define free(ptr) _free(ptr, __LINE__)

int main() {
    int *n1 = malloc(sizeof(int));
    free(n1);

    int *n2 = NULL;
    free(n2);

    int *n3 = malloc(sizeof(int));
    free(n3);
    free(n3);

    int *n4 = malloc(sizeof(int));

    print_report();
    return 0;
}

Output

naman@namantam1:~/programs$ gcc main.c && ./a.out
Warning 143: Tried to free a null ptr
Warning 147: Double free detected

Leak Summary
Total Memory allocated 12 bytes
Total Memory freed     8 bytes
Memory Leaked          4 bytes

Detailed Report
Memory leak at line 149: (4 bytes)

From the above output, It is clear that it detects all the memory leaks, double-free.

Note: This program will not be able to keep track of memory allocation done by inbuild or any third-party library. So if we free memory allocated in library call, It will show double free, We can simply ignore them.

❤️Thank you so much for reading this article. I'm a passionate engineering student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.

Also, consider sharing and giving a thumbs up If this post helps you in any way.

Ways to get the file size in C

Naman Tamrakar — Sat, 16 Jul 2022 19:27:00 +0000

In this article, I will discuss two approaches for getting the file size using the C programming language.

Approach 1

When we have to get the file size first approach that comes to our mind is to open the file, seek the cursor to the end of the file, and then get the position of the cursor which is nothing but the size of the file.

Let's understand how can we achieve this.

First, open a file using fopen. The first argument is the file path and the second argument is mode and it returns the file descriptor. Since we don't have to modify the file open it in read mode using "r".
Now move the cursor to the end of the file using fseek which takes the following arguments respectively.
- fd file descriptor of the file opened.
- offset how much to offset w.r.t the third argument position.
- whence from where the cursor should consider moving from. We have three options for it, SEEK_SET relative to the start of the file, SEEK_CUR relative to the current position, and SEEK_END relative to the end of the file.

Since we have to move to the end of the file we take relative to the end of the file and offset it as zero, as we have to move zero from the end. fseek return -1 if it fails.

Now use ftell to get the current position which takes fd as an argument and returns the current position which is our file size. On failing it returns -1.

NOTE: If the cursor move by 1 unit we consider it as 1 byte because the size of char is 1 byte and fopen reads the file character by character only.

Code

#include <stdio.h>

// function get file size
long get_file_size(char *);

int main() {
    char *filename = "a.out";
    printf(
        "Size of file `%s` is %ld\n", 
        filename, 
        get_file_size(filename)
    );

    return 0;
}

long get_file_size(char *filename) {
    FILE *fp = fopen(filename, "r");

    if (fp==NULL)
        return -1;

    if (fseek(fp, 0, SEEK_END) < 0) {
        fclose(fp);
        return -1;
    }

    long size = ftell(fp);
    // release the resources when not required
    fclose(fp);
    return size;
}

Output

Size of file `a.out` is 51880 bytes

Approach 2

In this approach, we use stat API to get the file information which also includes file size.
For this, we simply call the stat function which takes a file path as the first argument and pointer to the stat struct variable as the second argument and returns -1 on failure.

To get the file size we can simply use the st_size attribute.

Code

#include <sys/stat.h> // stat

// inherit the above base code here

long get_file_size(char *filename) {
    struct stat file_status;
    if (stat(filename, &file_status) < 0) {
        return -1;
    }

    return file_status.st_size;
}

Output

Size of file `a.out` is 51880 bytes

Using this we can get some other information about a file such as permission, creation time, user id, group id, etc. Also, there are some other functions defined that can be used based on requirements. Check out its man page for more info.

Which one should be used?

The second approach is more recommended because of the following reason.

It's fast as we don't have to open a file which in the first approach has to be done. Some compilers may buffer a file on opening which makes the first approach slower.
The code is more clear to other developers that we are trying to get file info.

But this code is not portable. As other APIs are developed on OS like windows to get file info.

Whereas the first approach code is portable. As same code works normally without any problem.

So, in conclusion, which strategy we should take is entirely dependent on our requirements.

This article is highly inspired by the content provided by Jacob Sorber on his youtube channel.

❤️Thank you so much for reading this article. I'm a passionate engineering student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.

Also, consider sharing and giving a thumbs up If this post helps you in any way.

Ways to get and set environment variables in C

Naman Tamrakar — Fri, 15 Jul 2022 10:54:05 +0000

In this article, I will discuss some of the most simple ways to access environment variables in C language programming.

Approach 1

In this method, we simply used the environ variable by extending it using the extern keyword.

Code

#include <stdio.h>

// https://man7.org/linux/man-pages/man7/environ.7.html
extern char **environ;

int main(int argc, char **argv) {
    // list out all the environment variables
    for (int i=0; environ[i]!=NULL; i++) {
        printf("%d: %s\n", i, envp[i]);
    }

    return 0;
}

Check out environ man page for more info.

Approach 2

Most of the students don't know that the main function can also receive a third argument which is nothing but the array of environment variables.

NOTE: The third argument may not support all compilers. But it should work on the latest compiler versions.

Code

#include <stdio.h>

int main(int argc, char **argv, char **envp) {
    // list out all the environment variables
    for (int i=0; envp[i]!=NULL; i++) {
        printf("%d: %s\n", i, envp[i]);
    }

    return 0;
}

Approach 3

In this method, we use the getenv and setenv functions defined

getenv takes one argument which is the environment variable name and returns a null-terminated char pointer. If the passed name does not exist, it returns NULL.

setenv takes three arguments. The first one is the environment variable name, the second is its value and the third one is an int flag which if non-zero overwrites the already existing environment variable with the same name.

NOTE: setenv doesn't set the environment variable permanently but for the current process and its child process only. It means setenv the environment variables are visible only in the current process and its child ones.

Check out some other functions like clearenv, and putenv in man page for more operations.

Code

#include <stdio.h>
#include <stdlib.h> // setenv, getenv

int main(int argc, char **argv) {
    char *user = getenv("USER"),
        *hosttype = getenv("HOSTTYPE"),
        *hostname = getenv("HOSTNAME");
    printf("USER: %s\n", user ? user : "null");
    printf("HOSTTYPE: %s\n", hosttype ? hosttype : "null");
    printf("HOSTNAME: %s\n", hostname ? hostname : "null");

    setenv("USER", "namantam1", 1);
    printf("updated USER: %s\n", getenv("USER"));

    return 0;
}

Output

USER: naman
HOSTTYPE: x86_64
HOSTNAME: null
updated USER: namantam1

Application

We can set log verbosity based on the environment variable.
One can set the environment variable in the parent process and access the same in its child process. Check out this article to know how to clone the current process into a child process.

❤️Thank you so much for reading this article. I'm a passionate engineering student learning new things so If you find any mistakes or have any suggestions please let me know in the comments.

Also, consider sharing and giving a thumbs up If this post helps you in any way.

A common pitfall when using sizeof() with pointers

Naman Tamrakar — Wed, 13 Jul 2022 10:42:00 +0000

There is a common mistake made by new student when they use sizeof operator with pointers to get number of bytes allocated.

NOTE: sizeof returns the size in bytes and 1 byte = 8 bit

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *c = malloc(10);

    printf("Bytes allocated: %ld\n", sizeof(c));
    return 0;
}

They expect the output of above program as 10 bytes. But it doesn't work like that.

The output will be

Bytes allocated: 8

But why? When we allocated 10 bytes then it should output 10 bytes. Why It is showing 8 bytes?

Then answer to this question is in the above code we are not measuring the amount of bytes allocated but the size of pointer which will be 8 bytes for all 64 bit compiler and 4 bytes for 32 bit compiler. (My compiler is 64-bit)

So If one want it to get later it should be store in some variable explicitly.

Now the question how we are able to do same for an array which also behaves like pointer.

Let's check the below example.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int c[10];

    printf("Bytes allocated: %ld\n", sizeof(c));
    return 0;
}

Output

Bytes allocated: 40

The output of above program is as expected because the size of int is 4 bytes so total 4x10 = 40 bytes it returns.

In the above statement it said array behaves like pointer but it isn't. It is allocated in stack not heap that may be one of the reason that sizeof is able to get size of bytes allocated to an array.

❤️Thank you so much for reading it completely. If you find any mistake please let me know in comments.

Also consider sharing and giving a thumbs up If this post help you in any way.

Ways to copy struct in c/c++

Naman Tamrakar — Tue, 12 Jul 2022 06:39:18 +0000

Today I am gonna show some of the ways to copy struct in c/c++.

Approach 1

In this approach we will copy attribute by attribute of struct into another struct to make a copy. The rest code is self explainable.

Code

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[63];
    enum { MALE, FEMALE, OTHER } gender;
    int age;
    float height;
} User;

void print_user(User *user) {
    printf(
        "(Name: %s, Gender: %s, age: %d, height %.1f)\n",
        user->name,
        user->gender == MALE ? "Male" :
            user->gender == FEMALE ? "Female" : "Other",
        user->age,
        user->height
    );
}

int main() {
    User user = {"Naman", MALE, 21, 5}, user1;

    // Approach 1 
    strncpy(user1.name, user.name, sizeof(user.name));
    //        ^dest      ^src           ^size to copy 
    user1.gender = user.gender;
    user1.age = user.age;
    user1.height = user.height;

    printf("user: "); print_user(&user);
    printf("user copy: "); print_user(&user1);

    return 0;
}

Output

user: (Name: Naman, Gender: Male, age: 21, height 5.0)
user copy: (Name: Naman, Gender: Male, age: 21, height 5.0)

Disadvantage in this approach

Although It is very clear that this code is written for copying the struct. But as the size of struct increase It becomes more difficult to type all the attributes and So the chance of typo also increases.

So what's the solution for this. Let's discuss our next approach.

Approach 2

Instead of copying attribute by attributes We can also copy whole struct using memcpy and rest code will be same. Just copy whole struct in one line only.

// Inherit above code here

int main() {
    User user = {"Naman", MALE, 21, 5}, user1;

    // Approach 2
    memcpy(&user1, &user, sizeof(user));
    //      ^dest   ^src    ^size to copy 

    printf("user: "); print_user(&user);
    printf("user copy: "); print_user(&user1);

    return 0;
}

Output

user: (Name: Naman, Gender: Male, age: 21, height 5.0)
user copy: (Name: Naman, Gender: Male, age: 21, height 5.0)

Approach 3

We can also use assignment operator to make copy of struct.

Code

int main() {
    User user = {"Naman", MALE, 21, 5}, user1;

    // Approach 3
    user1 = user;

    printf("user: "); print_user(&user);
    printf("user copy: "); print_user(&user1);

    return 0;
}

Output

user: (Name: Naman, Gender: Male, age: 21, height 5.0)
user copy: (Name: Naman, Gender: Male, age: 21, height 5.0)

A lot of people don't even realize that they can copy a struct this way because one can't do same it with an array. Similarly one can return struct from a function and assign it but not array. The compiler do all the copying stuff behind the scene for us.

NOTE: When dealing with struct pointers approach 3 doesn't work as assigning one pointer to another doesn't make copy instead just point to new memory address. So if we modify new variable, original one is also affected.

❤️Thank you so much for reading it completely. If you find any mistake please let me know in comments.

Also consider sharing and giving a thumbs up If this post help you in any way.

How to create new process of current program in c using fork

Naman Tamrakar — Sun, 10 Jul 2022 13:56:20 +0000

In this post I will explain how one can clone or create new process of current c program using fork.

Why it is named fork?

When we create child processes and these child processes can also create their own child process It form a tree like structure, So May be that is the reason it is named as fork.

So lets write a simple program to create a clone of current process.

#include <stdio.h>
#include <unistd.h> // fork

int main() {
    fork();
    printf("Hello world -> My PID is %d\n", getpid());
    return 0;
}

Output

Hello world -> My PID is 18131
Hello world -> My PID is 18132

So let me explain what is happening above.

The execution of program start from the main function and it first get fork() which create a new clone of current process and now both child parent process continues from here and get statement printf so print it on console.

Note: Whenever program get a fork() statement then at the same instant a clone of it is create and start executing from there only in both the process i.e. Parent and Child.

Let's explore more about fork by taking this example.

#include <stdio.h>
#include <unistd.h> // fork

int main() {
    printf("Program execution start here.\n");
    int r = fork();
    printf(
        "Hello world -> My PID is %d, I am %s process\n", 
        getpid(), 
        r==0 ? "child" : "parent"
    );
    return 0;
}

Output

Program execution start here.
Hello world -> My PID is 548, I am parent process
Hello world -> My PID is 549, I am child process

Let me explain what is happening above.

Program execution start and get first line printf so print it on console then get fork statement so create new child process at this line. Now in parent program fork return pid of child process but in child process it returns 0 so we check for return value and print based on that only.

NOTE: fork() returns -1 if it failed to clone the process.

Here is one more example

#include <stdio.h>
#include <unistd.h> // fork

int main() {
    printf("Program execution start here.\n");

    int r;
    for (int i=0; i<5; i++) {
        if ((r=fork())==0) {
            break;
        }
    }
    printf(
        "Hello world -> My PID is %d, I am %s process\n", 
        getpid(), 
        r==0 ? "child" : "parent"
    );
    return 0;
}

Output

Program execution start here.
Hello world -> My PID is 635, I am child process
Hello world -> My PID is 636, I am child process
Hello world -> My PID is 637, I am child process
Hello world -> My PID is 638, I am child process
Hello world -> My PID is 634, I am parent process
Hello world -> My PID is 639, I am child process

The output of this program seems weird as parent program output before the last child process. Let me explain what happening in the above code.

In the loop we execute fork() and response is stored in predefined variable r. So in the child process It will be zero so loop breaks out in child process and further program executes. But in parent program loop will not break and it will continue to create new child process.

So these child process are being created and executed in parallel by CPU. But the last child process execute after the child process because after creation of last child process loop breaks and continues to execute printf statement in parent process.

But why last process executed after parent?

One reason may be it take some time to make clone of child process in memory and schedule it by CPU to execute. But the parent program that is already running so it execute first.

NOTE: The above reason for execution order may be not accurate. It is just one assumption made by me. So the execution order may vary from machine to machine.

So that's it about fork to clone current process. In the above I may be wrong somewhere. Please write in comment If you find so. Thank you so much for reading it completely.

Summary

fork can be used to clone current process.
The execution of child process start from where we get fork() statement. So child process execute from there only.
fork returns PID of child process created in parent program but returns 0 in child process created. So one can use their logic based on return value to differentiate between child and parent process.

Please give it a thumbs up If you like this post.

DEV Community: Naman Tamrakar

JWT Token authorisation in spring boot 3 without any external library

output

output

Source code

Conclusion

Solve leetcode climbing stairs problem in x86_64 assembly language

Can a leetcode question be answered in x86–64 assembly language?

How to take hidden password from terminal in C/C++

Can we pass a function to a function in C as a parameter?

What's going on in function do_operation in the above code?

But what if we have to use this function in multiple functions? We will have to declare it like this everywhere?

A simple program to detect memory leaks in our C program

Ways to get the file size in C

Approach 1

Approach 2

Which one should be used?

Ways to get and set environment variables in C

Approach 1

Approach 2

Approach 3

Application

A common pitfall when using sizeof() with pointers

Ways to copy struct in c/c++

Approach 1

Approach 2

Approach 3

How to create new process of current program in c using fork

What's going on in function `do_operation` in the above code?