TechDesk Overview

TechDesk is built to facilitate seamless interaction between users and administrators within an organization. Users can submit tickets for any issues they encounter, which are then assigned to the relevant department's admin for resolution. The platform supports real-time communication, enabling users and admins to discuss and resolve issues promptly. Additionally, TechDesk includes a chatbot feature, providing immediate assistance and guiding users through common queries even before they start their trial.

Introduction

TechDesk is a powerful helpdesk solution designed to meet the demands of modern organizations. Its comprehensive features, including efficient ticket management, real-time communication, robust admin controls, and AI-driven chatbot support, make it an indispensable tool for enhancing customer service and operational efficiency. By choosing TechDesk, you are investing in a platform that not only addresses your current needs but also evolves with your organization, ensuring sustained excellence in support services.

Key Features

• Ticket Management: Users can quickly submit tickets through a user-friendly interface. Each ticket includes detailed information about the issue, allowing admins to understand and address the problem efficiently.
• Real-Time Communication: TechDesk supports real-time messaging between users and admins, facilitating quick discussions and resolutions. This feature helps in clarifying doubts and providing immediate feedback.
• Admin Management: Admins can manage user accounts, assign roles, and set permissions. This ensures that only authorized personnel have access to specific features and information.
• Chatbot Assistance: The TechDesk chatbot is available 24/7 to assist users with common queries and guide them through the process of submitting tickets. This feature helps in reducing the load on human agents and provides users with immediate answers.
• Security and Compliance: TechDesk employs advanced security measures to protect user data. This includes encryption, secure authentication, and regular security audits.

Benefits

• Improved Efficiency
• Enhanced User Experience
• Scalability
• Cost-Effectiveness

Audience:

This guide is specified for developers to integrate their application with TechDesk

JWT (JSON WEB TOKEN)

JWTs are commonly used for authentication in web applications. When a user logs in, the server generates a JWT containing information about the user (payload) and signs it. The client then receives this token and includes it in subsequent requests to authenticate itself. JWTs can also be used for exchanging data securely between parties.

Generate Access Token

• Include User Information : Gather the required information to include in the JWT token:
  • User Email
  • Session Start Time
  These will be included as claims within the JWT payload.
• Encode Payload: Create a JSON object containing the user information. For example:

  {
  "email": "user@example.com",
  "sessionStartTime": "2024-05-20T15:20:30Z"
  }
  

• Encrypt Payload: Use JWE (JSON Web Encryption) to encrypt the payload. This ensures that the token remains secure during transmission.
• Include Token in Requests: Include the encrypted JWT token in the headers of your API requests to authenticate and interact with the service.
• Example Request:

  
  GET https://helpdesk.techbitsolutions.com/externalconnect?accessToken=eyJhbGciOiJBMjU2R0NNS1ciLCJpdiI6Il8zbjdCSmpCTk0yM3hFNzIiLCJ0YWciOiI5c0kyM0hldmdVX3FZMGlWUnd2TFlnIiwiZW5jIjoiQTI1NkdDTSJ9.x4fQfv7JxIRg57-SaKj2pC5Nls9jwQb28vun31KV8JY.F-sSYCpA8T8h0kyD.iEeG-79BqhyIGHHbOOZWAZGKU91MpNafa5ufPdmZRpqZwymHs4xe1hR4F5_ipWU5fyMQogb-mRFwpe-4Of6-5UHsEMhMHnH3BFnm9chAiWt9z-DSJEkQ4XxaUUT-hQQ4SEbaXojvFhoXHJ0Y-Wku0w0MeJHOsZ62EL4aeCC8dWjv_kQOis5k1OM4wAaVatdSA0YijzRuA0ujmRkEu3s.K7wkA50YvMQK3q1Nv1XQUQ&applicationName=ExampleApplicationName
  
  

• Query Parameters:

  accessToken: A JWT containing user email and session start time.
  applicationName: The name of your application registered in Helpdesk.
  

Jose Library for Encryption

The node-jose library simplifies the implementation of JSON Web Encryption (JWE) in Node.js applications, providing robust security mechanisms for protecting sensitive data in transit. It's widely used in applications that require secure communication and data exchange between parties. Adjust the key generation and encryption methods based on your specific security requirements and cryptographic best practices.

• JSON Web Encryption (JWE): node-jose allows you to encrypt sensitive information in JSON format, ensuring confidentiality during transmission over potentially insecure networks.
• Key Management: It provides methods (createKeyStore, generate) to generate cryptographic keys (in this example, RSA keys), which are essential for both encryption and decryption operations.
• Encryption and Decryption: The library offers convenient APIs (JWE.createEncrypt, JWE.createDecrypt) to handle JWE operations. You can encrypt data with a public key and decrypt it with the corresponding private key securely.
• Compatibility: node-jose supports various algorithms and formats specified by the JSON Web Algorithms (JWA) standard, ensuring interoperability with other compliant libraries and systems.

Generate and Encrypt Token

