[TASK] Authentification - GTK

[RaresRacsan]

Feature Overview

What is the purpose of this feature?

• Implement user authentication for the GTK client/server application. This feature will allow users to securely authenticate before interacting with the server, providing a layer of security for file transfer operations.
• The transfet should have a Sender Name and a Receiver Name

Objectives

What are the key goals of this feature?

1. Allow users to enter credentials (username) to authenticate before they can access file transfer functionalities.
2. Implement authentication via the GTK-based user interface (UI), including forms for inputting username and password.
3. Integrate the authentication process with the server, ensuring that only authenticated users can interact with the file transfer service.
4. Provide feedback to users about the success or failure of the authentication attempt.
5. Ensure security best practices are followed, such as secure password storage and transmission.

Requirements

What are the technical and functional requirements for this feature?

• Functional Requirements:

  • The client should prompt for username and password when connecting to the server.
  • The server should verify the credentials against a user database (can be a simple file or external authentication service).
  • The GTK UI should display appropriate error messages if the authentication fails.
  • If authentication is successful, the user should be allowed to interact with the file transfer features (e.g., selecting and transferring files).

• Technical Requirements:

  • Use the GTK 3 library for creating the authentication UI (e.g., text input fields, buttons).
  • Implement a secure mechanism for password handling (e.g., password hashing and salting).
  • Use a communication protocol (e.g., TCP/IP) to securely transmit credentials from the client to the server.
  • Ensure proper error handling and validation for input fields (e.g., empty fields, invalid characters).

Design and Architecture

Describe the design and technical architecture:

1. Key components:
   • Client-side:
     • A GTK window containing input fields for username and password.
     • A button for submitting credentials.
     • Error message display for invalid authentication.
   • Server-side:
     • A simple authentication mechanism to verify the username and password.
     • Can be a text-based file or database with stored usernames and hashed passwords.
   • Protocol:
     • Secure communication between client and server to prevent sending credentials in plain text (e.g., use SSL/TLS or simple encryption).

Implementation Plan

Outline the steps to implement the feature:

1. Client-Side Authentication UI:

   • Use GTK to create a login form with fields for username and password.
   • Add a submit button and handle user interaction with event listeners.

2. Server-Side Authentication Logic:

   • Implement a basic user database (can be a text file for simplicity) that stores usernames and passwords (hashed).
   • On receiving the credentials from the client, verify them against the stored values.
   • If credentials match, allow file transfer; if not, reject the connection and send an error message to the client.

3. Secure Transmission:

   • Implement basic encryption or use an SSL/TLS connection to transmit the authentication data securely. (if possible)

4. Error Handling and Feedback:

   • Add error handling for invalid credentials or network errors.
   • Display an error message on the client-side if authentication fails (e.g., "Invalid username or password").
   • Provide success messages for successful authentication.

5. Testing and Validation:

   • Test the authentication system with valid and invalid credentials.
   • Test the secure transmission of data between the client and server.
   • Ensure that authentication errors are correctly handled and displayed in the GTK UI.

Testing Plan

Describe how this feature will be tested:

1. Unit Tests:

   • Test the GTK client UI to ensure the form correctly accepts and validates user input.
   • Test server-side authentication logic to ensure the username and password validation works as expected.

2. Integration Tests:

   • Test the end-to-end authentication flow between the client and server.
   • Ensure that incorrect credentials are rejected and correct credentials allow access to file transfer features.

3. Security Tests:

   • Verify that credentials are not sent in plain text (use encryption or SSL/TLS).
   • Test with different user credentials to ensure the authentication system is robust.

4. Usability Tests:

   • Ensure that the authentication interface is user-friendly and that error messages are clear and helpful.
   • Test the experience for the user when authentication fails (e.g., retrying or resetting credentials).

Risks and Challenges

Identify potential risks or challenges for this feature:

• User Experience: The login form and error messages must be user-friendly, especially in handling failed authentication attempts.