Forem: Ameed Jamous

Open Text Shield (OTS)

Ameed Jamous — Thu, 19 Sep 2024 04:08:32 +0000

Open Text Shield (OTS) is an open-source, real-time, high-performance filtering and classification tool for SMS and messaging traffic, designed to deliver responses in under a second on standard hardware. It detects and blocks spam, phishing, and malicious content in 10 languages, making it a powerful solution for telecom operators, messaging providers, and any application handling message traffic, including those using SMPP, SIP, RCS, or SMTP.

OTS version 2.1 now proudly offers text classification predictions across 10 diverse languages, reaffirming our commitment to breaking language barriers and enhancing global communication:

🇬🇧 English 🇸🇦 Arabic 🇮🇩 Indonesian 🇩🇪 German 🇮🇹 Italian 🇪🇸 Spanish 🇷🇺 Russian 🇫🇷 French 🇱🇰 Sinhala 🇮🇳 Tamil

Features

Real-Time Detection: Instantly classify and block spam, phishing, and other unwanted messages.
Machine Learning Models: Leverages advanced models like multi-lingual BERT to ensure high accuracy.
Flexible Integration: Compatible with any application capable of making HTTP requests, including those using SMPP, SIP, RCS, and SMTP.
Web API: Simple and efficient API for message analysis and predictions.
Open Source: Free to use and modify, with commercial support available for advanced use cases.
Quick Start with Docker

Setting up Open Text Shield is quick and easy with Docker. Follow these steps to get started:

Note: Our Dockerized version currently supports only ARM architecture. We plan to release a version for AMD/Intel architectures soon.

Pull the Latest Docker Image

shell docker pull telecomsxchange/opentextshield:latest

Run the Docker Container

shell docker run -d -p 8002:8002 telecomsxchange/opentextshield:latest

Send a Message for Prediction

Once the container is running, you can send HTTP requests to the API to classify messages.

Example curl request:

curl -X POST "http://localhost:8002/predict/" \
-H "accept: application/json" \
-H "Content-Type: application/json" \
-d "{\"text\":\"Your SMS content here\",\"model\":\"bert\"}"
Example Response:

{
  "label": "ham",
  "probability": 0.9971883893013,
  "processing_time": 0.6801116466522217,
  "Model_Name": "OTS_mBERT",
  "Model_Version": "bert-base-uncased",
  "Model_Author": "TelecomsXChange (TCXC)",
  "Last_Training": "2024-03-20"
}

Learn More

For full documentation and source code, visit the Open Text Shield GitHub repository⁠.

SMPP + OTS for real-time, fast Ai driven protection

This is an example implementation of an SMPP Proxy performing real-time classification via OTS before routing the message to the upstream provider.

Sample SMPP Server code:


const smpp = require('smpp');
const axios = require('axios');
const tls = require('tls');
const fs = require('fs');
const uuid = require('uuid'); 

// Configuration for the upstream SMPP provider (with optional TLS)
const upstreamSMPPConfig = {
  host: '127.0.0.2',     // Replace with your upstream SMPP provider's host
  port: 2776,                     // Replace with your upstream SMPP provider's port
  system_id: 'USER',      // Replace with your upstream SMPP provider's system_id
  password: 'PASSWORD',       // Replace with your upstream SMPP provider's password
  tls: true                        // Set to true to enable TLS for upstream connection
};

// TLS options for inbound connections (replace with your own certificates if available)
let tlsOptions = null;
try {
  tlsOptions = {
    key: fs.readFileSync('server-key.pem'),  // Replace with path to your private key
    cert: fs.readFileSync('server-cert.pem') // Replace with path to your certificate
  };
} catch (err) {
  console.log('TLS configuration for inbound connections not found, falling back to non-TLS.');
}

// TLS options for outbound (upstream) connections (replace with your own certificates if available)
let upstreamTlsOptions = null;
if (upstreamSMPPConfig.tls) {
  try {
    upstreamTlsOptions = {
      key: fs.readFileSync('client-key.pem'),  // Replace with your client key
      cert: fs.readFileSync('client-cert.pem'), // Replace with your client certificate
      rejectUnauthorized: false                // Set to true if you want to enforce certificate validation
    };
  } catch (err) {
    console.log('TLS configuration for upstream not found, falling back to non-TLS.');
    upstreamSMPPConfig.tls = false; // Disable TLS for upstream if config is invalid
  }
}

