How to use the node-forge.jsbn function in node-forge

function base64ToBn(base64) {
  return new forge.jsbn.BigInteger(util.b64dec(base64).toString("hex"), 16);
}

function base64urlToBigInteger(str) {
      var bytes = forge.util.decode64(
        (str + '==='.slice((str.length + 3) % 4))
          .replace(/\-/g, '+')
          .replace(/_/g, '/'));

      return new forge.jsbn.BigInteger(forge.util.bytesToHex(bytes), 16)
    }

export function importPublicKey(jwkPublicKey) {
  const n = new Buffer(jwkPublicKey.n, 'base64');
  const e = new Buffer(jwkPublicKey.e, 'base64');

  const publicKey = forge.pki.setRsaPublicKey(
    new forge.jsbn.BigInteger(n.toString('hex'), 16),
    new forge.jsbn.BigInteger(e.toString('hex'), 16)
  );
  return Promise.resolve(publicKey);
}

"use strict";

import * as xmlrpc from "xmlrpc";
import * as forge from "node-forge";
import {Logger} from "../bll/utils/logger";
import {injectable} from "inversify";
import {RemoteLogin} from "./remotelogin";
import {VsCodeUtils} from "../bll/utils/vscodeutils";
import {RcaPublicKey} from "./rcapublickey";
import {MessageConstants} from "../bll/utils/messageconstants";
const BigInteger = forge.jsbn.BigInteger;
const pki = forge.pki;

@injectable()
export class RemoteLoginImpl implements RemoteLogin {

    /**
     * @param user - user name
     * @param password - user password
     * @return - Promise. In case of success it returns the line in a format ${sessionId}:${userId}
     */
    async authenticate(serverUrl: string, user: string, password: string): Promise {
        const client = this.createClient(serverUrl);
        const rsaPublicKey: RcaPublicKey = await this.getPublicKey(client);
        if (!rsaPublicKey) {
            throw MessageConstants.XMLRPC_AUTH_EXCEPTION + " rsaPublicKey is absent";
        }

import * as xmlrpc from "xmlrpc";
import * as forge from "node-forge";
import {Logger} from "../bll/utils/logger";
import {inject, injectable} from "inversify";
import {RcaPublicKey} from "./rcapublickey";
import {MessageConstants} from "../bll/utils/messageconstants";
import {Utils} from "../bll/utils/utils";
import {TYPES} from "../bll/utils/constants";
import {IVsCodeUtils} from "../bll/utils/ivscodeutils";
import {RequestProxy, RequestResult} from "../bll/moduleproxies/request-proxy";
import * as url from "url";

const BigInteger = forge.jsbn.BigInteger;
const pki = forge.pki;

@injectable()
export class RemoteLogin {

    private readonly vsCodeUtils: IVsCodeUtils;
    private readonly requestProxy: RequestProxy;

    constructor(@inject(TYPES.VsCodeUtils) vsCodeUtils: IVsCodeUtils,
                @inject(TYPES.RequestProxy) requestProxy: RequestProxy) {
        this.vsCodeUtils = vsCodeUtils;
        this.requestProxy = requestProxy;
    }

    async isServerReachable(serverUrl: string): Promise {
        const options = {

var express = require('express');
var app = express();
var bodyParser = require('body-parser');
var _ = require('lodash');
var cradle = require('cradle');
var db = new(cradle.Connection)().database('secretin');
var forge = require('node-forge');
var rsa = forge.pki.rsa;
var BigInteger = forge.jsbn.BigInteger;
var redis = require('redis');


OPTIONAL_SALT = '';

client = redis.createClient();

app.use(express.static('client'));
app.use(bodyParser.json());


function userExists(name, callback){
  db.view('users/getUser', { key: name }, function (err, doc) {
    if(err === null && typeof doc !== 'undefined' && doc.length === 1){
      callback(true, doc[0].value.res, {id: doc[0].id, rev: doc[0].value.rev});
    }

function _b64UrlToBigInt(s) {
  return new forge.jsbn.BigInteger(_b64UrlToHex(s), 16);
}

converter.register("bytes", "bigIntForge", function (value) {
    return new BigIntForge(new forge.jsbn.BigInteger(value, 256));
}, true);
converter.register("bigIntForge", "decBlocks", function (value) {

const jwkPrivateKey = JSON.parse(jwkPrivateKeyString);

    const n = new Buffer(jwkPrivateKey.n, 'base64');
    const e = new Buffer(jwkPrivateKey.e, 'base64');
    const d = new Buffer(jwkPrivateKey.d, 'base64');
    const p = new Buffer(jwkPrivateKey.p, 'base64');
    const q = new Buffer(jwkPrivateKey.q, 'base64');
    const dP = new Buffer(jwkPrivateKey.dp, 'base64');
    const dQ = new Buffer(jwkPrivateKey.dq, 'base64');
    const qInv = new Buffer(jwkPrivateKey.qi, 'base64');

    const privateKey = forge.pki.setRsaPrivateKey(
      new forge.jsbn.BigInteger(n.toString('hex'), 16),
      new forge.jsbn.BigInteger(e.toString('hex'), 16),
      new forge.jsbn.BigInteger(d.toString('hex'), 16),
      new forge.jsbn.BigInteger(p.toString('hex'), 16),
      new forge.jsbn.BigInteger(q.toString('hex'), 16),
      new forge.jsbn.BigInteger(dP.toString('hex'), 16),
      new forge.jsbn.BigInteger(dQ.toString('hex'), 16),
      new forge.jsbn.BigInteger(qInv.toString('hex'), 16)
    );
    return Promise.resolve(privateKey);
  } catch (e) {
    return Promise.reject('Invalid Password');
  }
}

converter.register("decBlocks", "bigIntForge", function (value) {
    return new BigIntForge(new forge.jsbn.BigInteger(value, 10));
}, true);
converter.register("bigIntSjcl", "bigIntForge", function (value) {