Bitwark  

通过紧凑的二进制令牌和自动化的加密防御，为Rust应用程序提供强大的安全保护。

🚀 简介

Bitwark实现了二进制JSON Web Tokens，作为标准JWT的高效带宽替代方案，同时集成自动化密钥轮换和加盐，以动态增强加密保护。

🔐 关键特性

• 二进制签名负载：签名负载的紧凑二进制编码（类似于JWT）
• 默认加密：Bitwark默认使用EdDSA进行签名和验证，使用SHA3-384（EdDSA_SHA3-384）。
• 轮换：轻松轮换密钥和盐，确保您的应用程序能够适应动态的安全环境。
• 加盐：注入随机数据以增加熵并减缓暴力攻击。
• 轻量级：最小化开销，确保在高吞吐量场景中也能实现最佳性能。

🛠️ 入门指南

通过在Rust应用程序中利用以下功能，开始Bitwark的加密之旅

解码为二进制的签名负载（JWT的替代方案）

use bitwark::{
    exp::AutoExpiring,
    signed_exp::ExpiringSigned,
    salt::Salt64,
    keys::{ed::EdDsaKey},
};
use serde::{Serialize, Deserialize};
use chrono::Duration;

#[derive(Serialize, Deserialize)]
pub struct Claims {
    pub permissions: Vec<String>,
}

// Generate an EdDSA key pair and salt with a validity period
let exp_key = AutoExpiring::<EdDsaKey>::generate(
    Duration::minutes(10)
).unwrap();

let exp_salt = AutoExpiring::<Salt64>::generate(
    Duration::minutes(5)
).unwrap();

// Instantiate a token with specified claims.
let claims = Claims { 
    permissions: vec![
        "users:read".to_string(), 
        "users:write".to_string()
    ],
};

let token = ExpiringSigned::<Claims>::new(
    Duration::seconds(120), claims
).unwrap();

// Create a binary encoding of the token, signed with key and salt.
let signed_token_bytes = token.encode_and_sign_salted(
    &exp_salt, &*exp_key
).expect("Failed to sign token");

// Decode the token and verify its signature and validity.
let decoded_token = ExpiringSigned::<Claims>::decode_and_verify_salted(
    &signed_token_bytes, &exp_salt, &*exp_key
).expect("Failed to decode a token");

assert_eq!(
    2, 
    decoded_token.permissions.len(), 
    "Failed to find 2 permissions"
);

密钥轮换

use bitwark::{payload::SignedPayload, keys::ed::EdDsaKey, keys::CryptoKey, Generator};
use chrono::Duration;

// creating a key
let key = EdDsaKey::generate()?;

// Rotating key
let mut expiring_key = Expiring<EdDsaKey>::new(Duration::seconds(10), key);
if expiring_key.has_expired() {
    expiring_key.roll()?;
}

// Creating a payload
let payload = SignedPayload::<String>::new("A signed message".to_string());

// Encode the payload with signature based on the expiring key
let signed_payload_bytes = payload.encode_and_sign(&expiring_key)?;

// Decode the signed payload with verifying signature with payload's integrity
let decoded_payload = SignedPayload::<String>::decode_and_verify(&signed_payload_bytes, &expiring_key)?;
assert_eq!(*decoded_payload, *payload);

盐示例

use bitwark::{
    salt::Salt64, 
    exp::AutoExpiring, 
    key::ed::EdDsaKey, 
    Rotation, Generator
};
use bitwark::payload::SignedPayload;
use chrono::Duration;

// Make a new salt.
let salt = Salt64::generate().unwrap();

// Make a salt that lasts for 10 seconds.
let mut expiring_salt = AutoExpiring::<Salt64>::new(
    Duration::seconds(10), salt
).unwrap();

// Change the salt if it's too old.
if expiring_salt.has_expired() {
    expiring_salt
        .rotate()
        .expect("Salt rotation failed.");
}

// Make a key that lasts for 120 seconds.
let key = AutoExpiring::<EdDsaKey>::generate(
    Duration::seconds(120)
).unwrap();

// Make a payload for signing
let payload = SignedPayload::<String>::new(
    "Hello, world!".to_string()
);

// Combine message and signature into one piece.
let signature_bytes = payload.encode_and_sign_salted(
    &expiring_salt, &*key
).expect("Failed to encode");

// Separate message and signature, verifying validity.
let decoded_result = 
    SignedPayload::<String>::decode_and_verify_salted(
        &signature_bytes, &expiring_salt, &*key
    );

assert!(decoded_result.is_ok());

💡 动机

在数据安全至关重要的时代，Bitwark旨在为开发者提供工具箱，以在性能或易用性方面不妥协的情况下构建安全的数字交互。轻量级的二进制JWT令牌最小化带宽使用，而密钥轮换和盐功能增强了安全性，确保您的应用程序不仅安全，而且高效和可靠。

🌱 贡献

成为Bitwark旅程的一部分！

贡献者是开源项目的支柱，Bitwark热烈欢迎所有渴望为二进制安全领域做出贡献的人！

🎗️ 如何贡献

• 🧠 提出想法：通过问题分享改进想法或报告错误。
• 🛠️ 代码贡献：提交带有新功能、增强或错误修复的拉取请求。
• 📚 改进文档：帮助我们使文档更全面、更易于使用。
• 💬 社区互动：加入讨论并提供反馈，以帮助使Bitwark变得更好。

📜 许可证

Bitwark 是开源软件，在 MIT 许可证或 BSD-3-Clause 许可下免费提供。