• C#
• Node

              
public string GenerateToken(CipherDataModel dataModel)
{

// Create claims for the JWT Access token
  var claims = new[]
  {
    new Claim("email", dataModel.Email),
    new Claim("sessionstarttime", dataModel.SessionStartTime),
  };
  
  //Create claims for JWT User Identity Token
  var claims = new[]
  {
    new Claim("email", userResponse.Email),
    new Claim("firstName", userResponse.FirstName),
    new Claim("lastName", userResponse.LastName),
    new Claim("mobilePhone", userResponse.PhoneNumber),
    new Claim("userId", userResponse.UserId),
    new Claim("userName", userResponse.UserName),
    new Claim("userType", userResponse.UserType === "Admin" ? "Admin" : "NormalUser")
  };

  // Pass the secret key you've generated in helpdesk
  var clientSecretKey = _config["ConnectWithHelpdesk:ClientSecretKey"];
  
  var identity = new ClaimsIdentity(claims);
  var tokenHandler = new JwtSecurityTokenHandler();
  var securityToken = tokenHandler.CreateToken(new SecurityTokenDescriptor
  {
    Subject = identity,
    SigningCredentials = new SigningCredentials(
        new SymmetricSecurityKey(Convert.FromBase64String(clientSecretKey)),
        SecurityAlgorithms.HmacSha256Signature)
  });
  
  var token = tokenHandler.WriteToken(securityToken);
  var encryptedToken = EncryptToken(token, clientSecretKey);
  
  return encryptedToken;
}

//Encrypt Token
private string EncryptToken(string token, string clientSecretKey)
{
  var payload = JWT.Payload(token);
  var encryptedToken = JWT.Encode(payload, Convert.FromBase64String(clientSecretKey), JweAlgorithm.A256GCMKW, JweEncryption.A256GCM);
  return encryptedToken;
}
                
                

              
const cors = require('cors');
const jose = require('jose');
const { JWK, JWE } = require('jose');

const genereateHelpdeskToken = async ( { userId }) => {
    try {
        const user = await knex('users').where('id', userId).first();
        
        //Payload for Access Token
        const payload = {
            "email": user.email,
            "sessionStartTime": new Date().toISOString().split('.')[0] + 'Z',
        };

        //Payload for User Identity Token
        const payload = {
          "UserId": userId,
          "Email": user.email,
          "FirstName": user.first_name,
          "LastName": user.last_name,
          "Username": user.email,
          "UserType": user.role_id === ROLE.SUPER_ADMIN ? "admin" : 'NormalUser',
          "MobileNumber": user.phone_number,
        }

        const clientSecretKey = process.env.HELPDESK_SECRET;
        // const secretBuffer = Buffer.from(clientSecretKey, 'base64');
        const encryptionKey = {
            kty: 'oct',
            k: clientSecretKey,
            alg: 'A256GCMKW',
            use: 'enc',
        };

        const encryptedToken = await new jose.EncryptJWT(payload)
            .setProtectedHeader({ alg: 'A256GCMKW', enc: 'A256GCM' })
            .setIssuedAt()
            .setExpirationTime(process.env.JWT_EXPIRES_IN)
            .encrypt(await jose.importJWK(encryptionKey, 'A256GCMKW'));

        return encryptedToken;
    } catch (error) {
        console.error('Error generating helpdesk token:', error);
        throw error;
    }
}

//Encrypt Token

const verifyHelpdeskToken = async (token) => {
  try {
      const clientSecretKey = process.env.HELPDESK_SECRET;
      const decryptionKey = {
          kty: 'oct',
          k: clientSecretKey,
          alg: 'A256GCMKW',
          use: 'enc',
      };

      const { payload } = await jose.jwtDecrypt(token, await jose.importJWK(decryptionKey, 'A256GCMKW'));

      return payload;
  } catch (error) {
      console.error('Error verifying helpdesk token:', error);
      throw error;
  }
};
                
                

Why Use JWE (JSON Web Encryption)?

JWE is a security measure that enhances JWT (JSON Web Token) functionality. While JWTs are useful for authorization, JWE adds an extra layer of protection for sensitive information within the token.

JWT vs. JWE for Sensitive Data

Why Choose JWE for Sensitive Data?

• Enhanced Security : JWE encrypts the payload, making it unreadable even if intercepted. Only the authorized recipient with the decryption key can access the information.
• Data Protection : Sensitive information like user credentials or financial data requires extra protection. JWE ensures this data remains confidential during transmission.

When Might JWT Be Sufficient?

• Non-Sensitive Claims : If your token primarily contains information used for authorization (e.g., user ID, role), JWT might be enough. These claims are typically not highly sensitive.
• Performance: JWTs are smaller and faster to process compared to JWE tokens. This can be beneficial in performance-critical scenarios.

Invalid Token

If the token provided is not valid, the server will respond with a status code of 400 and a message indicating that the token is invalid. This can occur if the token has been tampered with, is malformed, or fails verification.

{
"status": 400,
"message": "Invalid token"
}

Token Expired

When the token has passed its expiration time, the server will respond with a status code of 400 and a message indicating that the token has expired. This indicates that the client needs to use the refresh token to obtain a new access token.

{
"status": 400,
"message": "Token expired"
}

Server Errors

If the Helpdesk system encounters an error while processing the token, it will respond with an appropriate HTTP status code and a message describing the error. These errors could be due to server-side issues, such as database connectivity problems or other internal errors.

{
"status": 500,
"message": "Internal server error"
}