sharenet_passport_creator/libs/sharenet-passport

Sharenet Passport Library

A secure Rust library for creating and managing Sharenet Passport files (.spf) for decentralized identity management.

Features

• Secure Passport Creation: Generate encrypted .spf files with BIP-39 mnemonic recovery phrases
• Ed25519 Key Generation: Cryptographically secure key derivation and signing
• Recovery Support: Import passports from recovery phrases or existing .spf files
• Export & Re-encrypt: Export passports with new passwords
• Message Signing: Sign messages using your passport's private key
• Security First: Zeroize memory management and secure file encryption
• WASM Support: Compatible with web applications via WebAssembly

Installation

From Private Registry

[dependencies]
sharenet-passport = { version = "0.1.0", registry = "sharenet-sh-forgejo", features = ["std"] }

For WASM Projects

[dependencies]
sharenet-passport = { version = "0.1.0", registry = "sharenet-sh-forgejo", features = ["wasm"] }

Usage

Creating a New Passport

use sharenet_passport::{
    application::use_cases::CreatePassportUseCase,
    infrastructure::{Bip39MnemonicGenerator, Ed25519KeyDeriver, XChaCha20FileEncryptor, FileSystemStorage},
};

let use_case = CreatePassportUseCase::new(
    Bip39MnemonicGenerator,
    Ed25519KeyDeriver,
    XChaCha20FileEncryptor,
    FileSystemStorage,
);

let (passport, recovery_phrase) = use_case.execute("your-password", "passport.spf")?;

println!("Public Key: {:?}", passport.public_key());
println!("DID: {}", passport.did().as_str());
println!("Recovery Phrase: {}", recovery_phrase.to_string());

Importing from Recovery Phrase

use sharenet_passport::{
    application::use_cases::ImportFromRecoveryUseCase,
    infrastructure::{Bip39MnemonicGenerator, Ed25519KeyDeriver, XChaCha20FileEncryptor, FileSystemStorage},
};

let use_case = ImportFromRecoveryUseCase::new(
    Bip39MnemonicGenerator,
    Ed25519KeyDeriver,
    XChaCha20FileEncryptor,
    FileSystemStorage,
);

let recovery_words = vec!["word1".to_string(), "word2".to_string(), /* ... 24 words */];
let passport = use_case.execute(&recovery_words, "new-password", "recovered-passport.spf")?;

Signing Messages

use sharenet_passport::{
    application::use_cases::{ImportFromFileUseCase, SignCardUseCase},
    infrastructure::{XChaCha20FileEncryptor, FileSystemStorage},
};

// Import passport from file
let import_use_case = ImportFromFileUseCase::new(
    XChaCha20FileEncryptor,
    FileSystemStorage,
);

let passport = import_use_case.execute("passport.spf", "password", None)?;

// Sign message
let sign_use_case = SignCardUseCase::new();
let signature = sign_use_case.execute(&passport, "Hello, Sharenet!")?;

Architecture

Built with Clean Architecture principles:

• Domain Layer: Core entities (Passport, RecoveryPhrase, PublicKey, etc.) and traits
• Application Layer: Use cases (CreatePassport, ImportFromRecovery, SignCard, etc.)
• Infrastructure Layer: Crypto implementations, file storage

Feature Flags

• std (default): Standard library support for CLI and server applications
• wasm: WebAssembly support for web applications
• alloc: No-std with allocator support

Security Features

• XChaCha20-Poly1305: Authenticated encryption for file security
• HKDF-SHA256: Key derivation from passwords
• Zeroize: Secure memory wiping for sensitive data
• BIP-39: Standard mnemonic generation and validation
• Ed25519: Cryptographically secure signing

File Format (.spf)

Sharenet Passport Files (.spf) are encrypted containers that store:

• Encrypted Seed: The master seed encrypted with XChaCha20-Poly1305
• Public Key: Your Ed25519 public key
• DID: Your Decentralized Identifier
• Metadata: Creation timestamp, version, and encryption parameters

Development

Running Tests

# Run all tests
cargo test

# Test specific features
cargo test --features std
cargo test --features wasm

Building for WASM

# Install wasm-pack if needed
cargo install wasm-pack

# Build for web
wasm-pack build --target web --features wasm

License

This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.

You are free to:

• Share — copy and redistribute the material in any medium or format
• Adapt — remix, transform, and build upon the material

Under the following terms:

• Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made.
• NonCommercial — You may not use the material for commercial purposes.
• ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.

To view a copy of this license, visit https://creativecommons.org/licenses/by-nc-sa/4.0/