Results for “websocket”

Tests WebSocket API implementations for security vulnerabilities including missing authentication on WebSocket upgrade, Cross-Site WebSocket Hijacking (CSWSH), injection attacks through WebSocket messages, insufficient input validation, denial-of-service via message flooding, and information leakage through WebSocket frames. The tester intercepts WebSocket handshakes and messages using Burp Suite, crafts malicious payloads, and tests for authorization bypass on WebSocket channels. Activates f...

The English summary is being prepared. Showing the original description.

Build a persistent connection that receives Zoom events, such as meeting starts and participant arrivals. This reference covers choosing WebSockets, a connection kept open for events, plus authentication, connection maintenance, and reconnection.

• Receive meeting start and end events
• Track participant arrivals and departures
• Receive events without a public endpoint

Build and debug LangBot plugins that handle messages, commands, and AI tool calls. The skill covers SDK usage, common errors, test environment setup, WebSocket message testing, and preparation for publishing to LangBot Space.

• Create a plugin that reacts to incoming messages
• Fix plugin SDK errors and missing responses
• Test group and private chats through WebSocket

Guides Kotlin HTTP server development with Ktor through examples for API routes, authentication, JSON conversion, and WebSockets. Shows how to organize application components with Koin and verify routes and authentication using integration tests.

• Building REST API routes with Ktor
• Protecting routes with JWT authentication
• Organizing application components with Koin

Integrate cryptocurrency exchanges into Go applications with CCXT. Follow examples for market data, order management, authentication, and error handling, using REST for individual requests and WebSocket streams to monitor prices, order books, balances, and orders.

• Fetch exchange market data in a Go application
• Implement order placement and cancellation
• Monitor live prices and order books

Build cryptocurrency exchange integrations in Rust with CCXT. Follow examples for fetching prices and order books, placing orders, streaming live updates through WebSocket connections, and handling authentication and errors with typed results.

• Fetching exchange prices and order books in Rust
• Building order placement and cancellation workflows
• Streaming live prices through WebSocket connections

Analyze WebSocket and SSE realtime connections in CTF sandboxes. Trace connection setup, authentication, subscriptions, and message sequences to explain changes in displayed or stored state and identify the smallest sequence that reproduces them.

• Inspecting connection setup and authentication data
• Decoding realtime messages and subscription flow
• Tracing reconnect behavior and message order

Build Python APIs with FastAPI and Pydantic V2, including input validation, database operations that avoid blocking other work, and token-based authentication. Implement REST or WebSocket endpoints, then check their behavior with automated tests and generated API documentation.

• Build REST APIs with FastAPI
• Validate input data with Pydantic V2
• Implement JWT authentication and authorization

Build real-time messaging with WebSocket or Socket.IO, including authentication, chat rooms, online status, and reconnection. Provides server and client code, plus guidance on using Redis to share messages across multiple servers and monitor connections.

• Building chat and live-update features
• Managing rooms and online user status
• Handling reconnection and queued messages

Build cryptocurrency exchange integrations in Java with CCXT. Get guidance on installation, market data, orders, authentication, and error handling, using REST for individual requests and WebSocket connections for live price and order book updates.

• Add exchange price data to a Java application
• Implement order placement and cancellation
• Monitor live prices and order books

Integrate cryptocurrency exchanges into PHP applications with CCXT. Follow examples for market data, orders, authentication, and errors, with synchronous requests, ReactPHP asynchronous processing that avoids waiting on each request, and WebSocket connections for live updates.

• Displaying cryptocurrency prices in a PHP web application
• Implementing order placement and cancellation in a trading bot
• Fetching market data asynchronously with ReactPHP

Build cryptocurrency exchange integrations in C# and .NET with CCXT. Get guidance on setup, market data, orders, authentication, and error handling, using REST for individual requests and WebSocket connections for live price and order book updates.

• Adding cryptocurrency prices to a C# application
• Implementing order placement and cancellation
• Monitoring live prices and order books

Build Python integrations with crypto exchanges using CCXT. Get guidance on fetching prices and order books, placing orders, checking balances, and receiving live updates, with examples for authentication, error handling, and synchronous or asynchronous code.

• Fetch exchange data for analysis
• Implement order placement in a trading bot
• Monitor live prices and order books

Build cryptocurrency exchange integrations in TypeScript or JavaScript with CCXT. Get examples for fetching prices, placing orders, checking balances, and receiving live updates, alongside guidance on authentication, supported methods, and error handling.

• Build a cryptocurrency trading bot
• Monitor live prices and order books
• Track portfolio balances

Trace how requests travel through a CTF sandbox, from hostnames and proxy rules to containers and processes. Compare headers and live traffic to identify which service handles a request and what changes its destination.

• Identify which container handles a request
• Check how Host and forwarded headers affect routing
• Trace path rewrites and WebSocket routing

Configure WebSocket connections for iii workers, including authentication and role-based access control. Define which functions workers may call or register, add invocation auditing, and isolate tenant namespaces through listener settings and authentication results.

• Configuring authenticated worker connections from external networks
• Restricting function calls and dynamic registrations
• Adding audit logs or rate limits to function calls

Build Java applications that exchange live audio with AI assistants using Azure AI VoiceLive. The skill covers authentication, streaming sessions, speech detection, voice selection, transcription, and handling responses over WebSocket, a persistent two-way connection.

• Implementing a real-time voice assistant in Java
• Configuring speech detection and interruptions
• Adding transcription and noise reduction

Build Python applications that keep other tasks moving while waiting for network, database, or file operations. Guides the choice of asyncio patterns, with timeouts, cancellation, error handling, and testing for asynchronous code.

• Build an asynchronous web API
• Fetch multiple web pages concurrently
• Develop a WebSocket server or chat system

Add a new exchange integration to CCXT using TypeScript and established exchange templates. Follow guidance for unified methods, data conversion, authentication, sandbox settings, recorded API test data, documentation, and checks across generated language implementations.

• Add an exchange that CCXT does not yet support
• Convert exchange responses into CCXT's common data format
• Record real API responses for regression tests

Assess authorized APIs through a ten-stage workflow covering endpoint discovery, authentication, access permissions, input handling, and request limits. Collect reproducible evidence and turn findings into regression checks that can run in a development pipeline.

• Review API authentication and access permissions
• Assess GraphQL and WebSocket security
• Check request limits and unintended data exposure

Build Python applications that handle other work while waiting for network or database operations. Use asyncio and async/await to run tasks concurrently, manage errors and timeouts, and handle cancellation with appropriate cleanup.

• Building web APIs that handle many simultaneous requests
• Fetching data from multiple sources concurrently
• Implementing WebSocket servers and chat systems

Build applications that use Polymarket market data and trading APIs. The skill guides live monitoring through WebSocket connections, which receive ongoing updates, including trades, orders, market comments, and cryptocurrency prices.

• Build an app that retrieves prediction market data
• Monitor live trades and price changes
• Track market comments and reactions

Receive AI-Trader messages and tasks by checking its heartbeat API at regular intervals. Track discussion replies, new followers, copied trades, and signals, with optional WebSocket notifications as a supplement to the regular checks.

• Check regularly for new messages and tasks
• Find new replies to discussions and strategies
• Receive follower and copied-trade notifications

Design GraphQL APIs with clear data types, data-fetching functions called resolvers, and real-time updates. Address repeated database calls, pagination, structured errors, and expensive queries while planning schema changes that preserve compatibility.

• Designing schemas around business concepts
• Reducing repeated database calls with DataLoader
• Planning real-time subscriptions over WebSocket