volter 0.0.178 → 0.0.180

package/src/crypto.ts

@@ -0,0 +1,157 @@
+export function hash(password: string, hmac?: string): string {
+	const hasher = new Bun.CryptoHasher("sha256", hmac)
+	return hasher.update(password).digest("hex")
+}
+export async function hash_async(password: string): Promise<string> {
+    const encoded = new TextEncoder().encode(password)
+    const hashBuffer = await crypto.subtle.digest("SHA-256", encoded)
+    const hashArray = Array.from(new Uint8Array(hashBuffer))
+    return hashArray.map(b => b.toString(16).padStart(2, "0")).join("")
+}
+
+export interface CipherText {
+	text: string
+	iv: Uint8Array<ArrayBuffer>
+	buffer: ArrayBuffer
+}
+
+export async function cryptoKey(raw?: CryptoKey | Uint8Array<ArrayBuffer> | string): Promise<CryptoKey> {
+	if (raw) {
+		if (raw instanceof CryptoKey) return raw
+		if (raw instanceof Uint8Array) {
+			if (raw.length === 32) {
+				return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
+			}
+			return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"])
+		}
+		if (raw.length === 64) {
+			return await crypto.subtle.importKey(
+				"raw",
+				Uint8Array.fromHex(raw),
+				{
+					name: "AES-GCM",
+					length: 256,
+				},
+				true,
+				["encrypt", "decrypt"],
+			)
+		} else {
+			return await crypto.subtle.importKey(
+				"raw",
+				Uint8Array.fromHex(hash(raw)),
+				{
+					name: "AES-GCM",
+					length: 256,
+				},
+				true,
+				["encrypt", "decrypt"],
+			)
+		}
+	} else {
+		return await crypto.subtle.generateKey(
+			{
+				name: "AES-GCM",
+				length: 256,
+			},
+			true,
+			["encrypt", "decrypt"],
+		)
+	}
+}
+export async function exportKey(key: CryptoKey, format: "raw" | "pkcs8" | "spki") {
+	const buffer = await crypto.subtle.exportKey(format, key)
+	return new Uint8Array(buffer).toBase64()
+}
+
+export async function generateECDSAKeyPair(): Promise<CryptoKeyPair> {
+	return await crypto.subtle.generateKey(
+		{
+			name: "ECDSA",
+			namedCurve: "P-256", // SECG curve
+		},
+		true,
+		["sign", "verify"],
+	)
+}
+
+export async function exportJWK(key: CryptoKey): Promise<JsonWebKey> {
+	return await crypto.subtle.exportKey("jwk", key)
+}
+
+export async function importJWK(jwk: JsonWebKey, usage: KeyUsage[]): Promise<CryptoKey> {
+	return await crypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, true, usage)
+}
+
+export async function sign(message: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>> {
+	const data = new TextEncoder().encode(message)
+
+	const signature = await crypto.subtle.sign(
+		{
+			name: "ECDSA",
+			hash: { name: "SHA-256" },
+		},
+		key,
+		data,
+	)
+
+	return new Uint8Array(signature)
+}
+export async function verifySign(message: string, signature: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<boolean> {
+	const data = new TextEncoder().encode(message)
+
+	return await crypto.subtle.verify(
+		{
+			name: "ECDSA",
+			hash: { name: "SHA-256" },
+		},
+		key,
+		signature,
+		data,
+	)
+}
+
+export async function cipher(text: string, key: CryptoKey | string): Promise<CipherText> {
+	const encoder = new TextEncoder()
+
+	const data = encoder.encode(text)
+	const iv = crypto.getRandomValues(new Uint8Array(12))
+	const buffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv }, await cryptoKey(key), data)
+
+	return {
+		text: new Uint8Array(buffer).toHex(),
+		iv: iv,
+		buffer: buffer,
+	}
+}
+export async function decipher(cipher: CipherText, key: CryptoKey | string) {
+	const decoder = new TextDecoder()
+
+	const buffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv: cipher.iv }, await cryptoKey(key), Uint8Array.fromHex(cipher.text))
+
+	const data = decoder.decode(buffer)
+
+	return data
+}
+
+export async function keypair(): Promise<CryptoKeyPair> {
+	return await crypto.subtle.generateKey(
+		{
+			name: "RSA-OAEP",
+			modulusLength: 2048,
+			publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
+			hash: { name: "SHA-256" },
+		},
+		true,
+		["encrypt", "decrypt"],
+	)
+}
+export async function encrypt(text: string, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>> {
+	const data = new TextEncoder().encode(text)
+	const buffer = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, key, data)
+	return new Uint8Array(buffer)
+}
+export async function decrypt(text: Uint8Array<ArrayBuffer>, key: CryptoKey): Promise<string> {
+	const buffer = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, key, text)
+	const data = new TextDecoder().decode(buffer)
+	return data
+}

