Struct spatial_hasher::Spha256

pub struct Spha256 { /* private fields */ }

A hasher that uses a 3D point and a rotation axis to encrypt and decrypt data.

The Spha256 struct provides methods for encrypting and decrypting data based on a deterministic algorithm. It derives a cryptographic key from its parameters and uses the ChaCha20-Poly1305 authenticated encryption algorithm for secure encryption and decryption.

Examples

use spatial_hasher::{Point3D, RotationAxis, Spha256};
let point = Point3D { x: 1.0, y: 2.0, z: 3.0 };
let axis = RotationAxis { x: 0.0, y: 1.0, z: 0.0 };
let hasher = Spha256::new(point, axis, 10, 0.1);

Implementations

impl Spha256

pub fn new( point: Point3D, rotation_axis: RotationAxis, iterations: u32, strength: f64, ) -> Self

Creates a new Spha256 instance with the specified parameters.

Arguments

• point - A Point3D specifying the starting point in 3D space.
• rotation_axis - A RotationAxis specifying the axis of rotation.
• iterations - The number of iterations to perform in the hashing process.
• strength - A floating-point value representing the strength of the transformation.

Returns

A new Spha256 instance configured with the provided parameters.

Examples

use spatial_hasher::{Point3D, RotationAxis, Spha256};
let point = Point3D { x: 1.0, y: 2.0, z: 3.0 };
let axis = RotationAxis { x: 0.0, y: 1.0, z: 0.0 };
let hasher = Spha256::new(point, axis, 10, 0.1);

Examples found in repository

examples/basic_usage.rs (line 17)

fn main() {
    // Define the starting point and rotation axis
    let point = Point3D {
        x: 1.0,
        y: 2.0,
        z: 3.0,
    };
    let axis = RotationAxis {
        x: 0.0,
        y: 1.0,
        z: 0.0,
    };

    // Create a new SpaceHasher instance
    let hasher = Spha256::new(point, axis, 10, 0.1);

    // Original data to be encrypted
    let original_data = b"Hello, World!";
    println!(
        "Original Data: {:?}",
        String::from_utf8_lossy(original_data)
    );

    // Encrypt the data
    let encrypted = hasher.encrypt(original_data);
    println!("Encrypted Data: {:?}", encrypted);

    // Decrypt the data
    let decrypted = hasher.decrypt(&encrypted).expect("Decryption failed");
    println!("Decrypted Data: {:?}", String::from_utf8_lossy(&decrypted));

    // Verify that the decrypted data matches the original data
    assert_eq!(original_data, &decrypted[..], "Decryption failed");
}

pub fn encrypt(&self, data: &[u8]) -> Vec<u8>

Encrypts the provided data using the ChaCha20-Poly1305 authenticated encryption algorithm.

This method encrypts the input data using the ChaCha20-Poly1305 cipher, with a key derived from the hasher’s parameters via the generate_key method. A random nonce is generated for each encryption operation to ensure uniqueness and security. The nonce is prepended to the ciphertext for use during decryption.

Arguments

• data - A slice of bytes representing the data to encrypt.

Returns

A Vec<u8> containing the encrypted data, with the nonce prepended.

Examples

use spatial_hasher::{Spha256, Point3D, RotationAxis};
let point = Point3D { x: 1.0, y: 2.0, z: 3.0 };
let axis = RotationAxis { x: 0.0, y: 1.0, z: 0.0 };
let hasher = Spha256::new(point, axis, 10, 0.1);

let data = b"Secret Message";
let encrypted = hasher.encrypt(data);

Examples found in repository

examples/basic_usage.rs (line 27)

fn main() {
    // Define the starting point and rotation axis
    let point = Point3D {
        x: 1.0,
        y: 2.0,
        z: 3.0,
    };
    let axis = RotationAxis {
        x: 0.0,
        y: 1.0,
        z: 0.0,
    };

    // Create a new SpaceHasher instance
    let hasher = Spha256::new(point, axis, 10, 0.1);

    // Original data to be encrypted
    let original_data = b"Hello, World!";
    println!(
        "Original Data: {:?}",
        String::from_utf8_lossy(original_data)
    );

    // Encrypt the data
    let encrypted = hasher.encrypt(original_data);
    println!("Encrypted Data: {:?}", encrypted);

    // Decrypt the data
    let decrypted = hasher.decrypt(&encrypted).expect("Decryption failed");
    println!("Decrypted Data: {:?}", String::from_utf8_lossy(&decrypted));

    // Verify that the decrypted data matches the original data
    assert_eq!(original_data, &decrypted[..], "Decryption failed");
}

pub fn decrypt(&self, encrypted: &[u8]) -> Result<Vec<u8>, &'static str>

Decrypts the provided data using the ChaCha20-Poly1305 authenticated decryption algorithm.

This method decrypts the input data using the ChaCha20-Poly1305 cipher, with a key derived from the hasher’s parameters via the generate_key method. The nonce used during encryption is expected to be prepended to the encrypted data and is extracted during decryption.

Arguments

• encrypted - A slice of bytes representing the encrypted data, with the nonce prepended.

Returns

A Result<Vec<u8>, &'static str> containing the decrypted data on success, or an error message on failure.

Errors

Returns an error if the decryption fails, such as when the ciphertext has been tampered with or the parameters do not match those used during encryption.

Examples

use spatial_hasher::{Spha256, Point3D, RotationAxis};
let point = Point3D { x: 1.0, y: 2.0, z: 3.0 };
let axis = RotationAxis { x: 0.0, y: 1.0, z: 0.0 };
let hasher = Spha256::new(point, axis, 10, 0.1);

let encrypted = hasher.encrypt(b"Secret Message");
let decrypted = hasher.decrypt(&encrypted).expect("Decryption failed");
assert_eq!(decrypted, b"Secret Message");

Examples found in repository

examples/basic_usage.rs (line 31)

fn main() {
    // Define the starting point and rotation axis
    let point = Point3D {
        x: 1.0,
        y: 2.0,
        z: 3.0,
    };
    let axis = RotationAxis {
        x: 0.0,
        y: 1.0,
        z: 0.0,
    };

    // Create a new SpaceHasher instance
    let hasher = Spha256::new(point, axis, 10, 0.1);

    // Original data to be encrypted
    let original_data = b"Hello, World!";
    println!(
        "Original Data: {:?}",
        String::from_utf8_lossy(original_data)
    );

    // Encrypt the data
    let encrypted = hasher.encrypt(original_data);
    println!("Encrypted Data: {:?}", encrypted);

    // Decrypt the data
    let decrypted = hasher.decrypt(&encrypted).expect("Decryption failed");
    println!("Decrypted Data: {:?}", String::from_utf8_lossy(&decrypted));

    // Verify that the decrypted data matches the original data
    assert_eq!(original_data, &decrypted[..], "Decryption failed");
}

Trait Implementations

impl Clone for Spha256

fn clone(&self) -> Spha256

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Spha256

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Spha256

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Spha256

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.