react-native-des-machine 0.1.0

package/DesMachine.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "DesMachine"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/NeRo8/react-native-des-machine.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Artur Duchenko
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,190 @@
+# react-native-des-machine
+
+A React Native TurboModule that provides DES (Data Encryption Standard) encryption and decryption with support for multiple cipher modes, padding schemes, and output formats.
+
+## Features
+
+- DES encryption and decryption
+- Multiple cipher modes: ECB, CBC, CFB, OFB, CTR
+- Multiple padding schemes: PKCS7, ISO10126, Zero, None
+- Output formats: Base64, Hexadecimal
+- Native implementation for both iOS and Android
+- TurboModule support for improved performance
+
+## Installation
+
+Using npm:
+
+```sh
+npm install react-native-des-machine
+```
+
+Using yarn:
+
+```sh
+yarn add react-native-des-machine
+```
+
+### iOS Setup
+
+After installing, run pod install:
+
+```sh
+cd ios && pod install
+```
+
+### Android Setup
+
+No additional setup required. The library auto-links on Android.
+
+## Usage
+
+### Basic Example
+
+```typescript
+import {
+  setMachineParams,
+  encrypt,
+  decrypt,
+  Mode,
+  Padding,
+  Format,
+} from 'react-native-des-machine';
+
+// Initialize the DES machine with your encryption key
+setMachineParams({
+  key: 'mySecretKey123', // minimum 8 characters
+});
+
+// Encrypt text
+const encrypted = encrypt('Hello World!');
+console.log('Encrypted:', encrypted);
+// Output: "Encrypted: 2jmj7l5rSw0yVb/vlWAYkK/YBwk="
+
+// Decrypt text
+const decrypted = decrypt(encrypted);
+console.log('Decrypted:', decrypted);
+// Output: "Decrypted: Hello World!"
+```
+
+### Advanced Configuration
+
+```typescript
+import {
+  setMachineParams,
+  encrypt,
+  decrypt,
+  Mode,
+  Padding,
+  Format,
+} from 'react-native-des-machine';
+
+// Configure with custom mode, padding, and output format
+setMachineParams({
+  key: 'mySecretKey123',
+  mode: Mode.CBC, // Cipher Block Chaining mode
+  padding: Padding.PKCS7, // PKCS7 padding
+  outputFormat: Format.HEX, // Hexadecimal output
+});
+
+const encrypted = encrypt('Sensitive data');
+console.log('Encrypted (hex):', encrypted);
+// Output: "Encrypted (hex): 4a6f686e446f65..."
+
+const decrypted = decrypt(encrypted);
+console.log('Decrypted:', decrypted);
+```
+
+## API Reference
+
+### `setMachineParams(params: DesMachineParams): void`
+
+Initialize the DES machine with encryption parameters.
+
+#### Parameters
+
+| Parameter      | Type                    | Required | Default    | Description                           |
+| -------------- | ----------------------- | -------- | ---------- | ------------------------------------- |
+| `key`          | `string`                | Yes      | -          | Encryption key (minimum 8 characters) |
+| `mode`         | `ModeEncryptionType`    | No       | `'ECB'`    | Cipher mode                           |
+| `padding`      | `PaddingEncryptionType` | No       | `'PKCS7'`  | Padding scheme                        |
+| `outputFormat` | `OutputFormatType`      | No       | `'BASE64'` | Output encoding format                |
+
+### `encrypt(text: string): string`
+
+Encrypt plaintext using the configured DES parameters.
+
+- **Parameters:** `text` - The plaintext string to encrypt
+- **Returns:** Encrypted string in the configured output format
+- **Throws:** Error if `setMachineParams()` has not been called
+
+### `decrypt(text: string): string`
+
+Decrypt ciphertext using the configured DES parameters.
+
+- **Parameters:** `text` - The encrypted string to decrypt
+- **Returns:** Decrypted plaintext string
+- **Throws:** Error if `setMachineParams()` has not been called
+
+## Constants
+
+### Mode
+
+| Constant   | Value   | Description                   |
+| ---------- | ------- | ----------------------------- |
+| `Mode.ECB` | `'ECB'` | Electronic Codebook (default) |
+| `Mode.CBC` | `'CBC'` | Cipher Block Chaining         |
+| `Mode.CFB` | `'CFB'` | Cipher Feedback               |
+| `Mode.OFB` | `'OFB'` | Output Feedback               |
+| `Mode.CTR` | `'CTR'` | Counter                       |
+
+### Padding
+
+| Constant           | Value        | Description              |
+| ------------------ | ------------ | ------------------------ |
+| `Padding.PKCS7`    | `'PKCS7'`    | PKCS#7 padding (default) |
+| `Padding.ISO10126` | `'ISO10126'` | ISO 10126 padding        |
+| `Padding.ZERO`     | `'ZERO'`     | Zero padding             |
+| `Padding.NONE`     | `'NONE'`     | No padding               |
+
+### Format
+
+| Constant        | Value      | Description               |
+| --------------- | ---------- | ------------------------- |
+| `Format.BASE64` | `'BASE64'` | Base64 encoding (default) |
+| `Format.HEX`    | `'HEX'`    | Hexadecimal encoding      |
+
+## TypeScript Support
+
+The library includes full TypeScript definitions:
+
+```typescript
+import type {
+  DesMachineParams,
+  ModeEncryptionType,
+  PaddingEncryptionType,
+  OutputFormatType,
+} from 'react-native-des-machine';
+```
+
+## Security Notice
+
+DES is considered cryptographically weak by modern standards due to its 56-bit key size. For production applications requiring strong encryption, consider using AES or other modern algorithms. This library is suitable for:
+
+- Legacy system compatibility
+- Educational purposes
+- Low-security applications
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,67 @@
+buildscript {
+  ext.DesMachine = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return DesMachine[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.desmachine"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/desmachine/DesMachineModule.kt

@@ -0,0 +1,193 @@
+package com.desmachine
+
+import android.util.Base64
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import javax.crypto.Cipher
+import javax.crypto.SecretKey
+import javax.crypto.SecretKeyFactory
+import javax.crypto.spec.DESKeySpec
+import javax.crypto.spec.IvParameterSpec
+
+class DesMachineModule(reactContext: ReactApplicationContext) :
+  NativeDesMachineSpec(reactContext) {
+
+  private var secretKey: SecretKey? = null
+  private var mode: String = MODE_ECB
+  private var padding: String = PADDING_PKCS7
+  private var outputFormat: String = FORMAT_BASE64
+  private var ivSpec: IvParameterSpec? = null
+
+  /**
+   * Set the DES machine parameters including key, mode, padding, and output format.
+   * @param params ReadableMap containing:
+   *   - key: String (required, minimum 8 characters)
+   *   - mode: String (optional, default: ECB) - ECB, CBC, CFB, OFB, CTR
+   *   - padding: String (optional, default: PKCS7) - PKCS7, ISO10126, ZERO, NONE
+   *   - outputFormat: String (optional, default: BASE64) - BASE64, HEX
+   */
+  override fun setMachineParams(params: ReadableMap) {
+    // Extract and validate key
+    val key = params.getString("key")
+      ?: throw IllegalArgumentException("Key is required")
+    require(key.length >= 8) { "DES key must be at least 8 characters long" }
+
+    // Extract optional parameters with defaults
+    mode = params.getString("mode") ?: MODE_ECB
+    padding = params.getString("padding") ?: PADDING_PKCS7
+    outputFormat = params.getString("outputFormat") ?: FORMAT_BASE64
+
+    // Initialize secret key
+    val keyBytes = key.toByteArray(Charsets.UTF_8)
+    val desKeySpec = DESKeySpec(keyBytes)
+    val keyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM)
+    secretKey = keyFactory.generateSecret(desKeySpec)
+
+    // Initialize IV for modes that require it (CBC, CFB, OFB, CTR)
+    if (mode != MODE_ECB) {
+      // Use first 8 bytes of key as IV (DES block size is 8 bytes)
+      val ivBytes = keyBytes.copyOf(8)
+      ivSpec = IvParameterSpec(ivBytes)
+    }
+  }
+
+  /**
+   * Encrypt the provided plaintext using DES algorithm.
+   * @param text The plaintext to encrypt
+   * @return Encrypted string in the configured output format (BASE64 or HEX)
+   */
+  override fun encrypt(text: String): String {
+    val key = secretKey
+      ?: throw IllegalStateException("DES not initialized. Call setMachineParams() first.")
+
+    val transformation = buildTransformation()
+    val cipher = Cipher.getInstance(transformation)
+
+    if (mode == MODE_ECB) {
+      cipher.init(Cipher.ENCRYPT_MODE, key)
+    } else {
+      cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec)
+    }
+
+    val inputBytes = applyPaddingIfNeeded(text.toByteArray(Charsets.UTF_8))
+    val encryptedBytes = cipher.doFinal(inputBytes)
+
+    return formatOutput(encryptedBytes)
+  }
+
+  /**
+   * Decrypt the provided ciphertext using DES algorithm.
+   * @param text Encrypted string in the configured format (BASE64 or HEX)
+   * @return Decrypted plaintext
+   */
+  override fun decrypt(text: String): String {
+    val key = secretKey
+      ?: throw IllegalStateException("DES not initialized. Call setMachineParams() first.")
+
+    val transformation = buildTransformation()
+    val cipher = Cipher.getInstance(transformation)
+
+    if (mode == MODE_ECB) {
+      cipher.init(Cipher.DECRYPT_MODE, key)
+    } else {
+      cipher.init(Cipher.DECRYPT_MODE, key, ivSpec)
+    }
+
+    val encryptedBytes = parseInput(text)
+    val decryptedBytes = cipher.doFinal(encryptedBytes)
+
+    return String(removePaddingIfNeeded(decryptedBytes), Charsets.UTF_8)
+  }
+
+  /**
+   * Build the cipher transformation string based on mode and padding.
+   */
+  private fun buildTransformation(): String {
+    val javaPadding = when (padding) {
+      PADDING_PKCS7 -> "PKCS5Padding" // PKCS5 is equivalent to PKCS7 for DES
+      PADDING_ISO10126 -> "ISO10126Padding"
+      PADDING_ZERO, PADDING_NONE -> "NoPadding"
+      else -> "PKCS5Padding"
+    }
+    return "$DES_ALGORITHM/$mode/$javaPadding"
+  }
+
+  /**
+   * Apply manual padding for ZERO padding mode.
+   */
+  private fun applyPaddingIfNeeded(data: ByteArray): ByteArray {
+    if (padding != PADDING_ZERO && padding != PADDING_NONE) {
+      return data
+    }
+
+    val blockSize = 8 // DES block size
+    val paddingLength = blockSize - (data.size % blockSize)
+    if (paddingLength == blockSize && padding == PADDING_NONE) {
+      return data
+    }
+
+    val paddedData = ByteArray(data.size + paddingLength)
+    System.arraycopy(data, 0, paddedData, 0, data.size)
+    // Zero padding: remaining bytes are already 0
+    return paddedData
+  }
+
+  /**
+   * Remove manual padding for ZERO padding mode.
+   */
+  private fun removePaddingIfNeeded(data: ByteArray): ByteArray {
+    if (padding != PADDING_ZERO) {
+      return data
+    }
+
+    // Find last non-zero byte
+    var lastIndex = data.size - 1
+    while (lastIndex >= 0 && data[lastIndex] == 0.toByte()) {
+      lastIndex--
+    }
+    return data.copyOf(lastIndex + 1)
+  }
+
+  /**
+   * Format encrypted bytes to the configured output format.
+   */
+  private fun formatOutput(bytes: ByteArray): String {
+    return when (outputFormat) {
+      FORMAT_HEX -> bytes.joinToString("") { "%02x".format(it) }
+      else -> Base64.encodeToString(bytes, Base64.NO_WRAP)
+    }
+  }
+
+  /**
+   * Parse input string from the configured format to bytes.
+   */
+  private fun parseInput(text: String): ByteArray {
+    return when (outputFormat) {
+      FORMAT_HEX -> text.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+      else -> Base64.decode(text, Base64.NO_WRAP)
+    }
+  }
+
+  companion object {
+    const val NAME = NativeDesMachineSpec.NAME
+
+    private const val DES_ALGORITHM = "DES"
+
+    // Mode constants
+    private const val MODE_ECB = "ECB"
+    private const val MODE_CBC = "CBC"
+    private const val MODE_CFB = "CFB"
+    private const val MODE_OFB = "OFB"
+    private const val MODE_CTR = "CTR"
+
+    // Padding constants
+    private const val PADDING_PKCS7 = "PKCS7"
+    private const val PADDING_ISO10126 = "ISO10126"
+    private const val PADDING_ZERO = "ZERO"
+    private const val PADDING_NONE = "NONE"
+
+    // Output format constants
+    private const val FORMAT_BASE64 = "BASE64"
+    private const val FORMAT_HEX = "HEX"
+  }
+}