package/src/error.ts

@@ -0,0 +1,51 @@
+export enum ErrorCodes {
+	// Server
+	INTERNAL_SERVER_ERROR,
+	SERVICE_UNAVAILABLE,
+
+	// Client
+	VALIDATION_FAILED,
+	TOO_MANY_REQUESTS,
+
+	// Resource
+	ALREADY_EXISTS,
+	RESOURCE_NOT_FOUND,
+
+	// A&A
+	AUTHORIZATION_REQUIRED,
+	AUTHENTICATION_FAILED,
+	INVALID_CREDENTIALS,
+	INVALID_TOKEN,
+	EXPIRED_TOKEN,
+}
+
+export interface ServerErrorOptions {
+	cause?: unknown
+	path?: string[]
+	code?: ErrorCodes
+}
+export class ServerError extends Error {
+	constructor(message: string, options?: ServerErrorOptions) {
+		super(message, {
+			cause: options?.cause,
+		})
+		this.message = message
+		this.cause = options?.cause
+		this.path = options?.path
+		this.code = options?.code ?? ErrorCodes.INTERNAL_SERVER_ERROR
+		this.occurred = new Date()
+	}
+    name = "ServerError"
+	message: string
+    cause?: unknown
+	path?: string[]
+	code: ErrorCodes
+	occurred: Date
+}
+
+export class UniqueError extends ServerError {
+    name = "UniqueError"
+	code: ErrorCodes = ErrorCodes.ALREADY_EXISTS
+}
+
+export { ZodError as ValidationError } from "zod"

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./utils"
+export * from "./error"
+export * from "./crypto"
+export * from "./sessions"

package/src/main.c

@@ -0,0 +1 @@
+#include "stdio.h"

package/src/main.rs

