Cross-platform high-level cryptographic library

import {
  symmetricKey64,
  secureCellSealWithSymmetricKeyEncrypt64,
  secureCellSealWithSymmetricKeyDecrypt64,
} from 'react-native-themis'

const message = "all your base are belong to us"
const context = ""

(async () => {
    const key64 = await symmetricKey64()
    const encrypted64 = await secureCellSealWithSymmetricKeyEncrypt64(key64, message, context)
    const decrypted = await secureCellSealWithSymmetricKeyDecrypt64(key64, encrypted64, context)
})();

import themis
            
let message = "all your base are belong to us".data(using: .utf8)!

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

let encryptionKey = TSGenerateSymmetricKey()!
let cell = TSCellSeal(key: encryptionKey)!

let encrypted = try cell.encrypt(message)
let decrypted = try cell.decrypt(encrypted)

@import themis;
                
NSString *messageString = @"all your base are belong to us";
NSData *message = [messageString dataUsingEncoding:NSUTF8StringEncoding];

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

NSData *encryptionKey = TSGenerateSymmetricKey();
TSCellSeal *cell = [[TSCellSeal alloc] initWithKey:encryptionKey];

NSError *error;
NSData *encrypted = [cell encrypt:message error:&error];
NSData *decrypted = [cell decrypt:encrypted error:&error];

import com.cossacklabs.themis.*;

byte[] message = "all your base are belong to us"
    .getBytes(StandardCharsets.UTF_8);

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

SymmetricKey encryptionKey = new SymmetricKey();
SecureCell.Seal cell = SecureCell.SealWithKey(encryptionKey);

byte[] encrypted = cell.encrypt(message);
byte[] decrypted = cell.decrypt(encrypted);

import com.cossacklabs.themis.*;

val message = "all your base are belong to us"
.toByteArray(StandardCharsets.UTF_8)

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

val encryptionKey = SymmetricKey()
val cell = SecureCell.SealWithKey(encryptionKey)

val encrypted = cell.encrypt(message)
val decrypted = cell.decrypt(encrypted)

import "github.com/cossacklabs/themis/gothemis/cell"
import "github.com/cossacklabs/themis/gothemis/keys"

message := []byte("all your base are belong to us")

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

encryptionKey, err := keys.NewSymmetricKey()
scell, err := cell.SealWithKey(encryptionKey)

encrypted, err := scell.Encrypt(message, nil)
decrypted, err := scell.Decrypt(encrypted, nil)

use themis::keys::SymmetricKey;
use themis::secure_cell::SecureCell;

let message = b"all your base are belong to us";

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

let encryption_key = SymmetricKey::new();
let cell = SecureCell::with_key(&encryption_key)?.seal();

let encrypted = cell.encrypt(&message)?;
let decrypted = cell.decrypt(&encrypted)?;

from pythemis.scell import SCellSeal
from pythemis.skeygen import GenerateSymmetricKey

message = b'all your base are belong to us'

# Protect message using strong encryption under the hood:
# AES-256-GCM with KDF, random salt and IV

encryption_key = GenerateSymmetricKey()
cell = SCellSeal(key=encryption_key)

encrypted = cell.encrypt(message)
decrypted = cell.decrypt(encrypted)

require 'rbthemis'

message = 'all your base are belong to us'

# Protect message using strong encryption under the hood:
# AES-256-GCM with KDF, random salt and IV

encryption_key = Themis::gen_sym_key
cell = Themis::ScellSeal.new(encryption_key)

encrypted = cell.encrypt(message)
decrypted = cell.decrypt(encrypted)

const themis = require('jsthemis')

const message = Buffer.from("all your base are belong to us")

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

const encryptionKey = new themis.SymmetricKey()
const cell = themis.SecureCellSeal.withKey(encryptionKey)

const encrypted = cell.encrypt(message)
const decrypted = cell.decrypt(encrypted)

const themis = require('wasm-themis')

await themis.initialized

let messageString = "all your base are belong to us"
let message = new TextEncoder().encode(messageString)

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

let encryptionKey = new themis.SymmetricKey()
let cell = themis.SecureCellSeal.withKey(encryptionKey)

let encrypted = cell.encrypt(message)
let decrypted = cell.decrypt(encrypted)

#include <themispp/secure_cell.hpp>
#include <themispp/secure_keygen.hpp>

uint8_t message[] = "all your base are belong to us";

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

std::vector<uint8_t> encryption_key = themispp::gen_sym_key();
auto cell = themispp::secure_cell_seal_with_key(encryption_key);

std::vector<uint8_t> encrypted = cell.encrypt(message);
std::vector<uint8_t> decrypted = cell.decrypt(encrypted);

$message = 'all your base are belong to us';

// Protect message using strong encryption under the hood:
// AES-256-GCM with KDF, random salt and IV

$encryption_key = phpthemis_gen_sym_key();

$encrypted = phpthemis_scell_seal_encrypt($encryption_key, $message, NULL);
$decrypted = phpthemis_scell_seal_decrypt($encryption_key, $encrypted, NULL);