Date Preparatoin and Encryption

RSA Encryption

To ensure the security and integrity of the data being sent to the Hyperhashing API, we use RSA encryption. This section outlines the steps required to generate RSA keys and how to use them for encrypting data before making API requests.

Generating RSA Keys

1. Generate RSA Key Pair: Users need to generate an RSA key pair (public and private keys). The public key will be shared with Hyperhashing, while the private key will be kept secure by the user.

2. Share Public Key: Once the RSA key pair is generated, the user must provide Hyperhashing with their public key. This key will be used by Hyperhashing to decrypt the data sent by the user.

Generating RSA Keys Using OpenSSL

Step 1: Install OpenSSL

If you don't have OpenSSL installed, you can install it using your package manager. For example, on Ubuntu, you can install it with:

sudo apt-get update
sudo apt-get install openssl

Step 2: Generate the RSA Private Key

To generate a 2048-bit RSA private key, use the following command:

openssl genpkey -algorithm RSA -out private_key.pem -aes256

This command generates a private key and encrypts it with AES-256. You will be prompted to enter a passphrase to secure the key.

Step 3: Generate the RSA Public Key

Once you have the private key, you can generate the corresponding public key with:

openssl rsa -pubout -in private_key.pem -out public_key.pem

This command reads the private key and outputs the corresponding public key.

Sharing the Public Key

The public key generated in the above step should be securely shared with Hyperhashing.

Encrypting Data

Once the RSA keys are set up, the user can proceed to encrypt the data before sending it to the API. The data is first converted to a JSON string and then encrypted using the private key.

Encrypting Data

Once the RSA keys are set up, the user can proceed to encrypt the data before sending it to the API. The data is first converted to a JSON string and then encrypted using the private key.

Here is an example of how to encrypt data using the node-rsa library:

const NodeRSA = require('node-rsa');

function rsa_encrypt(text) {
  // Replace with your RSA private key
  let privateKey = '-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----';
  let key = new NodeRSA(privateKey);
  
  // Convert the text to a Buffer
  let buf = Buffer.from(text, 'utf8');
  
  // Encrypt the buffer and convert it to a Base64 string
  let encrypted = key.sign(buf);
  
  return encrypted.toString('base64');
}

const data = {
  order_id: "17188041436139639757",
  nonce: makeid(10),
  timestamp: Math.floor(Date.now() / 1000),
};

const hash = rsa_encrypt(JSON.stringify(data));
console.log('Encrypted Data:', hash);

function makeid(length) {
  let result = "";
  const characters = "abcdefghijklmnopqrstuvwxyz0123456789";
  const charactersLength = characters.length;
  let counter = 0;
  while (counter < length) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength));
    counter += 1;
  }
  return result;
}

Example Request Preparation

After encrypting the data, the user can prepare the API request as follows:

const axios = require('axios');

async function main() {
  const data = {
    order_id: "17188041436139639757",
    nonce: makeid(10),
    timestamp: Math.floor(Date.now() / 1000),
  };

  const hash = rsa_encrypt(JSON.stringify(data));

  axios.post("https://payment.hyperhashing.com/v1/token/withdraw", {
    merchant_id: "xxxx-xxxx-xxxx-xxxx",
    hash: hash,
    data: data,
  })
  .then(function (response) {
    console.log(response.config.data);
    console.log(response.data);
  })
  .catch(function (error) {
    console.log(error);
  });
}

main();

In this example, the data object is encrypted using the user's private RSA key, and the resulting hash is included in the API request.