User types

 
     alg: "HS256"
    }.
    {
     jti: "f69fbb80-2967-4985-afae-6cfe6c0786c4",
     sub: "[email protected]",
     stp: "email",
     iss: "e7de374f-e590-4429-ae2d-54be7e90a356",
     iat: 1582700204,
     exp: 1582700264,
     ski: "52",
     sid: "85a53925-7bbb-46be-84f8-2b00c4a48a4d"
    }.
    xqDTU5RYS-KJRL7zyuwra2PDfZBNDHI3bbZHHrjQUjA
 

 
    liveChat('auth', '[personalizationToken]', function(error, result) {
      if (error) {
        ... // do process error
        console.log(error.code, error.message)
      } else {
      ... // no errors
      }
    });
 

 
    liveChat('logout', null, function(error, result) {
      if (error) {
        ... // do process error
        console.log(error.code, error.message)
      } else {
      ... // no errors
      }
    });
 

 
    // Download PHP-JWT: https://github.com/firebase/php-jwt
    composer require firebase/php-jwt
    use \Firebase\JWT\JWT;
    $timestamp = time();
    $securityKey = json_decode('Copied data from Infobip Live Chat Security Key');
    $payload = {
      'jti' => 'random UNIQUE String',
      'stp' => '[email | msisdn | externalPersonId]',
      'sub' => '[[email protected] | +PhoneNumber | ExtPersonID]',
      'iss' => 'Widget ID',
      'iat' => $timestamp,
      'exp' => $timestamp + 15,
      'ski' => $securityKey->id,
      'sid' => 'Session Identifier'
    };
     $token = JWT::encode($payload, base64_decode($securityKey->key));
 

    // Install jsonwebtoken: npm install jsonwebtoken --save-dev
    var jwt = require('jsonwebtoken');
    const securityKey = JSON.parse('Copied data from Infobip Live Chat Security Key');
    const timestamp = Math.floor(date.getTime()/1000);
    var payload = {
      jti: 'random UNIQUE String',
      stp: '[email | msisdn | externalPersonId]',
      sub: '[[email protected] | +PhoneNumber | ExtPersonID]',
      iss: 'Widget ID',
      iat: timestamp,
      exp: timestamp + 15,
      ski: securityKey.id,
      sid: 'Session Identifier'
    };
    var token = jwt.sign(payload, Buffer.from(securityKey.key, 'base64'));

 
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.nimbusds.jose.JWSAlgorithm;
    import com.nimbusds.jose.JWSHeader;
    import com.nimbusds.jose.crypto.MACSigner;
    import com.nimbusds.jwt.JWTClaimsSet;
    import com.nimbusds.jwt.SignedJWT;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Component;
 
    import java.time.Instant;
    import java.util.*;
 
    @Component
    class PersonalisationTokenGenerator {
      // IMPORTANT: securityKey here it is a copied data from Infobip Live Chat Security Key
      public ResponseEntity authorize(String widgetId, String securityKey) {
        try {
          // simple example how personalizationToken issuing process could looks like:
          ObjectMapper objectMapper = new ObjectMapper();
          SecurityKeyHMAC secret = objectMapper.readValue(securityKey, SecurityKeyHMAC.class);
          MACSigner personalizationTokenSigner = new MACSigner(Base64.getDecoder().decode(secret.getKey()));
          JWTClaimsSet claimsSet = new JWTClaimsSet.Builder()
            // generate always UNIQUE ID because Infobip will remember it and not permit to use it twice! As ID can be used ant string
            .jwtID(UUID.randomUUID().toString())                                      // unique ID of this token. Mandatory
            .subject("[email protected]")                                     // person destination in Infobip People service. Mandatory
            .issuer(widgetId)                                                         // which widget it belongs. Mandatory
            .issueTime(new Date())                                                        // when created. Mandatory
            .expirationTime(Date.from(Instant.now().plusMillis(15000))) // Optional, e.g. when this token should be invalidated if not yet used,
            // if not set then by default token will be invalidated after 15 seconds after issueTime
            .claim("ski", secret.getId())                                                 // needs for security validation. Mandatory
            .claim("stp", "email")                                                   // type of person destination in Infobip People service. Mandatory
            .claim("sid", "Session identifier")                                      // unique session identifier. Optional
            .build();
          SignedJWT personalizedToken = new SignedJWT(new JWSHeader(JWSAlgorithm.HS256), claimsSet);
          personalizedToken.sign(personalizationTokenSigner);
          return ResponseEntity.ok(personalizedToken.serialize());
        } catch (Exception ex){
          // do some logging stuff
          ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
      }
    }
 
    class SecurityKeyHMAC {
      private long id;
      private String key;
 
      public long getId() {
        return id;
      }
 
      public void setId(long id) {
        this.id = id;
      }
 
      public String getKey() {
        return key;
      }
 
      public void setKey(String key) {
        this.key = key;
      }
    }
 

 
    import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
    import com.nimbusds.jose.JWSAlgorithm
    import com.nimbusds.jose.JWSHeader
    import com.nimbusds.jose.crypto.MACSigner
    import com.nimbusds.jwt.JWTClaimsSet
    import com.nimbusds.jwt.SignedJWT
    import org.springframework.http.HttpStatus
    import org.springframework.http.ResponseEntity
    import org.springframework.stereotype.Component
    import java.time.Instant
    import java.util.*
 
    @Component
    internal class PersonalisationTokenGenerator {
        // IMPORTANT: securityKey here it is a copied data from Infobip Live Chat Security Key
        fun authorize(widgetId: String?, securityKey: String?): ResponseEntity {
            try {
                // simple example how personalizationToken issuing process could looks like:
                val objectMapper = jacksonObjectMapper()
                val secret = objectMapper.readValue(securityKey, SecurityKeyHMAC::class.java)
                val personalizationTokenSigner = MACSigner(Base64.getDecoder().decode(secret.key))
                val claimsSet = JWTClaimsSet.Builder()                          // generate always UNIQUE ID because Infobip will remember it and not permit to use it twice! As ID can be used ant string
                    .jwtID(UUID.randomUUID().toString())                        // unique ID of this token. Mandatory
                    .subject("example-email@infobip.com")                       // person destination in Infobip People service. Mandatory
                    .issuer(widgetId)                                                            // which widget it belongs. Mandatory
                    .issueTime(Date())                                          // when created. Mandatory
                    .expirationTime(Date.from(Instant.now().plusMillis(15000))) // Optional, e.g. when this token should be invalidated if not yet used,
                    // if not set then by default token will be invalidated after 15 seconds after issueTime
                    .claim("ski", secret.id)                                    // needs for security validation. Mandatory
                    .claim("stp", "email")                                      // type of person destination in Infobip People service. Mandatory
                    .claim("sid", "Session identifier")                         // unique session identifier. Optional
                    .build()
                val personalizedToken = SignedJWT(JWSHeader(JWSAlgorithm.HS256), claimsSet)
                personalizedToken.sign(personalizationTokenSigner)
                return ResponseEntity.ok(personalizedToken.serialize())
            } catch (ex: Exception) {
                // do some logging stuff
                ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build()
            }
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build()
        }
    }
 
    data class SecurityKeyHMAC(val id: Long, val key: String)
 

 
    // Download Swift-JWT: https://github.com/Kitura/Swift-JWT or any JSON Web Token library for Swift
    import SwiftJWT
    struct JWTClaims: Claims {
        let jti: String // random UNIQUE String. Mandatory.
        let sub: String // '[[email protected] | +PhoneNumber | ExtPersonID]'. Mandatory.
        let stp: String // Define the above. ie: "email", "msisdn" or "externalPersonId". Mandatory.
        let iss: String // Livechat widget Id. Mandatory.
        let iat: Date // timestamp. Mandatory. Issue time when created. Mandatory.
        let exp: Date // timestamp. Optional, e.g. when this token should be invalidated if not yet used. Default of 15 seconds. Mandatory.
        let ski: String // securityKey.id (provided by livechat widget, different that widget id). Mandatory.
        let sid: String // 'Session Identifier'. Optional
    }
    let myHeader = Header()
    let randomUniqueString = UUID().uuidString
    let myClaims = JWTClaims(
        jti: randomUniqueString,
        sub: email,
        stp: "email",
        iss: widgetId,
        iat: Date(),
        exp: Date().addingTimeInterval(20), // 20 seconds after creation - recommended value
        ski: widgetKeyId,
        sid: randomUniqueString)
    var myJWT = JWT(header: myHeader, claims: myClaims)
    guard let secretKeyIdData = Data(base64Encoded: widgetSecretKeyId, options: .ignoreUnknownCharacters) else {
        print("Unable to decode the base64 secret key Id")
        return nil
    }
    let jwtSigner = JWTSigner.hs256(key: secretKeyIdData)
    guard let signedJWT = try? myJWT.sign(using: jwtSigner) else {
        print("Unable to prepare the signed JWT to authenticate into the chat")
        return nil
    }
    // signedJWT is your JSON Web Token ready to use