Secure and Efficient Data Handling in Dart/Flutter with secure

When developing apps with Dart/Flutter, you might sometimes need to store or transmit sensitive string data — be it user preferences, configuration values, small text-based files, or other serialized data. In such cases, two requirements often come up. Security — data should be encrypted so that even if someone obtains storage or an intercepted payload, they cannot read it easily, and Efficiency / Compactness — data size should be minimized to save storage space or reduce bandwidth when sending over the network.

The open‑source package secure_compressor offers a neat solution combining both encryption and compression for string data. secure_compressor is a Dart package that provides utilities to:

Encrypt and decrypt string data using AES encryption

Compress and decompress string data using gzip
Combine both processes — compress first, then encrypt (or decrypt then decompress) — to make data both compact and secure
Optionally save encrypted & compressed data to local storage
Share encrypted & compressed data via device media platforms (e.g. send via messaging, email, etc.)

In short: secure_compressor gives you an easy way to store/send string data in a way that is both secure and size-efficient.

Why Use `secure_compressor?`

🔐 Encryption + Compression in One Package

Using separate libraries for encryption and compression can be error‑prone and cumbersome. secure_compressor bundles both together so you don’t need to manually compress and then encrypt. This reduces boilerplate and the risk of mistakes.

Size Efficiency + Data Privacy

By compressing data, you reduce storage or transmission footprint. Then by encrypting, you protect the data’s confidentiality. This makes it ideal for saving user data locally (e.g. preferences, small saved files) or sending data over network or via share-intents, where both security and size matter.

Simple API, Easy Integration

Integration is straightforward — after adding the dependency in pubspec.yaml and running flutter pub get, you can call a few static methods to handle everything (encrypt, compress & encrypt, decrypt, uncompress & decrypt, save to storage, share, etc.) with minimal boilerplate.

Flexible Storage Options

Beyond string-to-string operations, the package comes with a StorageHelper (built on get_storage) to store primitive types (string, int, bool, double) — optionally encrypted — which makes it easy to use for app preferences or local settings while still keeping data secure.

How to Use this Package?

Here’s a minimal example illustrating common use cases:


import 'package:secure_compressor/secure_compressor.dart';

const keyString = '0123456789abcdef0123456789abcdef';
const ivString = 'abcdefghijklmnop';                 

void main() async {
  String data = 'This is some secret data to store securely';

  // 1. Encrypt only
  String encrypted = await SecureCompressor.encrypt(data, keyString, ivString: ivString);

  // 2. Compress then encrypt
  String compressedEncrypted = await SecureCompressor.compressAndEncrypt(data, keyString, ivString: ivString);

  // ...later: decrypt
  String decrypted = SecureCompressor.decrypt(encrypted, keyString, ivString: ivString);

  // ...or decrypt and decompress
  String original = SecureCompressor.uncompressAndDecrypt(compressedEncrypted, keyString, ivString: ivString);

  print('Original: $original');
}

If you want to persist data securely:


await StorageHelper.initialize(
  'my_app_storage',
  isEncryptKeyAndValue: true,
  encryptionKey: keyString,
  isKeyEncrypted: false,
);

StorageHelper.saveString('user_secret', data);
String saved = StorageHelper.getString('user_secret');

Because secure_compressor supports both encryption and compression, this combination becomes a powerful tool to manage sensitive data while keeping storage/transfer efficient.

Support RSA Encryption

`secure_compressor` also support RSA encryption. We need to initialize the keys.pam as string when start the app. You also can save public_key and private_key using encrypt and decrypt when load the keys to init RSA encrypt-decrypt

final publicKey = readAsset('public_key.pam');
final privateKey = readAsset('private_key.pam');
SecureCompressor.initialize(publicKey: publicKey, privateKey: privateKey);

Where `secure_compressor` Fits?

Here are scenarios where secure_compressor is especially useful:

Storing user preferences or settings that include sensitive strings (e.g. tokens, API keys, secrets) — compressed and encrypted — locally.
Saving small configuration or state files that may be shared between devices or backed up.
Sending small text-based payloads over network or via share/intents (e.g. exported config, user notes, etc.) while ensuring privacy and compactness.
Apps that want a simple, integrated solution for secure + compressed string storage/transmission without customizing encryption/compression manually.

secure_compressor fills a useful niche in Flutter/Dart development: a simple, all-in-one package that provides encryption + compression for string data. For many apps — especially those handling user settings, textual secrets, or small data blobs — it's a handy tool that can improve both security and storage/transfer efficiency.

If you're building a Flutter app that needs to store or share sensitive text data securely and efficiently, secure_compressor is worth evaluating.

Secure and Efficient Data Handling in Dart/Flutter with secure_compressor

Why Use `secure_compressor?`