create-fluxstack 1.0.22 → 1.4.0

package/plugins/crypto-auth/client/components/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Exportações dos componentes do cliente
+ */
+
+export { LoginButton } from './LoginButton'
+export type { LoginButtonProps } from './LoginButton'
+
+export { AuthProvider, useAuth } from './AuthProvider'
+export type { AuthProviderProps, AuthContextValue } from './AuthProvider'
+
+export { ProtectedRoute, withAuth } from './ProtectedRoute'
+export type { ProtectedRouteProps } from './ProtectedRoute'
+
+export { SessionInfo } from './SessionInfo'
+export type { SessionInfoProps } from './SessionInfo'

package/plugins/crypto-auth/client/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Exportações principais do cliente de autenticação
+ */
+
+export { CryptoAuthClient } from './CryptoAuthClient'
+export type { SessionInfo, AuthConfig, SignedRequestOptions } from './CryptoAuthClient'
+
+// Componentes React
+export * from './components'
+
+// Re-exportar para compatibilidade
+export { CryptoAuthClient as default } from './CryptoAuthClient'

package/plugins/crypto-auth/index.ts

@@ -0,0 +1,230 @@
+/**
+ * FluxStack Crypto Auth Plugin
+ * Sistema de autenticação baseado em criptografia Ed25519
+ */
+
+import type { FluxStack, PluginContext, RequestContext, ResponseContext } from "../../core/plugins/types"
+
+type Plugin = FluxStack.Plugin
+import { CryptoAuthService, AuthMiddleware } from "./server"
+
+export const cryptoAuthPlugin: Plugin = {
+  name: "crypto-auth",
+  version: "1.0.0",
+  description: "Sistema de autenticação baseado em criptografia Ed25519 para FluxStack",
+  author: "FluxStack Team",
+  priority: 100, // Alta prioridade para autenticação
+  category: "auth",
+  tags: ["authentication", "ed25519", "cryptography", "security"],
+  dependencies: [],
+  
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        description: "Habilitar autenticação criptográfica"
+      },
+      sessionTimeout: {
+        type: "number",
+        minimum: 300000, // 5 minutos mínimo
+        description: "Timeout da sessão em millisegundos"
+      },
+      maxTimeDrift: {
+        type: "number",
+        minimum: 30000,
+        description: "Máximo drift de tempo permitido em millisegundos"
+      },
+      adminKeys: {
+        type: "array",
+        items: { type: "string" },
+        description: "Chaves públicas dos administradores"
+      },
+      protectedRoutes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Rotas que requerem autenticação"
+      },
+      publicRoutes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Rotas públicas (não requerem autenticação)"
+      },
+      enableMetrics: {
+        type: "boolean",
+        description: "Habilitar métricas de autenticação"
+      }
+    },
+    additionalProperties: false
+  },
+  
+  defaultConfig: {
+    enabled: true,
+    sessionTimeout: 1800000, // 30 minutos
+    maxTimeDrift: 300000, // 5 minutos
+    adminKeys: [],
+    protectedRoutes: ["/api/admin/*", "/api/protected/*"],
+    publicRoutes: ["/api/auth/*", "/api/health", "/api/docs"],
+    enableMetrics: true
+  },
+
+  setup: async (context: PluginContext) => {
+    const config = getPluginConfig(context)
+    
+    if (!config.enabled) {
+      context.logger.info('Crypto Auth plugin desabilitado por configuração')
+      return
+    }
+
+    // Inicializar serviço de autenticação
+    const authService = new CryptoAuthService({
+      sessionTimeout: config.sessionTimeout,
+      maxTimeDrift: config.maxTimeDrift,
+      adminKeys: config.adminKeys,
+      logger: context.logger
+    })
+
+    // Inicializar middleware de autenticação
+    const authMiddleware = new AuthMiddleware(authService, {
+      protectedRoutes: config.protectedRoutes,
+      publicRoutes: config.publicRoutes,
+      logger: context.logger
+    })
+
+    // Armazenar instâncias no contexto para uso posterior
+    ;(context as any).authService = authService
+    ;(context as any).authMiddleware = authMiddleware
+
+    // Registrar rotas de autenticação
+    context.app.group("/api/auth", (app: any) => {
+      // Rota para inicializar sessão
+      app.post("/session/init", async ({ body, set }: any) => {
+        try {
+          const result = await authService.initializeSession(body)
+          return result
+        } catch (error) {
+          context.logger.error("Erro ao inicializar sessão", { error })
+          set.status = 500
+          return { success: false, error: "Erro interno do servidor" }
+        }
+      })
+
+      // Rota para validar sessão
+      app.post("/session/validate", async ({ body, set }: any) => {
+        try {
+          const result = await authService.validateSession(body)
+          return result
+        } catch (error) {
+          context.logger.error("Erro ao validar sessão", { error })
+          set.status = 500
+          return { success: false, error: "Erro interno do servidor" }
+        }
+      })
+
+      // Rota para obter informações da sessão
+      app.get("/session/info", async ({ headers, set }: any) => {
+        try {
+          const sessionId = headers['x-session-id']
+          if (!sessionId) {
+            set.status = 401
+            return { success: false, error: "Session ID não fornecido" }
+          }
+
+          const sessionInfo = await authService.getSessionInfo(sessionId)
+          return { success: true, session: sessionInfo }
+        } catch (error) {
+          context.logger.error("Erro ao obter informações da sessão", { error })
+          set.status = 500
+          return { success: false, error: "Erro interno do servidor" }
+        }
+      })
+
+      // Rota para logout
+      app.post("/session/logout", async ({ headers, set }: any) => {
+        try {
+          const sessionId = headers['x-session-id']
+          if (!sessionId) {
+            set.status = 401
+            return { success: false, error: "Session ID não fornecido" }
+          }
+
+          await authService.destroySession(sessionId)
+          return { success: true, message: "Sessão encerrada com sucesso" }
+        } catch (error) {
+          context.logger.error("Erro ao encerrar sessão", { error })
+          set.status = 500
+          return { success: false, error: "Erro interno do servidor" }
+        }
+      })
+    })
+
+    context.logger.info("Crypto Auth plugin inicializado com sucesso", {
+      sessionTimeout: config.sessionTimeout,
+      adminKeys: config.adminKeys.length,
+      protectedRoutes: config.protectedRoutes.length
+    })
+  },
+
+  onRequest: async (context: RequestContext) => {
+    const pluginContext = (context as any).pluginContext
+    if (!pluginContext?.authMiddleware) return
+
+    // Aplicar middleware de autenticação
+    const authResult = await pluginContext.authMiddleware.authenticate(context)
+    
+    if (!authResult.success && authResult.required) {
+      // Marcar como handled para evitar processamento adicional
+      ;(context as any).handled = true
+      ;(context as any).authError = authResult.error
+    } else if (authResult.success && authResult.user) {
+      // Adicionar usuário ao contexto
+      ;(context as any).user = authResult.user
+    }
+  },
+
+  onResponse: async (context: ResponseContext) => {
+    const config = getPluginConfig((context as any).pluginContext)
+    
+    if (config.enableMetrics) {
+      // Log métricas de autenticação
+      const user = (context as any).user
+      const authError = (context as any).authError
+      
+      if (user) {
+        ;((context as any).pluginContext?.logger || console).debug("Requisição autenticada", {
+          sessionId: user.sessionId,
+          isAdmin: user.isAdmin,
+          path: context.path,
+          method: context.method,
+          duration: context.duration
+        })
+      } else if (authError) {
+        ;((context as any).pluginContext?.logger || console).warn("Falha na autenticação", {
+          error: authError,
+          path: context.path,
+          method: context.method
+        })
+      }
+    }
+  },
+
+  onServerStart: async (context: PluginContext) => {
+    const config = getPluginConfig(context)
+    
+    if (config.enabled) {
+      context.logger.info("Crypto Auth plugin ativo", {
+        protectedRoutes: config.protectedRoutes.length,
+        publicRoutes: config.publicRoutes.length,
+        adminKeys: config.adminKeys.length
+      })
+    }
+  }
+}
+
+// Helper function para obter configuração do plugin
+function getPluginConfig(context: PluginContext) {
+  const pluginConfig = context.config.plugins.config?.['crypto-auth'] || {}
+  return { ...cryptoAuthPlugin.defaultConfig, ...pluginConfig }
+}
+
+export default cryptoAuthPlugin

