应用层后量子
安全传输让每一次连接可验证。

// npm install @piv9/stp-wasm

import { V9StpClient, initWasm } from '@piv9/stp-wasm';

// 1. 初始化 WASM 模块
await initWasm();

// 2. 创建客户端并激活授权
const client = new V9StpClient({
  licenseKey: 'YOUR-LICENSE-KEY',
  serverUrl:  'https://api.example.com',
  securityLevel: 4,  // L4TopSecret
});

// 3. 执行 V9-KEM 握手（自动 4 步）
await client.handshake();
console.log('V9 会话已建立, sessionId:', client.sessionId);

// 4. 发送加密请求（透明加密）
const response = await client.fetch('/api/data', {
  method: 'POST',
  body: JSON.stringify({ message: 'Hello V9-STP!' }),
});

// 5. 响应自动解密
const data = await response.json();
console.log('解密后的响应:', data);

// SDK 自动处理：
// - DEK 轮换（每 1000 条自动 rekey）
// - 会话过期自动重新握手
// - 序号管理和完整性校验
// - 内存中密钥自动擦除

# pip install piv9-stp

from piv9_stp import V9StpClient, SecurityLevel

# 1. 创建客户端并激活授权
client = V9StpClient(
    license_key="YOUR-LICENSE-KEY",
    server_url="https://api.example.com",
    security_level=SecurityLevel.L4_TOP_SECRET,
)

# 2. 执行握手
client.handshake()
print(f"V9 会话已建立: {client.session_id}")

# 3. 加密发送数据
response = client.post("/api/data", json={
    "message": "Hello V9-STP!",
    "amount":  10000.00,
})

# 4. 响应自动解密
data = response.json()
print("解密后的响应:", data)

# 5. 批量数据加密传输
with client.stream("/api/upload") as stream:
    for chunk in read_file_chunks("large_file.bin"):
        stream.send(chunk)  # 自动 V9 加密 + 分块

# SDK 自动处理 rekey / 会话管理 / 密钥擦除

// build.gradle.kts
// implementation("com.lonxang:piv9-stp-android:1.0.0")

import com.lonxang.piv9.stp.*

class SecureApiClient(context: Context) {

    private val client = V9StpClient.Builder(context)
        .licenseKey("YOUR-LICENSE-KEY")
        .serverUrl("https://api.example.com")
        .securityLevel(SecurityLevel.L4_TOP_SECRET)
        .build()

    suspend fun sendSecureMessage(message: String): ApiResponse {
        // 握手（首次自动执行，后续自动管理）
        client.ensureSession()

        // 发送加密请求
        val response = client.post("/api/data") {
            jsonBody(mapOf("message" to message))
        }

        // 自动解密响应
        return response.decode<ApiResponse>()
    }
}

// Activity 中使用
val api = SecureApiClient(applicationContext)
lifecycleScope.launch {
    val result = api.sendSecureMessage("Hello V9-STP!")
    Log.d("V9", "Response: ${result}")
}

// Swift Package Manager:
// .package(url: "https://github.com/lonxang/piv9-stp-ios", from: "1.0.0")

import PIV9STP

class SecureAPIManager {

    private let client: V9StpClient

    init() throws {
        client = try V9StpClient(
            licenseKey: "YOUR-LICENSE-KEY",
            serverURL: URL(string: "https://api.example.com")!,
            securityLevel: .l4TopSecret
        )
    }

    func sendSecureData(_ message: String) async throws -> APIResponse {
        // 自动握手 + 会话管理
        try await client.ensureSession()

        // 加密请求
        let response = try await client.post("/api/data", body: [
            "message": message,
        ])

        // 自动解密响应
        return try response.decode(APIResponse.self)
    }
}

// SwiftUI 中使用
let api = try SecureAPIManager()
let result = try await api.sendSecureData("Hello V9-STP!")
print("解密响应: \(result)")