> Read the whitepaper on our Zero Trust data-level security platform.
Storage level encryption isn’t effective – Ubiq’s Zero Trust data-level security platform ensures your data is safe no matter where it’s stored, shared or analyzed.
Admin credentials can easily bypass storage-layer controls, putting your data at risk of insider and external threats.
Data is only protected when stored, not in use. Usage and sharing require decryption, increasing the risk of exposure.
It lacks fine-grained access controls, forcing you to trust users with full access to sensitive data for analytics.
We’ve abstracted the messy and complex world of encryption, tokenization, masking, and key management into a simple API call and elegant integrations, allowing you to confidently secure sensitive data on the client-side in minutes.
Since your data is individually secured, you’ll lower risk of unauthorized access by malicious insiders, external attackers, and supply chain threats.
Ubiq integrates with your IDP to provide fine-grained permissions and control over sensitive data, enabling secure analysis and safe sharing, and a Zero Trust data security strategy.
ubiq = require('ubiq-security' 1.0.5)
const credentials =
new ubiq.Credentials('T31i/+eZAsURqVOO/0WfkGqd',
'GyPujOPlRcQu+uF7sZchT0c1BsUMkyqcIlz0ss3FhciS',
'AkQ9vGDsUhZPHk+YUSekFEJSP0XzKouEpfMIt6ZvmEfd')
plaintext_data = 'ABC'
encrypted_data = await ubiq.encrypt(credentials, plaintext_data)
console.log(encrypted_data.toString('base64'))
decrypted_data = await ubiq.decrypt(credentials, encrypted_data)Ubiq’s integrated key management automates compliance-driven key management practices and provides secure key storage, eliminating the need and cost of managing your own KMS or HSM.
Ubiq’s data-level security allows you to quickly and easily integrate client-side encryption, tokenization, and masking into your environment. This enables you to focus more on enhancing product and customer experiences, while spending less time managing disparate data security and key management tools.
const ubiq = require('ubiq-security')
// Explicitly set the credentials.
const credentials = new Credentials('', '', '')
// Encrypt a block of data.
const encrypted_data = await ubiq.encrypt(credentials, plainntext_data)
// Decrypt a block of data.
const plainttext_data = await ubiq.decrypt(credentials, encrypted_data)
require 'ubiq-security'
include Ubiq
# Explicitly set the credentials.
credentials = Credentials(access_key_id = "...", secret_signing_key = "...", secret_crypto_access_key = "...")
# Encrypt a block of data.
encrypted_data = encrypt(credentials, plaintext_data)
# Decrypt a block of data.
plaintext_data = decrypt(credentials, encrypted_data)
# Require the Security Client.
import ubiq_security as ubiq
# Explicitly set the credentials.
credentials = ubiq.credentials(access_key_id = "...", secret_signing_key = "...", secret_crypto_access_key = "...")
# Encrypt a block of data.
encrypted_data = ubiq.encrypt(credentials, plaintext_data)
# Decrypt a block of data.
plaintext_data = ubiq.decrypt(credentials, encrypted_data)
#include
struct ubiq_platform_credentials * creds = NULL;
void * ptbuf = NULL, * ctbuf = NULL;
size_t ptlen = 0, ctlen = 0;
/*
* load credentials from the environment
* or the credentials file
*/
ubiq_platform_credentials_create(creds);
/* initialize ptbuf and ptlen */
...
/* Encrypt a block of data. */
ubiq_platform_encrypt(creds, ptbuf, ptlen, ctbuf, ctlen);
/* Decrypt a block of data. */
ubiq_platform_decrypt(creds, ctbuf, ctlen, ptbuf, ptlen);
free(ctbuf);
free(ptbuf);
ubiq_platform_credentials_destroy(creds); #include
/*
* load credentials from the environment
* or the credentials file
*/
ubiq::platform::credentials creds;
std::vector ptbuf, ctbuf;
/* initialize ptbuf */
...
/* Encrypt a block of data. */
ctbuf = ubiq::platform::encrypt(creds, ptbuf.data(), ptbuf.size());
/* Decrypt a block of data. */
ptbuf = ubiq::platform::decrypt(creds, ctbuf.data(), ctbuf.size()); using UbiqSecurity;
/* explicitly set the credentials */
var credentials = UbiqFactory.CreateCredentials(accessKeyId: "...", secretSigningKey: "...", secretCryptoAccessKey: "...");
/* Encrypt a block of data. */
byte[] plainBytes = ...;
byte[] encryptedBytes = await UbiqEncrypt.EncryptAsync(credentials, plainBytes);
/* Decrypt a block of data. */
plainBytes = await UbiqDecrypt.DecryptAsync(credentials, encryptedBytes);import com.ubiqsecurity.UbiqCredentials;
import com.ubiqsecurity.UbiqDecrypt;
import com.ubiqsecurity.UbiqEncrypt;
import com.ubiqsecurity.UbiqFactory;
// Explicitly set the credentials.
UbiqCredentials credentials = UbiqFactory.createCredentials("", "", "", null);
// Encrypt a block of data.
byte[] plainBytes = ...;
byte[] encryptedBytes = UbiqEncrypt.encrypt(credentials, plainBytes);
// Decrypt a block of data.
plainBytes = UbiqDecrypt.decrypt(credentials, encryptedBytes); import "gitlab.com/ubiqsecurity/ubiq-go"
var plaintext []byte = ...
// load the default credentials
credentials, _ := ubiq.NewCredentials()
// encrypt a block of data
ciphertext, _ := ubiq.Encrypt(credentials, plaintext)
// decrypt a block of data
plaintext, _ := ubiq.Decrypt(credentials, ciphertext)# Initialize credentials into the current session
call ubiq_begin_fpe_session(dataset_names, access_key,
secret_key, secret_crypto_access_key);
# Encrypt a block of data.
select ubiq_fpe_encrypt_cache(plain_text, dataset_name);
# Decrypt a block of data.
select ubiq_fpe_decrypt_cache(cipher_text, dataset_name);
# Querying encrypted data stored in a table
select name, address, ubiq_fpe_decrypt_cache(sensitive_info, dataset_name) from secure_table;
# Inserting encrypted data to a table
insert into secure_table (name, address, sensitive_info) values ("Jeff", "101 Anywhere St",
ubiq_fpe_encrypt_cache(sensitive_info, dataset_name));
# Tear down the Ubiq Session
call ubiq_close_fpe_session(access_key, secret_key);Integrations are available for the most popular programming languages, databases and warehouses, API gateways, and SaaS platforms.
Ubiq is more than a vendor, they're a true partner and an extension of our team. Implementing their encryption API was one of the most seamless and painless integrations we've ever experienced. In just hours, we began securing sensitive patient data, meeting vital HIPAA requirements with ease. This has reinforced our confidence in managing both our present and future compliance obligations.
Executive Director
Ubiq's encryption API transformed our data security from a "checkbox" approach to one that effectively protects sensitive data and significantly enhances our threat model. Even in scenarios where S3 encryption falls short, such as compromised AWS credentials, we're now protected. Implementing Ubiq's solution was incredibly painless, taking only a few hours, a testament to their commitment to customer experience. Ubiq is more than a vendor; they're a trusted security partner.
Product Leader
Ubiq has saved us hundreds of hours in encryption tasks in our engineering and DevSecOps processes, safeguarding billions of sensitive records, from customer PII to financial information. With Ubiq as our partner, we manage encryption efficiently and tackle new security requirements with confidence, saving critical engineering time and driving value to the business, all while ensuring effective data security.
Security Architect
We employ Ubiq encryption to store sensitive data inside each MongoDB document. But the best thing I love about Ubiq is that the encryption travels with the data. Even if I accidentally expose my S3-bucket to the whole wide world, my data is still safe, and I can control the validity of decryption keys from the Ubiq console. Talk about god-like powers!
Microbuilder
Ubiq saved us countless hours by eliminating custom engineering encryption and the burden of cryptographic decision-making from our developers. Their encryption API efficiently protects highly sensitive documents and data. Implementation was very straightforward and clearly designed with developers in mind, offering a familiar customer experience. The Ubiq team is remarkably responsive, supportive, and always to our feature enhancement requests.
CTO and Chief Architect
Ubiq's encryption API provides robust protection for sensitive data with minimal integration effort, enabling us to effectively reduce the risk of data breaches and strengthen our defense.
CISO
Ubiq has modernized and streamlined our approach to data encryption and key management, simplifying the process and eliminating complexity. With Ubiq, we achieve consistent encryption across our infrastructure, streamlining compliance audits and reducing scope. The ability to seamlessly integrate critical data encryption controls into our development processes has significantly reduced downstream efforts and costs, while removing guesswork and risks from cryptographic decisions.
CTO
The adoption and implementation of Ubiq's API was one of our quickest and most effortless technology implementations, done in just a few hours. Ubiq streamlines encryption, making the process of safeguarding sensitive data and implementing top security practices in your application both seamless and comprehensible.
CTO