package/plugins/crypto-auth/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@fluxstack/crypto-auth-plugin",
+  "version": "1.0.0",
+  "description": "Plugin de autenticação criptográfica Ed25519 para FluxStack",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./client": {
+      "import": "./client/index.ts",
+      "types": "./client/index.ts"
+    },
+    "./server": {
+      "import": "./server/index.ts",
+      "types": "./server/index.ts"
+    }
+  },
+  "keywords": [
+    "fluxstack",
+    "plugin",
+    "authentication",
+    "ed25519",
+    "cryptography",
+    "security",
+    "react",
+    "typescript"
+  ],
+  "author": "FluxStack Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@noble/curves": "^1.2.0",
+    "@noble/hashes": "^1.3.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "fluxstack": {
+    "version": "^1.0.0",
+    "hooks": [
+      "setup",
+      "onServerStart",
+      "onRequest",
+      "onResponse"
+    ],
+    "category": "auth",
+    "tags": [
+      "authentication",
+      "ed25519",
+      "cryptography",
+      "security"
+    ]
+  }
+}

package/plugins/crypto-auth/plugin.json

@@ -0,0 +1,29 @@
+{
+  "name": "crypto-auth",
+  "version": "1.0.0",
+  "description": "Sistema de autenticação baseado em criptografia Ed25519 para FluxStack",
+  "author": "FluxStack Team",
+  "license": "MIT",
+  "main": "index.ts",
+  "keywords": ["fluxstack", "plugin", "authentication", "ed25519", "cryptography"],
+  "fluxstack": {
+    "plugin": true,
+    "version": "^1.0.0",
+    "category": "auth",
+    "tags": ["authentication", "ed25519", "cryptography", "security"]
+  },
+  "dependencies": {
+    "@noble/curves": "^1.2.0",
+    "@noble/hashes": "^1.3.2",
+    "react": ">=16.8.0"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "files": [
+    "index.ts",
+    "server/",
+    "client/",
+    "README.md"
+  ]
+}

package/plugins/crypto-auth/server/AuthMiddleware.ts

@@ -0,0 +1,237 @@
+/**
+ * Middleware de Autenticação
+ * Intercepta requisições e valida autenticação
+ */
+
+import type { RequestContext } from '../../../core/plugins/types'
+import type { CryptoAuthService } from './CryptoAuthService'
+
+export interface Logger {
+    debug(message: string, meta?: any): void
+    info(message: string, meta?: any): void
+    warn(message: string, meta?: any): void
+    error(message: string, meta?: any): void
+}
+
+export interface AuthMiddlewareConfig {
+    protectedRoutes: string[]
+    publicRoutes: string[]
+    logger?: Logger
+}
+
+export interface AuthMiddlewareResult {
+    success: boolean
+    required: boolean
+    error?: string
+    user?: {
+        sessionId: string
+        isAdmin: boolean
+        isSuperAdmin: boolean
+        permissions: string[]
+    }
+}
+
+export class AuthMiddleware {
+    private authService: CryptoAuthService
+    private config: AuthMiddlewareConfig
+    private logger?: Logger
+
+    constructor(authService: CryptoAuthService, config: AuthMiddlewareConfig) {
+        this.authService = authService
+        this.config = config
+        this.logger = config.logger
+    }
+
+    /**
+     * Autenticar requisição
+     */
+    async authenticate(context: RequestContext): Promise<AuthMiddlewareResult> {
+        const path = context.path
+        const method = context.method
+
+        // Verificar se a rota é pública
+        if (this.isPublicRoute(path)) {
+            return {
+                success: true,
+                required: false
+            }
+        }
+
+        // Verificar se a rota requer autenticação
+        if (!this.isProtectedRoute(path)) {
+            return {
+                success: true,
+                required: false
+            }
+        }
+
+        // Extrair headers de autenticação
+        const authHeaders = this.extractAuthHeaders(context.headers)
+        if (!authHeaders) {
+            this.logger?.warn("Headers de autenticação ausentes", {
+                path,
+                method,
+                headers: Object.keys(context.headers)
+            })
+
+            return {
+                success: false,
+                required: true,
+                error: "Headers de autenticação obrigatórios"
+            }
+        }
+
+        // Validar sessão
+        try {
+            const validationResult = await this.authService.validateSession({
+                sessionId: authHeaders.sessionId,
+                timestamp: authHeaders.timestamp,
+                nonce: authHeaders.nonce,
+                signature: authHeaders.signature,
+                message: this.buildMessage(context)
+            })
+
+            if (!validationResult.success) {
+                this.logger?.warn("Falha na validação da sessão", {
+                    path,
+                    method,
+                    sessionId: authHeaders.sessionId.substring(0, 8) + "...",
+                    error: validationResult.error
+                })
+
+                return {
+                    success: false,
+                    required: true,
+                    error: validationResult.error
+                }
+            }
+
+            this.logger?.debug("Requisição autenticada com sucesso", {
+                path,
+                method,
+                sessionId: authHeaders.sessionId.substring(0, 8) + "...",
+                isAdmin: validationResult.user?.isAdmin
+            })
+
+            return {
+                success: true,
+                required: true,
+                user: validationResult.user
+            }
+        } catch (error) {
+            this.logger?.error("Erro durante autenticação", {
+                path,
+                method,
+                error
+            })
+
+            return {
+                success: false,
+                required: true,
+                error: "Erro interno de autenticação"
+            }
+        }
+    }
+
+    /**
+     * Verificar se a rota é pública
+     */
+    private isPublicRoute(path: string): boolean {
+        return this.config.publicRoutes.some(route => {
+            if (route.endsWith('/*')) {
+                const prefix = route.slice(0, -2)
+                return path.startsWith(prefix)
+            }
+            return path === route
+        })
+    }
+
+    /**
+     * Verificar se a rota é protegida
+     */
+    private isProtectedRoute(path: string): boolean {
+        return this.config.protectedRoutes.some(route => {
+            if (route.endsWith('/*')) {
+                const prefix = route.slice(0, -2)
+                return path.startsWith(prefix)
+            }
+            return path === route
+        })
+    }
+
+    /**
+     * Extrair headers de autenticação
+     */
+    private extractAuthHeaders(headers: Record<string, string>): {
+        sessionId: string
+        timestamp: number
+        nonce: string
+        signature: string
+    } | null {
+        const sessionId = headers['x-session-id']
+        const timestampStr = headers['x-timestamp']
+        const nonce = headers['x-nonce']
+        const signature = headers['x-signature']
+
+        if (!sessionId || !timestampStr || !nonce || !signature) {
+            return null
+        }
+
+        const timestamp = parseInt(timestampStr, 10)
+        if (isNaN(timestamp)) {
+            return null
+        }
+
+        return {
+            sessionId,
+            timestamp,
+            nonce,
+            signature
+        }
+    }
+
+    /**
+     * Construir mensagem para assinatura
+     */
+    private buildMessage(context: RequestContext): string {
+        // Incluir método, path e body (se houver) na mensagem
+        let message = `${context.method}:${context.path}`
+
+        if (context.body && typeof context.body === 'string') {
+            message += `:${context.body}`
+        } else if (context.body && typeof context.body === 'object') {
+            message += `:${JSON.stringify(context.body)}`
+        }
+
+        return message
+    }
+
+    /**
+     * Verificar se usuário tem permissão para acessar rota
+     */
+    hasPermission(user: any, requiredPermission: string): boolean {
+        if (!user || !user.permissions) {
+            return false
+        }
+
+        return user.permissions.includes(requiredPermission) || user.permissions.includes('admin')
+    }
+
+    /**
+     * Verificar se usuário é admin
+     */
+    isAdmin(user: any): boolean {
+        return user && user.isAdmin === true
+    }
+
+    /**
+     * Obter estatísticas do middleware
+     */
+    getStats() {
+        return {
+            protectedRoutes: this.config.protectedRoutes.length,
+            publicRoutes: this.config.publicRoutes.length,
+            authService: this.authService.getStats()
+        }
+    }
+}