// Action configuration: customize the behavior for each label type (ham, spam, phishing)
const actionsConfig = {
  ham: {
    action: 'pass_through', // Available options: 'pass_through', 'reject', 'submit_but_not_send'
    logMessage: 'Message is safe (HAM), passing through...'
  },
  spam: {
    action: 'reject', // Available options: 'pass_through', 'reject', 'submit_but_not_send'
    logMessage: 'Message is classified as SPAM, rejecting...'
  },
  phishing: {
    action: 'submit_but_not_send', // Available options: 'pass_through', 'reject', 'submit_but_not_send'
    logMessage: 'Message is classified as PHISHING, submitting but not sending...'
  }
};

// Store for multipart messages
let multipartStore = {};

// Function to create a session to connect to the upstream SMPP provider
let upstreamSession;
if (upstreamSMPPConfig.tls && upstreamTlsOptions) {
  // Use TLS for upstream connection
  upstreamSession = new smpp.Session({
    socket: tls.connect(upstreamSMPPConfig.port, upstreamSMPPConfig.host, upstreamTlsOptions, () => {
      console.log('Connected to upstream SMPP provider using TLS.');
      bindToUpstream();
    })
  });
} else {
  // No TLS, plain SMPP session
  upstreamSession = new smpp.Session({
    host: upstreamSMPPConfig.host,
    port: upstreamSMPPConfig.port
  });
  bindToUpstream();
}

// Function to bind to upstream SMPP provider
function bindToUpstream() {
  upstreamSession.bind_transceiver({
    system_id: upstreamSMPPConfig.system_id,
    password: upstreamSMPPConfig.password
  }, (pdu) => {
    if (pdu.command_status === 0) {
      console.log('Upstream SMPP provider bind successful.');
    } else {
      console.error('Upstream SMPP provider bind failed.');
    }
  });
}

// Conditional inbound connection handler (TLS or non-TLS)
let server;
if (tlsOptions) {
  // Start TLS-based SMPP Server for inbound connections
  server = smpp.createServer({ tls: true }, (session) => {
    handleSession(session);
  });
  server.listen({
    port: 2776,
    key: tlsOptions.key,
    cert: tlsOptions.cert
  }, '127.0.0.1', () => {
    console.log('Smart SMPP Proxy running with TLS on 127.0.0.1:2776');
    simulatePhishingMessage(); // Simulate phishing message after server starts
  });
} else {
  // Start non-TLS SMPP Server for inbound connections
  server = smpp.createServer((session) => {
    handleSession(session);
  });
  server.listen(2776, '127.0.0.1', () => {
    console.log('Smart SMPP Proxy running without TLS on 127.0.0.1:2776');
    simulatePhishingMessage(); // Simulate phishing message after server starts
  });
}

// Handle the SMPP session (bind and message submission)
function handleSession(session) {
  // Listen for bind_transceiver events (incoming bind requests)
  session.on('bind_transceiver', (pdu) => {
    console.log('Received bind request:', pdu);
    // Authenticate the incoming connection
    if (pdu.system_id === 'ots' && pdu.password === 'ots_secret') {
      // Successful bind
      session.send(pdu.response());
      console.log('Client bound successfully with system_id: ots');
    } else {
      // Authentication failure, send bind failure response
      session.send(pdu.response({
        command_status: smpp.ESME_RBINDFAIL
      }));
      console.log('Client bind failed. Invalid system_id or password.');
    }
  });

  // Handle incoming SMS messages via submit_sm PDU
  session.on('submit_sm', (pdu) => {
    console.log('Received submit_sm request:', pdu);

    // Log the message content
    const smsContent = pdu.short_message.message;
    console.log('SMS content:', smsContent);

    // Send response to acknowledge message receipt
    // Modify the response to include the message_id
    const message_id = uuid.v4();  // Generate a unique message ID
    session.send(pdu.response({
      command_status: smpp.ESME_ROK,  // Message sent successfully
      message_id: message_id          // Include the generated message_id
    }));

    console.log(`Generated message_id: ${message_id}`);  // Optional: Log the message_id for debugging

    // Analyze the SMS content via OTS
    processMessage(smsContent, session, pdu);
  });

  // Catch any unexpected disconnection or error
  session.on('unbind', () => {
    console.log('Client has unbound.');
  });

  session.on('close', () => {
    console.log('Connection closed.');
  });

  session.on('error', (err) => {
    console.log('SMPP error:', err);
  });
}

