steam-auth-rs

Steam authentication and session management for Rust.

This crate provides a complete implementation for authenticating with Steam, supporting multiple login methods including password-based authentication, QR code login, and session resumption via refresh tokens.

Overview

Installation

[dependencies]

steam-auth-rs = "0.1"

tokio = { version = "1", features = ["full"] }

The crate is imported as steam_auth in your code (the package name is steam-auth-rs because steam-auth is taken on crates.io).

Usage

Password Login

use steam_auth::{LoginSession, CredentialsDetails, EAuthTokenPlatformType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new login session
    let mut session = LoginSession::new(EAuthTokenPlatformType::SteamClient, None)?;
    
    // Start login with credentials
    let response = session.start_with_credentials(CredentialsDetails {
        account_name: "username".to_string(),
        password: "password".to_string(),
        steam_guard_code: None,
        steam_guard_machine_token: None,
    }).await?;
    
    // Check if Steam Guard is required
    if response.action_required {
        println!("Steam Guard code required!");
        // Get code from user...
        session.submit_steam_guard_code("ABC123").await?;
    }
    
    // Poll for completion
    let result = session.poll().await?;
    
    println!("Logged in! SteamID: {:?}", session.steam_id());
    println!("Refresh Token: {:?}", session.refresh_token());
    
    Ok(())
}

QR Code Login

use steam_auth::{LoginSession, EAuthTokenPlatformType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut session = LoginSession::new(EAuthTokenPlatformType::SteamClient, None)?;
    
    // Start QR login
    let response = session.start_with_qr().await?;
    
    println!("Scan this URL with Steam mobile app:");
    println!("{}", response.qr_challenge_url.unwrap());
    
    // Poll until user scans QR
    loop {
        match session.poll().await {
            Ok(result) => {
                println!("Login successful!");
                println!("Refresh Token: {:?}", session.refresh_token());
                break;
            }
            Err(e) => {
                // Check remote interaction
                if session.had_remote_interaction().await {
                    println!("QR scanned, waiting for approval...");
                }
                tokio::time::sleep(session.poll_interval()).await;
            }
        }
    }
    
    Ok(())
}

Resume Session with Refresh Token

use steam_auth::{LoginSession, EAuthTokenPlatformType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let refresh_token = "your_saved_refresh_token";
    
    // Create session from refresh token
    let mut session = LoginSession::from_refresh_token(
        EAuthTokenPlatformType::SteamClient,
        refresh_token,
        None,
    )?;
    
    // Refresh access token
    session.refresh_access_token().await?;
    
    println!("Access Token: {:?}", session.access_token());
    
    Ok(())
}

Get Web Cookies

use steam_auth::{LoginSession, EAuthTokenPlatformType};

async fn get_cookies(session: &mut LoginSession) -> Result<(), Box<dyn std::error::Error>> {
    // After successful authentication...
    let cookies = session.get_web_cookies().await?;
    
    for cookie in cookies {
        println!("Cookie: {}", cookie);
    }
    
    Ok(())
}

Approve QR Login (Mobile Simulation)

use steam_auth::{LoginApprover, ApproverOptions, ESessionPersistence};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let access_token = "your_access_token";
    let shared_secret = "your_authenticator_shared_secret";
    
    let approver = LoginApprover::new(
        access_token,
        shared_secret,
        ApproverOptions::default(),
    )?;
    
    // QR URL from another device
    let qr_url = "https://s.team/q/1/1234567890";
    
    // Get session info
    let info = approver.get_auth_session_info(qr_url).await?;
    println!("Login from: {} ({})", info.ip, info.city);
    
    // Approve the login
    approver.approve_auth_session(qr_url, true, ESessionPersistence::Persistent).await?;
    
    Ok(())
}

API Reference

Core Types

LoginSession Methods

Configuration Types

Response Types

Error Variants

Platform Types

Steam supports different authentication platforms:

Transport Layer

The crate supports two transport mechanisms:

Helper Functions

Dependencies

Source

This crate is a Rust port of node-steam-session.

License

MIT