package/android/src/main/java/com/desmachine/DesMachinePackage.kt

@@ -0,0 +1,33 @@
+package com.desmachine
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class DesMachinePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == DesMachineModule.NAME) {
+      DesMachineModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[DesMachineModule.NAME] = ReactModuleInfo(
+        DesMachineModule.NAME,
+        DesMachineModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/DesMachine.h

@@ -0,0 +1,12 @@
+#import <DesMachineSpec/DesMachineSpec.h>
+#import <CommonCrypto/CommonCryptor.h>
+
+@interface DesMachine : NSObject <NativeDesMachineSpec>
+
+@property (nonatomic, strong) NSData *secretKey;
+@property (nonatomic, strong) NSData *ivData;
+@property (nonatomic, copy) NSString *mode;
+@property (nonatomic, copy) NSString *padding;
+@property (nonatomic, copy) NSString *outputFormat;
+
+@end

package/ios/DesMachine.mm

@@ -0,0 +1,281 @@
+#import "DesMachine.h"
+#import <CommonCrypto/CommonCryptor.h>
+
+// Mode constants
+static NSString *const MODE_ECB = @"ECB";
+static NSString *const MODE_CBC = @"CBC";
+static NSString *const MODE_CFB = @"CFB";
+static NSString *const MODE_OFB = @"OFB";
+static NSString *const MODE_CTR = @"CTR";
+
+// Padding constants
+static NSString *const PADDING_PKCS7 = @"PKCS7";
+static NSString *const PADDING_ISO10126 = @"ISO10126";
+static NSString *const PADDING_ZERO = @"ZERO";
+static NSString *const PADDING_NONE = @"NONE";
+
+// Output format constants
+static NSString *const FORMAT_BASE64 = @"BASE64";
+static NSString *const FORMAT_HEX = @"HEX";
+
+@implementation DesMachine
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _mode = MODE_ECB;
+        _padding = PADDING_PKCS7;
+        _outputFormat = FORMAT_BASE64;
+    }
+    return self;
+}
+
+#pragma mark - TurboModule
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeDesMachineSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+    return @"DesMachine";
+}
+
+#pragma mark - NativeDesMachineSpec Methods
+
+/**
+ * Set the DES machine parameters including key, mode, padding, and output format.
+ * @param params NSDictionary containing:
+ *   - key: NSString (required, minimum 8 characters)
+ *   - mode: NSString (optional, default: ECB) - ECB, CBC, CFB, OFB, CTR
+ *   - padding: NSString (optional, default: PKCS7) - PKCS7, ISO10126, ZERO, NONE
+ *   - outputFormat: NSString (optional, default: BASE64) - BASE64, HEX
+ */
+- (void)setMachineParams:(JS::NativeDesMachine::DesMachineParams &)params {
+    NSString *key = params.key();
+    
+    if (!key || key.length < 8) {
+        @throw [NSException exceptionWithName:@"InvalidKeyException"
+                                       reason:@"DES key must be at least 8 characters long"
+                                     userInfo:nil];
+    }
+    
+    // Extract optional parameters with defaults
+    // Codegen returns NSString* (nil if not provided) for optional string params
+    NSString *modeParam = params.mode();
+    NSString *paddingParam = params.padding();
+    NSString *outputFormatParam = params.outputFormat();
+    
+    self.mode = (modeParam && modeParam.length > 0) ? modeParam : MODE_ECB;
+    self.padding = (paddingParam && paddingParam.length > 0) ? paddingParam : PADDING_PKCS7;
+    self.outputFormat = (outputFormatParam && outputFormatParam.length > 0) ? outputFormatParam : FORMAT_BASE64;
+    
+    // Initialize secret key (DES uses 8 bytes)
+    NSData *keyData = [key dataUsingEncoding:NSUTF8StringEncoding];
+    self.secretKey = [keyData subdataWithRange:NSMakeRange(0, MIN(8, keyData.length))];
+    
+    // Pad key to 8 bytes if needed
+    if (self.secretKey.length < 8) {
+        NSMutableData *paddedKey = [NSMutableData dataWithData:self.secretKey];
+        [paddedKey setLength:8];
+        self.secretKey = paddedKey;
+    }
+    
+    // Initialize IV for modes that require it (use first 8 bytes of key)
+    if (![self.mode isEqualToString:MODE_ECB]) {
+        self.ivData = [self.secretKey copy];
+    } else {
+        self.ivData = nil;
+    }
+}
+
+/**
+ * Encrypt the provided plaintext using DES algorithm.
+ * @param text The plaintext to encrypt
+ * @return Encrypted string in the configured output format (BASE64 or HEX)
+ */
+- (NSString *)encrypt:(NSString *)text {
+    if (!self.secretKey) {
+        @throw [NSException exceptionWithName:@"NotInitializedException"
+                                       reason:@"DES not initialized. Call setMachineParams() first."
+                                     userInfo:nil];
+    }
+    
+    NSData *inputData = [text dataUsingEncoding:NSUTF8StringEncoding];
+    NSData *paddedData = [self applyPadding:inputData];
+    NSData *encryptedData = [self performDESOperation:kCCEncrypt onData:paddedData];
+    
+    return [self formatOutput:encryptedData];
+}
+
+/**
+ * Decrypt the provided ciphertext using DES algorithm.
+ * @param text Encrypted string in the configured format (BASE64 or HEX)
+ * @return Decrypted plaintext
+ */
+- (NSString *)decrypt:(NSString *)text {
+    if (!self.secretKey) {
+        @throw [NSException exceptionWithName:@"NotInitializedException"
+                                       reason:@"DES not initialized. Call setMachineParams() first."
+                                     userInfo:nil];
+    }
+    
+    NSData *encryptedData = [self parseInput:text];
+    NSData *decryptedData = [self performDESOperation:kCCDecrypt onData:encryptedData];
+    NSData *unpaddedData = [self removePadding:decryptedData];
+    
+    return [[NSString alloc] initWithData:unpaddedData encoding:NSUTF8StringEncoding];
+}
+
+#pragma mark - DES Operations
+
+- (NSData *)performDESOperation:(CCOperation)operation onData:(NSData *)data {
+    CCOptions options = [self getCCOptions];
+    
+    size_t bufferSize = data.length + kCCBlockSizeDES;
+    void *buffer = malloc(bufferSize);
+    size_t numBytesProcessed = 0;
+    
+    CCCryptorStatus status = CCCrypt(
+        operation,
+        kCCAlgorithmDES,
+        options,
+        self.secretKey.bytes,
+        kCCKeySizeDES,
+        self.ivData.bytes,
+        data.bytes,
+        data.length,
+        buffer,
+        bufferSize,
+        &numBytesProcessed
+    );
+    
+    if (status != kCCSuccess) {
+        free(buffer);
+        @throw [NSException exceptionWithName:@"CryptoException"
+                                       reason:[NSString stringWithFormat:@"DES operation failed with status: %d", status]
+                                     userInfo:nil];
+    }
+    
+    NSData *result = [NSData dataWithBytes:buffer length:numBytesProcessed];
+    free(buffer);
+    
+    return result;
+}
+
+- (CCOptions)getCCOptions {
+    CCOptions options = 0;
+    
+    // ECB mode
+    if ([self.mode isEqualToString:MODE_ECB]) {
+        options |= kCCOptionECBMode;
+    }
+    
+    // Padding
+    if ([self.padding isEqualToString:PADDING_PKCS7]) {
+        options |= kCCOptionPKCS7Padding;
+    }
+    // For other padding types, we handle manually (no padding flag = NoPadding)
+    
+    return options;
+}
+
+#pragma mark - Padding
+
+- (NSData *)applyPadding:(NSData *)data {
+    if ([self.padding isEqualToString:PADDING_PKCS7]) {
+        // PKCS7 is handled by CommonCrypto
+        return data;
+    }
+    
+    NSUInteger blockSize = kCCBlockSizeDES;
+    NSUInteger paddingLength = blockSize - (data.length % blockSize);
+    
+    if (paddingLength == blockSize && [self.padding isEqualToString:PADDING_NONE]) {
+        return data;
+    }
+    
+    NSMutableData *paddedData = [NSMutableData dataWithData:data];
+    
+    if ([self.padding isEqualToString:PADDING_ZERO] || [self.padding isEqualToString:PADDING_NONE]) {
+        // Zero padding
+        [paddedData setLength:data.length + paddingLength];
+    } else if ([self.padding isEqualToString:PADDING_ISO10126]) {
+        // ISO10126: random bytes followed by padding length
+        uint8_t randomBytes[paddingLength];
+        for (NSUInteger i = 0; i < paddingLength - 1; i++) {
+            randomBytes[i] = arc4random_uniform(256);
+        }
+        randomBytes[paddingLength - 1] = (uint8_t)paddingLength;
+        [paddedData appendBytes:randomBytes length:paddingLength];
+    }
+    
+    return paddedData;
+}
+
+- (NSData *)removePadding:(NSData *)data {
+    if ([self.padding isEqualToString:PADDING_PKCS7]) {
+        // PKCS7 is handled by CommonCrypto
+        return data;
+    }
+    
+    if ([self.padding isEqualToString:PADDING_ZERO]) {
+        // Find last non-zero byte
+        const uint8_t *bytes = (const uint8_t *)data.bytes;
+        NSInteger lastIndex = data.length - 1;
+        while (lastIndex >= 0 && bytes[lastIndex] == 0) {
+            lastIndex--;
+        }
+        return [data subdataWithRange:NSMakeRange(0, lastIndex + 1)];
+    }
+    
+    if ([self.padding isEqualToString:PADDING_ISO10126]) {
+        // Last byte indicates padding length
+        const uint8_t *bytes = (const uint8_t *)data.bytes;
+        uint8_t paddingLength = bytes[data.length - 1];
+        if (paddingLength > 0 && paddingLength <= kCCBlockSizeDES) {
+            return [data subdataWithRange:NSMakeRange(0, data.length - paddingLength)];
+        }
+    }
+    
+    return data;
+}
+
+#pragma mark - Output Formatting
+
+- (NSString *)formatOutput:(NSData *)data {
+    if ([self.outputFormat isEqualToString:FORMAT_HEX]) {
+        NSMutableString *hexString = [NSMutableString stringWithCapacity:data.length * 2];
+        const uint8_t *bytes = (const uint8_t *)data.bytes;
+        for (NSUInteger i = 0; i < data.length; i++) {
+            [hexString appendFormat:@"%02x", bytes[i]];
+        }
+        return hexString;
+    }
+    
+    // Default: BASE64
+    return [data base64EncodedStringWithOptions:0];
+}
+
+- (NSData *)parseInput:(NSString *)text {
+    if ([self.outputFormat isEqualToString:FORMAT_HEX]) {
+        NSMutableData *data = [NSMutableData dataWithCapacity:text.length / 2];
+        for (NSUInteger i = 0; i < text.length; i += 2) {
+            NSString *hexByte = [text substringWithRange:NSMakeRange(i, 2)];
+            unsigned int byteValue;
+            [[NSScanner scannerWithString:hexByte] scanHexInt:&byteValue];
+            uint8_t byte = (uint8_t)byteValue;
+            [data appendBytes:&byte length:1];
+        }
+        return data;
+    }
+    
+    // Default: BASE64
+    return [[NSData alloc] initWithBase64EncodedString:text options:0];
+}
+
+@end