@@ -0,0 +1,172 @@
+mod utils;
+
+use crate::utils::{DateTimeExt, Socket, SocketAddrEnv};
+use chrono::Utc;
+use colored::Colorize;
+use std::{
+    net::SocketAddr,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt, copy_bidirectional},
+    net::{TcpListener, TcpStream, UdpSocket, windows::named_pipe::ClientOptions},
+    spawn,
+};
+
+#[allow(dead_code)]
+async fn process_tcp(mut stream: TcpStream) -> tokio::io::Result<()> {
+    // info!("{}", StreamEvent::new(StreamEventLevel::Open, addr));
+    let mut client = TcpStream::connect("127.0.0.1:843").await?;
+    copy_bidirectional(&mut stream, &mut client).await?;
+    // info!("{}", StreamEvent::new(StreamEventLevel::Close, addr));
+    Ok(())
+}
+
+#[allow(dead_code)]
+async fn process_udp(mut stream: TcpStream, target: &String) -> tokio::io::Result<()> {
+    stream.set_nodelay(true)?;
+    let datagram = UdpSocket::bind("0.0.0.0:0").await?;
+    datagram.connect(target).await?;
+
+    let mut buf = [0u8; 8192];
+
+    let n = stream.read(&mut buf).await?;
+    datagram.send(&buf[..n]).await?;
+
+    let n = datagram.recv(&mut buf).await?;
+    stream.write_all(&buf[..n]).await?;
+    Ok(())
+}
+
+async fn process_raw(mut stream: TcpStream) -> tokio::io::Result<()> {
+    stream.set_nodelay(true)?;
+    stream
+        .write_all("HTTP/1.1 200 OK\r\n\r\nHello, world!".as_bytes())
+        .await?;
+    stream.shutdown().await?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+async fn process_pipe(mut stream: TcpStream) -> tokio::io::Result<()> {
+    stream.set_nodelay(true)?;
+    // info!("{}", StreamEvent::new(StreamEventLevel::Open, addr));
+    let mut pipe = ClientOptions::new().open("//./pipe/socket")?;
+    copy_bidirectional(&mut stream, &mut pipe).await?;
+
+    /*
+    let mut buf = [0; 1024];
+
+    let n = stream.read(&mut buf).await?;
+    pipe.write_all(&buf[..n]).await?;
+    // info!("{}", StreamEvent::new(StreamEventLevel::Data, addr));
+
+    let n = pipe.read(&mut buf).await?;
+    stream.write_all(&buf[..n]).await?;
+    */
+
+    // info!("{}", StreamEvent::new(StreamEventLevel::Close, addr));
+    Ok(())
+}
+
+#[allow(dead_code)]
+async fn process_udp_select(mut stream: TcpStream) -> tokio::io::Result<()> {
+    let datagram = UdpSocket::bind("0.0.0.0:0").await?;
+    datagram.connect("127.0.0.1:843").await?;
+
+    let mut req = [0u8; 8192];
+    let mut res = [0u8; 8192];
+
+    tokio::select! {
+        // TCP -> UDP (Request)
+        n = stream.read(&mut req) => {
+            let n = n?;
+            if n == 0 { () }
+            datagram.send(&req[..n]).await?;
+        }
+
+        // UDP -> TCP (Response)
+        n = datagram.recv(&mut res) => {
+            let n = n?;
+            // Note: UDP 0-byte packets are valid, so we just check for errors
+            stream.write_all(&res[..n]).await?;
+        }
+    }
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let address = SocketAddr::env();
+    let listener = TcpListener::bind(address).await?;
+    info!("Listening to {}...", address);
+
+    let targets = vec!["127.0.0.1:3001".to_string(), "127.0.0.1:3002".to_string()];
+    let targets = Arc::new(targets);
+    let current_index = Arc::new(AtomicUsize::new(0));
+
+    let connection = Socket::RDMA;
+
+    match connection {
+        Socket::TCP => loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    spawn(async move {
+                        if let Err(e) = process_tcp(stream).await {
+                            error!("{:?}", e)
+                        }
+                    });
+                }
+                Err(e) => error!("{:?}", e),
+            }
+        },
+        Socket::UDP => loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    let targets = Arc::clone(&targets);
+                    let index_ptr = Arc::clone(&current_index);
+                    spawn(async move {
+                        let idx = index_ptr.fetch_add(1, Ordering::Relaxed) % targets.len();
+                        if let Err(e) = process_udp(stream, &targets[idx]).await {
+                            error!("{:?}", e)
+                        }
+                    });
+                }
+                Err(e) => error!("{:?}", e),
+            }
+        },
+        Socket::UDS => loop {
+            match listener.accept().await {
+                Ok((_stream, _addr)) => {}
+                Err(e) => error!("{:?}", e),
+            }
+        },
+        Socket::PIPE => loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    spawn(async move {
+                        if let Err(e) = process_pipe(stream).await {
+                            error!("{:?}", e)
+                        }
+                    });
+                }
+                Err(e) => error!("{:?}", e),
+            }
+        },
+        Socket::RDMA => loop {
+            match listener.accept().await {
+                Ok((stream, _addr)) => {
+                    spawn(async move {
+                        if let Err(e) = process_raw(stream).await {
+                            error!("{:?}", e)
+                        }
+                    });
+                }
+                Err(e) => error!("{:?}", e),
+            }
+        },
+    }
+}

package/src/network.ts

@@ -0,0 +1,53 @@
+import type { ServerError } from "./error"
+
+export interface APIResponse {
+	data?: unknown
+	error?: ServerError[]
+	success?: boolean
+}
+
+export type ID = number
+
+export enum Method {
+	GET,
+	POST,
+	PUT,
+	DELETE,
+	PATCH,
+	HEAD,
+	OPTIONS,
+}
+
+export enum Event {
+    MESSAGE,
+    OPEN,
+    CLOSE,
+    DRAIN,
+}
+
+export interface LogHTTP {
+	id: ID
+	method: Method // what?
+	url: URL // where?
+	status: number // why?
+	ip: string // who?
+	user_agent?: string
+    size: number // how?
+	created: Date // when?
+}
+
+export interface LogWS {
+	id: ID
+	event: Event // what?
+	url: URL // where?
+	ip: string // who?
+	user_agent?: string
+    size: number // how?
+	created: Date // when?
+}
+
+export interface SocketConnection {
+	id: ID
+	ip: string
+	created: Date
+}