rust-auth-utils 1.0.0

A rust port of @better-auth/utils.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use crate::ecdsa::ECDSA;
use crate::types::{ECDSACurve, ExportKeyFormat, SHAFamily};

#[tokio::test]
async fn test_generate_key_pair() {
    let (private_key, public_key) = ECDSA::generate_key_pair(None)
        .await
        .expect("Failed to generate key pair");

    assert!(!private_key.is_empty());
    assert!(!public_key.is_empty());
}

#[tokio::test]
async fn test_sign_verify_flow() {
    let (private_key, public_key) = ECDSA::generate_key_pair(Some(ECDSACurve::P256))
        .await
        .expect("Failed to generate key pair");

    let signing_key = ECDSA::import_private_key(&private_key, ECDSACurve::P256, false)
        .await
        .expect("Failed to import private key");

    let verifying_key = ECDSA::import_public_key(&public_key, ECDSACurve::P256, false)
        .await
        .expect("Failed to import public key");

    let test_data = b"Hello, World!";

    let signature = ECDSA::sign(&signing_key, test_data, Some(SHAFamily::SHA256))
        .await
        .expect("Failed to sign data");

    let is_valid = ECDSA::verify(
        &verifying_key,
        &signature,
        test_data,
        Some(SHAFamily::SHA256),
    )
    .await
    .expect("Failed to verify signature");

    assert!(is_valid);
}

#[tokio::test]
async fn test_key_export() {
    let (private_key, public_key) = ECDSA::generate_key_pair(None)
        .await
        .expect("Failed to generate key pair");

    let signing_key = ECDSA::import_private_key(&private_key, ECDSACurve::P256, false)
        .await
        .expect("Failed to import private key");

    let verifying_key = ECDSA::import_public_key(&public_key, ECDSACurve::P256, false)
        .await
        .expect("Failed to import public key");

    let exported_private = ECDSA::export_key_private(&signing_key, ExportKeyFormat::PKCS8)
        .await
        .expect("Failed to export private key");

    let exported_public = ECDSA::export_key_public(&verifying_key, ExportKeyFormat::SPKI)
        .await
        .expect("Failed to export public key");

    assert_eq!(exported_private, private_key);
    assert_eq!(exported_public, public_key);
}

#[tokio::test]
async fn test_invalid_signature() {
    let (private_key1, _) = ECDSA::generate_key_pair(None)
        .await
        .expect("Failed to generate first key pair");

    let (_, public_key2) = ECDSA::generate_key_pair(None)
        .await
        .expect("Failed to generate second key pair");

    let signing_key = ECDSA::import_private_key(&private_key1, ECDSACurve::P256, false)
        .await
        .expect("Failed to import private key");

    let wrong_verifying_key = ECDSA::import_public_key(&public_key2, ECDSACurve::P256, false)
        .await
        .expect("Failed to import wrong public key");

    let test_data = b"Hello, World!";

    let signature = ECDSA::sign(&signing_key, test_data, None)
        .await
        .expect("Failed to sign data");

    let is_valid = ECDSA::verify(&wrong_verifying_key, &signature, test_data, None)
        .await
        .expect("Failed to verify signature");

    assert!(!is_valid);
}