package/lib/module/NativeDesMachine.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('DesMachine');
+//# sourceMappingURL=NativeDesMachine.js.map

package/lib/module/NativeDesMachine.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeDesMachine.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAmBpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,YAAY,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+import DesMachine from "./NativeDesMachine.js";
+const Padding = {
+  PKCS7: 'PKCS7',
+  ISO10126: 'ISO10126',
+  ZERO: 'ZERO',
+  NONE: 'NONE'
+};
+const Mode = {
+  ECB: 'ECB',
+  CBC: 'CBC',
+  CFB: 'CFB',
+  OFB: 'OFB',
+  CTR: 'CTR'
+};
+const Format = {
+  BASE64: 'BASE64',
+  HEX: 'HEX'
+};
+const modeOptions = [{
+  label: 'ECB (Electronic Codebook)',
+  value: Mode.ECB
+}, {
+  label: 'CBC (Cipher Block Chaining)',
+  value: Mode.CBC
+}, {
+  label: 'CFB (Cipher Feedback)',
+  value: Mode.CFB
+}, {
+  label: 'OFB (Output Feedback)',
+  value: Mode.OFB
+}, {
+  label: 'CTR (Counter)',
+  value: Mode.CTR
+}];
+const paddingOptions = [{
+  label: 'PKCS7',
+  value: Padding.PKCS7
+}, {
+  label: 'ISO10126',
+  value: Padding.ISO10126
+}, {
+  label: 'Zero Padding',
+  value: Padding.ZERO
+}, {
+  label: 'No Padding',
+  value: Padding.NONE
+}];
+const formatOptions = [{
+  label: 'Base64',
+  value: Format.BASE64
+}, {
+  label: 'Hexadecimal',
+  value: Format.HEX
+}];
+const defaultParams = {
+  mode: Mode.ECB,
+  padding: Padding.PKCS7,
+  outputFormat: Format.BASE64
+};
+export function setMachineParams(params) {
+  DesMachine.setMachineParams({
+    ...defaultParams,
+    ...params
+  });
+}
+export function encrypt(text) {
+  return DesMachine.encrypt(text);
+}
+export function decrypt(text) {
+  return DesMachine.decrypt(text);
+}
+export { Mode, Padding, Format, modeOptions, paddingOptions, formatOptions };
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DesMachine","Padding","PKCS7","ISO10126","ZERO","NONE","Mode","ECB","CBC","CFB","OFB","CTR","Format","BASE64","HEX","modeOptions","label","value","paddingOptions","formatOptions","defaultParams","mode","padding","outputFormat","setMachineParams","params","encrypt","text","decrypt"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,OAAOA,UAAU,MAAiC,uBAAoB;AAOtE,MAAMC,OAA6D,GAAG;EACpEC,KAAK,EAAE,OAAO;EACdC,QAAQ,EAAE,UAAU;EACpBC,IAAI,EAAE,MAAM;EACZC,IAAI,EAAE;AACR,CAAC;AAED,MAAMC,IAAoD,GAAG;EAC3DC,GAAG,EAAE,KAAK;EACVC,GAAG,EAAE,KAAK;EACVC,GAAG,EAAE,KAAK;EACVC,GAAG,EAAE,KAAK;EACVC,GAAG,EAAE;AACP,CAAC;AAED,MAAMC,MAAkD,GAAG;EACzDC,MAAM,EAAE,QAAQ;EAChBC,GAAG,EAAE;AACP,CAAC;AAOD,MAAMC,WAA8C,GAAG,CACrD;EAAEC,KAAK,EAAE,2BAA2B;EAAEC,KAAK,EAAEX,IAAI,CAACC;AAAI,CAAC,EACvD;EAAES,KAAK,EAAE,6BAA6B;EAAEC,KAAK,EAAEX,IAAI,CAACE;AAAI,CAAC,EACzD;EAAEQ,KAAK,EAAE,uBAAuB;EAAEC,KAAK,EAAEX,IAAI,CAACG;AAAI,CAAC,EACnD;EAAEO,KAAK,EAAE,uBAAuB;EAAEC,KAAK,EAAEX,IAAI,CAACI;AAAI,CAAC,EACnD;EAAEM,KAAK,EAAE,eAAe;EAAEC,KAAK,EAAEX,IAAI,CAACK;AAAI,CAAC,CAC5C;AAED,MAAMO,cAAoD,GAAG,CAC3D;EAAEF,KAAK,EAAE,OAAO;EAAEC,KAAK,EAAEhB,OAAO,CAACC;AAAM,CAAC,EACxC;EAAEc,KAAK,EAAE,UAAU;EAAEC,KAAK,EAAEhB,OAAO,CAACE;AAAS,CAAC,EAC9C;EAAEa,KAAK,EAAE,cAAc;EAAEC,KAAK,EAAEhB,OAAO,CAACG;AAAK,CAAC,EAC9C;EAAEY,KAAK,EAAE,YAAY;EAAEC,KAAK,EAAEhB,OAAO,CAACI;AAAK,CAAC,CAC7C;AAED,MAAMc,aAA8C,GAAG,CACrD;EAAEH,KAAK,EAAE,QAAQ;EAAEC,KAAK,EAAEL,MAAM,CAACC;AAAO,CAAC,EACzC;EAAEG,KAAK,EAAE,aAAa;EAAEC,KAAK,EAAEL,MAAM,CAACE;AAAI,CAAC,CAC5C;AAED,MAAMM,aAAwC,GAAG;EAC/CC,IAAI,EAAEf,IAAI,CAACC,GAAG;EACde,OAAO,EAAErB,OAAO,CAACC,KAAK;EACtBqB,YAAY,EAAEX,MAAM,CAACC;AACvB,CAAC;AAED,OAAO,SAASW,gBAAgBA,CAACC,MAAwB,EAAQ;EAC/DzB,UAAU,CAACwB,gBAAgB,CAAC;IAC1B,GAAGJ,aAAa;IAChB,GAAGK;EACL,CAAC,CAAC;AACJ;AAEA,OAAO,SAASC,OAAOA,CAACC,IAAY,EAAU;EAC5C,OAAO3B,UAAU,CAAC0B,OAAO,CAACC,IAAI,CAAC;AACjC;AAEA,OAAO,SAASC,OAAOA,CAACD,IAAY,EAAU;EAC5C,OAAO3B,UAAU,CAAC4B,OAAO,CAACD,IAAI,CAAC;AACjC;AAEA,SAASrB,IAAI,EAAEL,OAAO,EAAEW,MAAM,EAAEG,WAAW,EAAEG,cAAc,EAAEC,aAAa","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/NativeDesMachine.d.ts