// Process message based on OTS analysis and action configuration
async function processMessage(smsContent, session, pdu) {
  console.log(`Processing SMS: ${smsContent}`);

  // Analyze SMS using OTS
  try {
    const response = await analyzeSmsWithOTS(smsContent);
    const label = response.label; // Assume OTS returns 'ham', 'spam', or 'phishing'
    const config = actionsConfig[label];

    // Execute the action based on the configuration
    if (config) {
      console.log(config.logMessage);
      handleAction(session, pdu, config.action);
    } else {
      console.log('Unknown classification, rejecting message.');
      session.send(pdu.response({
        command_status: smpp.ESME_RSUBMITFAIL
      }));
    }
  } catch (error) {
    console.error('Error analyzing SMS with OTS:', error);
    session.send(pdu.response({
      command_status: smpp.ESME_RSUBMITFAIL
    }));
  }
}

// Simulate a phishing message when the proxy starts
function simulatePhishingMessage() {
  const phishingMessage = "Urgent! Your bank account has been compromised. Click here to secure it now: http://fakebank.com";
  console.log("Simulating phishing message...");
  processMessage(phishingMessage, null, { short_message: { message: phishingMessage } });
}

// Function to handle concatenated SMS
function handleConcatenatedSMS(pdu) {
  const udh = pdu.short_message.udh;
  const reference = udh[3]; // Unique reference number for the multipart message
  const totalParts = udh[4]; // Total number of parts
  const currentPart = udh[5]; // Current part number

  // Initialize multipart store for the reference number if not already present
  if (!multipartStore[reference]) {
    multipartStore[reference] = new Array(totalParts).fill(null);
  }

  // Store the current part
  multipartStore[reference][currentPart - 1] = pdu.short_message.message;

  // Check if all parts are received
  if (multipartStore[reference].every(part => part !== null)) {
    const fullMessage = multipartStore[reference].join('');
    delete multipartStore[reference]; // Clear the store for this reference
    return fullMessage;
  }

  return null; // Return null until all parts are received
}

// Function to handle different actions based on the label
function handleAction(session, pdu, action) {
  switch (action) {
    case 'pass_through':
      // Pass-through logic: Forward the SMS to the upstream SMPP provider
      console.log('Forwarding SMS to upstream provider...');
      forwardToUpstream(pdu); // Forward the message to the upstream SMPP provider
      break;
    case 'reject':
      // Reject the SMS
      if (session) {
        session.send(pdu.response({
          command_status: smpp.ESME_RSUBMITFAIL
        }));
      }
      break;
      case 'submit_but_not_send':
        // Acknowledge submission but do not forward to upstream
        const message_id = uuid.v4();  // Generate a unique message ID
        if (session) {
          session.send(pdu.response({
            command_status: smpp.ESME_ROK,  // Acknowledge success
            message_id: message_id          // Include the generated message_id
          }));
        }
        console.log(`SMS classified as PHISHING, message_id: ${message_id}, submitted but not forwarded to upstream. DING DING 💰💰💰`);
        break;
    default:
      // Default case: reject message
      if (session) {
        session.send(pdu.response({
          command_status: smpp.ESME_RSUBMITFAIL
        }));
      }
      console.log('Invalid action specified, rejecting the message.');
  }
}

// Function to forward the message to the upstream SMPP provider
function forwardToUpstream(pdu) {
  upstreamSession.submit_sm({
    destination_addr: pdu.destination_addr,
    source_addr: pdu.source_addr,
    short_message: pdu.short_message
  }, (responsePdu) => {
    if (responsePdu.command_status === 0) {
      console.log('Message forwarded to upstream successfully.');
    } else {
      console.error('Failed to forward message to upstream:', responsePdu.command_status);
    }
  });
}