@@ -0,0 +1,18 @@
+import { type TurboModule } from 'react-native';
+export type ModeEncryptionType = 'ECB' | 'CBC' | 'CFB' | 'OFB' | 'CTR';
+export type PaddingEncryptionType = 'PKCS7' | 'ISO10126' | 'ZERO' | 'NONE';
+export type OutputFormatType = 'BASE64' | 'HEX';
+export interface DesMachineParams {
+    key: string;
+    mode?: ModeEncryptionType;
+    padding?: PaddingEncryptionType;
+    outputFormat?: OutputFormatType;
+}
+export interface Spec extends TurboModule {
+    setMachineParams(params: DesMachineParams): void;
+    encrypt(text: string): string;
+    decrypt(text: string): string;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeDesMachine.d.ts.map

package/lib/typescript/src/NativeDesMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeDesMachine.d.ts","sourceRoot":"","sources":["../../../src/NativeDesMachine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAC3E,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAED,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACjD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;;AAED,wBAAoE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,18 @@
+import { type DesMachineParams } from './NativeDesMachine';
+import type { ModeEncryptionType, PaddingEncryptionType, OutputFormatType } from './NativeDesMachine';
+declare const Padding: Record<PaddingEncryptionType, PaddingEncryptionType>;
+declare const Mode: Record<ModeEncryptionType, ModeEncryptionType>;
+declare const Format: Record<OutputFormatType, OutputFormatType>;
+interface OptionsList<T extends string> {
+    label: string;
+    value: T;
+}
+declare const modeOptions: OptionsList<ModeEncryptionType>[];
+declare const paddingOptions: OptionsList<PaddingEncryptionType>[];
+declare const formatOptions: OptionsList<OutputFormatType>[];
+export declare function setMachineParams(params: DesMachineParams): void;
+export declare function encrypt(text: string): string;
+export declare function decrypt(text: string): string;
+export { Mode, Padding, Format, modeOptions, paddingOptions, formatOptions };
+export type { ModeEncryptionType, PaddingEncryptionType, OutputFormatType };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,QAAA,MAAM,OAAO,EAAE,MAAM,CAAC,qBAAqB,EAAE,qBAAqB,CAKjE,CAAC;AAEF,QAAA,MAAM,IAAI,EAAE,MAAM,CAAC,kBAAkB,EAAE,kBAAkB,CAMxD,CAAC;AAEF,QAAA,MAAM,MAAM,EAAE,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,CAGtD,CAAC;AAEF,UAAU,WAAW,CAAC,CAAC,SAAS,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV;AAED,QAAA,MAAM,WAAW,EAAE,WAAW,CAAC,kBAAkB,CAAC,EAMjD,CAAC;AAEF,QAAA,MAAM,cAAc,EAAE,WAAW,CAAC,qBAAqB,CAAC,EAKvD,CAAC;AAEF,QAAA,MAAM,aAAa,EAAE,WAAW,CAAC,gBAAgB,CAAC,EAGjD,CAAC;AAQF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAK/D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,168 @@
+{
+  "name": "react-native-des-machine",
+  "version": "0.1.0",
+  "description": "React Native module that provides simple text encryption and decryption based on the DES algorithm.",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-des-machine-example",
+    "clean": "del-cli lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "test": "jest",
+    "release": "release-it --only-version",
+    "lint": "eslint \"**/*.{js,ts,tsx}\""
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NeRo8/react-native-des-machine.git"
+  },
+  "author": "Artur Duchenko <artur.duchenko@gmail.com> (https://github.com/NeRo8)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/NeRo8/react-native-des-machine/issues"
+  },
+  "homepage": "https://github.com/NeRo8/react-native-des-machine#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.12",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "DesMachineSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.desmachine"
+    }
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "jest",
+      "lefthook",
+      "release-it",
+      "eslint"
+    ],
+    "version": "0.57.0"
+  }
+}

package/src/NativeDesMachine.ts

@@ -0,0 +1,20 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export type ModeEncryptionType = 'ECB' | 'CBC' | 'CFB' | 'OFB' | 'CTR';
+export type PaddingEncryptionType = 'PKCS7' | 'ISO10126' | 'ZERO' | 'NONE';
+export type OutputFormatType = 'BASE64' | 'HEX';
+
+export interface DesMachineParams {
+  key: string;
+  mode?: ModeEncryptionType;
+  padding?: PaddingEncryptionType;
+  outputFormat?: OutputFormatType;
+}
+
+export interface Spec extends TurboModule {
+  setMachineParams(params: DesMachineParams): void;
+  encrypt(text: string): string;
+  decrypt(text: string): string;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('DesMachine');

package/src/index.ts

@@ -0,0 +1,75 @@
+import DesMachine, { type DesMachineParams } from './NativeDesMachine';
+import type {
+  ModeEncryptionType,
+  PaddingEncryptionType,
+  OutputFormatType,
+} from './NativeDesMachine';
+
+const Padding: Record<PaddingEncryptionType, PaddingEncryptionType> = {
+  PKCS7: 'PKCS7',
+  ISO10126: 'ISO10126',
+  ZERO: 'ZERO',
+  NONE: 'NONE',
+};
+
+const Mode: Record<ModeEncryptionType, ModeEncryptionType> = {
+  ECB: 'ECB',
+  CBC: 'CBC',
+  CFB: 'CFB',
+  OFB: 'OFB',
+  CTR: 'CTR',
+};
+
+const Format: Record<OutputFormatType, OutputFormatType> = {
+  BASE64: 'BASE64',
+  HEX: 'HEX',
+};
+
+interface OptionsList<T extends string> {
+  label: string;
+  value: T;
+}
+
+const modeOptions: OptionsList<ModeEncryptionType>[] = [
+  { label: 'ECB (Electronic Codebook)', value: Mode.ECB },
+  { label: 'CBC (Cipher Block Chaining)', value: Mode.CBC },
+  { label: 'CFB (Cipher Feedback)', value: Mode.CFB },
+  { label: 'OFB (Output Feedback)', value: Mode.OFB },
+  { label: 'CTR (Counter)', value: Mode.CTR },
+];
+
+const paddingOptions: OptionsList<PaddingEncryptionType>[] = [
+  { label: 'PKCS7', value: Padding.PKCS7 },
+  { label: 'ISO10126', value: Padding.ISO10126 },
+  { label: 'Zero Padding', value: Padding.ZERO },
+  { label: 'No Padding', value: Padding.NONE },
+];
+
+const formatOptions: OptionsList<OutputFormatType>[] = [
+  { label: 'Base64', value: Format.BASE64 },
+  { label: 'Hexadecimal', value: Format.HEX },
+];
+
+const defaultParams: Partial<DesMachineParams> = {
+  mode: Mode.ECB,
+  padding: Padding.PKCS7,
+  outputFormat: Format.BASE64,
+};
+
+export function setMachineParams(params: DesMachineParams): void {
+  DesMachine.setMachineParams({
+    ...defaultParams,
+    ...params,
+  });
+}
+
+export function encrypt(text: string): string {
+  return DesMachine.encrypt(text);
+}
+
+export function decrypt(text: string): string {
+  return DesMachine.decrypt(text);
+}
+
+export { Mode, Padding, Format, modeOptions, paddingOptions, formatOptions };
+export type { ModeEncryptionType, PaddingEncryptionType, OutputFormatType };