// Function to send SMS content to OTS for analysis, with request/response logging
async function analyzeSmsWithOTS(smsContent) {
  console.log("Sending request to OTS with message:", smsContent);
  try {
    const response = await axios.post('http://localhost:8002/predict/', {
      text: smsContent,
      model: 'bert' // Assuming you're using the BERT model
    }, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // Log the OTS response
    console.log("Received response from OTS:", response.data);

    // Return the OTS response (assumed format: { label: 'ham', probability: 0.95 })
    return response.data;
  } catch (error) {
    console.error('Failed to contact OTS service:', error);
    throw new Error('Failed to contact OTS service.');
  }
}

APIban-mysql client

Ameed Jamous — Fri, 30 Sep 2022 19:47:20 +0000

Apiban-mysql

Introducing simple apiban-mysql project. Fetch SIP attackers IPs from APIBan REST API and save them to MySQL database table.

Download Project

git clone https://github.com/ajamous/apiban-mysql.git

Change Directory


cd apiban-mysql/

Install dependencies

npm install

Created required tables in your mysql db


CREATE TABLE "last_fetched_id" (
  "id" varchar(32) NOT NULL DEFAULT '',
  PRIMARY KEY ("id")
);

CREATE TABLE "apiban_banned_ips" (
  "ip" varchar(15) NOT NULL DEFAULT '',
  PRIMARY KEY ("ip")
);

INSERT INTO last_fetched_id(id) values('');

Enter APIBan API key and DB Credentials


vi sync.js

/* validate environment */
const APIBAN_API_KEY = "XXXXXXXXXXXXXXXXX"
const APIBAN_MYSQL_SERVER = "replace_with_mysql_ip_or_host"
const APIBAN_MYSQL_PORT = 3306
const APIBAN_MYSQL_DATABASE = "replace_with_db_name"
const APIBAN_MYSQL_USER = "replace_with_mysql_user"
const APIBAN_MYSQL_PASSWORD = "replace_with_mysql_password"

Run the script

node sync.js

Sample output


$ node sync.js 

getting ips list...
starting from ID: undefined
fetched 250 ips, next ID 1663924065
fetched 250 ips, next ID 1663954967
fetched 250 ips, next ID 1663970136
fetched 250 ips, next ID 1663991432
fetched 250 ips, next ID 1664018643
fetched 250 ips, next ID 1664039285
fetched 250 ips, next ID 1664058709
fetched 250 ips, next ID 1664082297
fetched 250 ips, next ID 1664111965
fetched 250 ips, next ID 1664130848
fetched 250 ips, next ID 1664160433
fetched 250 ips, next ID 1664198153
fetched 250 ips, next ID 1664229896
fetched 250 ips, next ID 1664259993
fetched 250 ips, next ID 1664287578
fetched 250 ips, next ID 1664321167
fetched 250 ips, next ID 1664330768
fetched 250 ips, next ID 1664351231
fetched 250 ips, next ID 1664373761
fetched 250 ips, next ID 1664386920
saving ips list into DB...
done.

When there is no more IPs to add

$ node sync.js

getting ips list...
starting from ID: 1664386920
no new banned IPs since last sync, exiting...

Check your MySQL DB table for updates:

I hope you found it useful.

You may also like

APIBan-Redis: https://github.com/jambonz/apiban-redis
APIBan official website: https://apiban.org

OpenMSISDN

Ameed Jamous — Tue, 14 Jun 2022 12:19:37 +0000

Open Source E164 to E212 mapping dataset

OpenMSISDN Mapper is a detailed and high-quality e164 & e212 mapping database. it is essential for accurate billing, reporting, and routing purposes for voice and SMS traffic to have an accurate list.

It is surprisingly difficult for communications providers and developers to find a good quality e.164 to e.212 mapping database, this data set has been created and updated manually using over 10 different data sources. data is provided in the hope that it will be useful but WITHOUT ANY WARRANTY.

You can just open and use the raw json file OpenMSISDNMapper.jsonwith your fav text editor and/or convert it to any file format you want e.g. SQL or CSV and use it as you wish, you may also create a quick RESTful API server from the json file to use it from your application.

This API allows you to integrate and interact with OpenMSISDN Mapper data set

The data is provided in standard JSON responses and uses HTTP Status Codes to help determine results.

Create The API

git clone https://github.com/ajamous/OpenMSISDNMapper.git
cd OpenMSISDNMapper
Install required packages

npm install -g

Run the API server

json-server --watch OpenMSISDNMapper.json

Using The API

Now you can open http://localhost:8080/lookup to list all records
Lookup a specific country E.164 & E.212 data http://localhost:8080/lookup?Country=EGYPT
Lookup a specific prefix_e164 data http://localhost:8080/lookup?prefix_e164=20
Lookup a specific MCCMNC data http://localhost:8080/lookup?mccmnc_e212=60203
Lookup a secondary MCCMNC data http://localhost:8080/lookup?mccmnc_secondary=1234

[
  {
    "prefix_e164": 202,
    "Country": "EGYPT",
    "Network Description": "Fixed - Cairo",
    "mccmnc_e212": 0,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20,
    "Country": "EGYPT",
    "Network Description": "Fixed - Roc",
    "mccmnc_e212": 0,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 2011,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20110,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20111,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20112,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20114,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20115,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20117,
    "Country": "EGYPT",
    "Network Description": "Mobile - Etisalat",
    "mccmnc_e212": 60203,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 2012,
    "Country": "EGYPT",
    "Network Description": "Mobile - Orange",
    "mccmnc_e212": 60201,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20120,
    "Country": "EGYPT",
    "Network Description": "Mobile - Orange",
    "mccmnc_e212": 60201,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20122,
    "Country": "EGYPT",
    "Network Description": "Mobile - Orange",
    "mccmnc_e212": 60201,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20127,
    "Country": "EGYPT",
    "Network Description": "Mobile - Orange",
    "mccmnc_e212": 60201,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20128,
    "Country": "EGYPT",
    "Network Description": "Mobile - Orange",
    "mccmnc_e212": 60201,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 201,
    "Country": "EGYPT",
    "Network Description": "Mobile - Roc",
    "mccmnc_e212": 6020,
    "mccmnc_secondary": " 602 602999"
  },
  {
    "prefix_e164": 2010,
    "Country": "EGYPT",
    "Network Description": "Mobile - Vodafone",
    "mccmnc_e212": 60202,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20100,
    "Country": "EGYPT",
    "Network Description": "Mobile - Vodafone",
    "mccmnc_e212": 60202,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20101,
    "Country": "EGYPT",
    "Network Description": "Mobile - Vodafone",
    "mccmnc_e212": 60202,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20106,
    "Country": "EGYPT",
    "Network Description": "Mobile - Vodafone",
    "mccmnc_e212": 60202,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 20109,
    "Country": "EGYPT",
    "Network Description": "Mobile - Vodafone",
    "mccmnc_e212": 60202,
    "mccmnc_secondary": ""
  },
  {
    "prefix_e164": 2015,
    "Country": "EGYPT",
    "Network Description": "Mobile - We",
    "mccmnc_e212": 60204,
    "mccmnc_secondary": ""
  }
]

Getting Help

Help is provided by the community as soon as possible, you can open an issue here.

Warranty

OpenMSISDN Mapper data is provided in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

Contribution

To keep this list error-free and useful for everyone, We expect community members to create pull requests to contribute back improvements to the data set. Once a pull request is opened, project authors will run a verification using HLR to verify the updated data is correct before it’s merged to the master branch.

Submit your first contribution

1- Clone project git clone https://github.com/ajamous/OpenMSISDNMapper/ .

2- Create a new branch by issuing the command: git checkout -b new_branch

3- Create a new remote for the upstream repo with the command: git remote add upstream https://github.com/ajamous/OpenMSISDNMapper/

4- Switch to the new branch git checkout -b new_branch

5- edit OpenMSISDNMapper.jsonusing your preferred text editor

6- Committing your changes git commit -S -m "Dial Code Improvmenth"

7- push your changes git push -u origin new_branch

Once you push the changes to your repo, the Compare & pull request button will appear in GitHub. Click it and next Open a pull request by clicking the Create pull request button

The post OpenMSISDN appeared first on TelecomsXChange (TCXC) Blog.

Blocking unwanted SIP Traffic efficiently using APIBan

Ameed Jamous — Tue, 16 Nov 2021 14:06:43 +0000

Blocking unwanted SIP traffic manually is a reactive procedure, in the absence of smart tools, being pro-active is nearly impossible, it is common if you’re only reacting to a SIP attack that the damage of different types is already done.

If you're interested in automatically blocking unwanted SIP traffic detected by multiple honeypots, check out apiban.org or continue reading my full blog post that includes a tutorial here: https://blog.telecomsxchange.com/block-sip-attack/

Cloud BYOC

Ameed Jamous — Tue, 17 Aug 2021 08:57:20 +0000

Hello Developers !

We’re kicking off the Cloud BYOC project, a community-inspired SaaS project for existing Twilio, Zoom Phone, and other cloud communications users, with the of use cloid Bring Your Own Carrier (BYOC) feature,you can use any of the available 300+ providers instantly or add your own carrier, unify control of routing and billing under on roof.

The goal for this project is to let you have just one BYOC profile and control routing policies to multiple carriers via #CloudBYOC portal without the need to create another BYOC profile per carrier. By default by using CloudBYOC you don’t have to be dependent on one carrier, there are hundreds of alternatives that you can switch to without creating yet another BYOC profile in your Twilio, Zoom Phone portal.

With CloudBYOC you don’t need an SBC or billing system to manage your costs across different providers. It providers you all that out of the box!

For this project, we welcome both #developers and telecom carriers to join and contribute to solving the cloud communication BYOC debate once and for all.

If your interested in trying this out when ready, you can register here: https://lnkd.in/eppknHD3

TelecomsXChange (TCXC) a Founding Member of the API3 Alliance, To Offer First-Party Oracle Services on Web3.0

Ameed Jamous — Tue, 10 Aug 2021 17:29:44 +0000

TelecomsXChange (TCXC) a Founding Member of the API3 Alliance, To Offer First-Party Oracle Services on Web3

Leading Web API provider to provide data and services to the next generation of decentralized applications via Airnode

Miami, Florida– August 10, 2021 — TelecomsXChange today joined with API3, a “first-party oracle” solution empowering data providers to offer APIs directly to Web3 applications, to launch the API3 Alliance 2. The API3 Alliance represents a strategic coalition of API providers who believe that we should be able to share the same data and services we currently offer to web applications directly to Web3 consumers, without having to rely on third-party middlemen. Traditionally, APIs have been forced to either build their own facilities or pay external oracle operators to implement the middleware necessary to make their data and services compatible with the blockchain. API3 offers the tools and individualized support to our growing community — already more than 100 API providers — to go direct to the consumers of our APIs on Web3.

“We believe this partnership to be a solid foundation for bridging the telecommunication networks off the chain with decentralized applications (DApps) that live on the #blockchain, we are very excited to enable decentralized applications on the blockchain to utilize telecom carrier infrastructure for messaging, voice, lookups and many other use cases that will be made possible for dApps developers, said Ameed Jamous, founder and CEO at TelecomsXChange.”

At the center of its interactions with the APIs in the API3 Alliance is Airnode. Airnode is the serverless utility that allows API providers to effortlessly create first-party oracles that bring all forms of API-delivered data and services to Web3 applications and form an essential bridge between blockchain and the rest of the digital world.

“The API3 Alliance represents the first incarnation of the burgeoning community of API providers utilizing API3’s Airnode oracle middleware to offer services, which, already proven on the traditional web, can now be made accessible to the decentralized Web3 ecosystem at scale,” said Heikki Vänttinen, co-founder of API3. “We have always placed APIs at the heart of our operation, and we are thrilled to be collaborating with so many diverse and reputable API providers, all working to unlock the next evolutionary step of the decentralized web.”

The API3 ecosystem will be managed at scale by the newly formed API3 decentralized autonomous organization (DAO), which will maintain a self-regulating balance of risk and reward through well-engineered, value-added services built on top of APIs — such as quantifiable security guarantees in the form of insurance, and data feeds aggregated from independent sources known as decentralized APIs (dAPIs).

API3 DAO’s governing members will vote to ensure the API Alliance and API3’s unique procedures are not limited by their initial designs, and that they evolve to meet new challenges and needs.

“We will put our maximum effort behind our API3 Alliance partners, and are confident that with our support they will succeed in connecting their services to the growing Web3 market. At a time when the importance of APIs in the digital world has never been greater, we are creating the Web3 API economy and building the open infrastructure for decentralized applications,” said Vänttinen.

Moving forward, the API3 Alliance will continue to grow as more providers hosting APIs use API3 to enable their web offerings on the blockchain. To learn more about the API Alliance, please visit API3.org 1.

About TelecomsXChange

TelecomsXChange (TCXC) is a leading market place and PaaS provider that is empowering some of the world largest carriers digital transformation globally with a unified full stack wholesale platform for voice, SMS, Numbers and more.

For more information visit www.TelecomsXChange.com

About API3

API3 is the leading first-party blockchain oracle solution empowering the world’s premier API providers to offer their services directly to Web3 applications. Airnode, its open source, provider-operated oracle and value-added services such as dAPIs are governed by a decentralized autonomous organization (DAO) comprised of stakeholders, industry experts and project partners. API3 embodies the values of maximum transparency and minimum trust as it works to build the Web3 API economy

The post TelecomsXChange (TCXC) a Founding Member of the API3 Alliance, To Offer First-Party Oracle Services on Web3.0 appeared first on TelecomsXChange Blog.

When integrating APIs, Which API Authentication method do you prefer?

Ameed Jamous — Sat, 25 Apr 2020 18:23:32 +0000

Am wondering what other developers enjoy more as an Authentication method when integrating with APIs, Digest ? Basic Auth ? OAuth? API key ? JWT ?

What Front-End framework should i migrate to in 2020?

Ameed Jamous — Sat, 25 Apr 2020 11:51:30 +0000

Am trying to make up my mind with what front-end framework(s) to use for the next few years. I see many cool ones (BS, material etc...) but hard to make up our mind to decide on which path. We have been using our custom styling and JS components for many years. It’s time to get rid of that and move towards more responsiveness and modern design.

Two important things we want to achieve, modern design. Stable JS library and actively being developed and improved.

From your experience which framework would migrate to and why?

Thx!

Is it just me or is Chrome Inspector really fuc**** Awesome!!

Ameed Jamous — Fri, 24 Apr 2020 23:25:09 +0000

Buying Phone Numbers and Pointing them to your SIP/SMPP Network programmatically.

Ameed Jamous — Fri, 24 Apr 2020 21:39:47 +0000

In this tutorial I will share how to programmatically search and buy a virtual voice and SMS enabled phone number and point them to your own SIP and SMPP network/devices.

Search for a Phone Number in UK starting with 4471


curl --location --request POST 'https://apiv2.telecomsxchange.com/number/market' \
--form 'prefix=44741' \         
--form 'country=' \
--form 'description=' \
--form 'seller=' \
--form 'voice=1' \
--form 'sms=1' \
--form 'fax=0' \
--form 'video=0' \
--form 'did_type=any' \
--form 'pager=5' \
--form 'off=0'

API Response


{
  "status": "success",
  "dids": [
    {
      "i_did": "1002",
      "country": "GB",
      "msisdn": "447418340370",
      "cost": "1.25",
      "type": "mobile-lvn",
      "features": [
        "VOICE",
        "SMS"
      ],
      "monthly_fee": "2.5063",
      "number": "447418340370",
      "smpp_price": "0.0063",
      "price_1": "0.0050",
      "setup_fee": "0.0000",
      "capacity": 50,
      "voice": 1,
      "sms": 1,
      "video": 0,
      "fax": 0,
      "verification_required": 0,
      "interval_1": 60,
      "interval_n": 60,
      "did_type": "mobile",
      "vendor_name": "BT",
      "is_nexmo": 0,
      "country_code": "gb",
      "country_name": "UNITED KINGDOM",
      "description": "Mobile - Tismi",
      "price_n": "0.0050"
    }

Buy Phone Number and Point it to your SIP / SMPP Network Address


curl --location --request POST 'https://apiv2.telecomsxchange.com/number/purchase' \
--form 'i_did=1002' \ 
--form 'billing_i_account=[Your Billing Account ID]' \
--form 'contact=sip:447418340370@sip.domain.com:5060' \
--form 'smpp_contact=smpp:login:pass:447418340370@smpp.domain.com:PORT'

shell


{
  "status": "success",
  "message": "+447418340370 has been purchased and pointed to your network successfully"
}

That's it! You can now call or text +447418340370 from any phone and it'll be routed to your SIP/SMPP network.

NodeJS SMPP Stress Tester with configurable parameters

Ameed Jamous — Thu, 23 Apr 2020 20:33:18 +0000

This script allows you to perform sending high number of SMS messages towards an SMPP server and configure parameters to control it's behavior.

It's easy to setup and works.

I hope you find it useful.

Installation

Clone repository to your machine


# git clone https://github.com/telecomsxchange/smpp-client-nodejs.git


cd /smpp-client-nodejs/

Install node modules


# npm install

# npm install system-sleep

Open smpp-stress-tester.js in your code editor and configure SMPP HOST, PORT, USER, PASS, MESSAGES COUNT etc..



const nanoid = require('nanoid')
const sleep = require('system-sleep')

var smpp = require('smpp');

// define SMPP host and port

var session = smpp.connect('smpp://YOUR-SMPP-IP-OR-DOMAIN:PORT');

// If you're using TelecomsXChange as provider, this TLV will show the //price per message being sent out. 
// if you do not require it, you can comment it.

smpp.addTLV('billing_price', {
    id: 0x1520,
    type: smpp.types.tlv.string
});

// Configure test parameters

const test_sms_count = 5000;                // Number of SMS messages to send.
const req_sec_limit = 65;                   // Number of messages per second
const sleep_time = 1/req_sec_limit*1000;    // Sleep time / Wait for x secs
let i = 0
let test_end = 0
let start_test_ts = Math.floor(new Date() / 1000)
let end_test_ts
let failed_count = 0
var success_count = 0
let last_sms_sent_time = 0


session.bind_transceiver({

        //SMPP Credintials used during the test.

        system_id: 'ENTER SMPP USERNAME',
        password: 'ENTER SMPP PASSWORD'

}, function(pdu) {
    if (pdu.command_status == 0) {
        // Successfully bound
        start_test_ts = Math.floor(new Date() / 1000)
        for(i=0; i<test_sms_count; i++) {
            sleep(sleep_time)
            session.submit_sm({
                destination_addr: '{ENTER TO Number}',         // To Phone Number
                source_addr: '{ENTER FROM Number}',             // From Number or Sender ID
                registered_delivery: 1, 
                message_id: nanoid(24),
// Generate random verification code for every message. 
short_message: 'Your verification code is SS: ' + nanoid(4) ,    



// Uncomment below if your SMPP server supports message_payload for long text messages.

// message_payload: 'verification code AAA:' + nanoid(4)  

            }, function(pdu) {
                if (pdu.command_status == 0) {
                    // Message successfully sent
                    //console.log("message sent OK")
                    success_count++
                    end_test_ts = Math.floor(new Date() / 1000)
                } else {

          //console.log("message sending failed");
                    failed_count++
                    end_test_ts = Math.floor(new Date() / 1000)
                }
            });
            last_sms_sent_time = Math.floor(new Date() / 1000)
        }
    }
});


sleep(sleep_time * test_sms_count)
console.log("Finished sending, sleeping 30 secs");
const end_send_ts = Math.floor(new Date() / 1000);
sleep(10000)

// Console log the final report

console.log("Sent " + success_count + " SMS. Failed: " + failed_count + ". Total req/sec:" + (success_count / ( end_test_ts - start_test_ts)) + ". Waited for " + (end_test_ts - last_sms_sent_time) + " sec for last SMS" );
process.exit()

Now, let's start SMPP test


#node smpp-stress-tester.js

Sample Response


Finished sending, sleeping 30 secs
Sent 5000 SMS. Failed: 0. Total req/sec:50.5555555555555556. 

Waited for 1 sec for last SMS

Am about to Open Source this project - Encourage me!

Ameed Jamous — Thu, 16 Apr 2020 03:05:05 +0000

Let me know if I should speed up releasing the source code?

(Source Code Coming Soon to this public Github Repo)

Github URL: https://github.com/telecomsxchange/ott_apps

IOS and Android OTT App (Chat, Voice, Video) supports one on one and one to many.

Goal

The approuch here is to open source the Apps and Web services side of things and integrate with as many different CPaaS providers as possible (e.g. Twilio, Sinch, Restcomm, Etc..) i think there is no value today of building another SIP/WebRTC backend, we want to give a head start to developers that need a working IOS, Android app for group and one to one messaging, conferencing, and voice calling.

Live Demo on App Store: https://itunes.apple.com/us/app/o2-app/id1363104848?mt=8

Tested on over 32k Live Users: http://ottusers.telecomsxchange.com

XCode view:

Signup:

Ready to use your Twilio Account SID - Token for sending OTPs
Can easily switch signup OTPs to your own HTTP API.

Video Calls:

Twilio Programmable Video Dependant (Up to 4 people at the same time currently supported)
Possible to use another SDK for initiating videos

Audio Calls

Up to 10 participents at the same time
Twilio support already built in for Audio, Possible to switch to another SDK

Chat

Unlimited particpents support
Audio Voice Message support
Image Sharing support
Location Sharing Support
1:1 , 1 to many