Results for “kernel”

Iterative Python via live Jupyter kernel (hamelnb).

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

Integrates AI/LLM via Semantic Kernel. Plugins, prompt templates, memory stores, agents.

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

You are helping a penetration tester exploit Linux kernel vulnerabilities and escape

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

You are helping a penetration tester exploit kernel vulnerabilities, vulnerable drivers,

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

Low-level keylogger architecture design: kernel driver hooks (WH_KEYBOARD_LL, SetWindowsHookEx), ETW-based input capture, user-mode vs kernel-mode approaches, stealth techniques, and data exfiltration. Use for understanding input capture mechanisms, EDR evasion research, or malware architecture analysis.

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

Design a persistent multi-agent workflow in Claude Code, with specialist roles, reusable commands, file-based memory, and scheduled tasks. Keep project context and decisions across sessions using JSON and Markdown files without an external database.

• Coordinate specialist agents for development and writing
• Preserve project context across sessions
• Schedule recurring morning briefings

Explore data and develop Python code in a live Jupyter session that keeps variables between runs. Inspect objects, edit notebook cells, and optionally restart and run the whole notebook to check execution from top to bottom.

• Exploring data while keeping variables between runs
• Inspecting DataFrames and live Python objects
• Trying API usage and refining complex code

Restructure claude-flow v3 into focused modules using Domain-Driven Design, which groups code by responsibility. Define module boundaries, event communication, and plugin interfaces to support a modular architecture with independently testable business logic.

• Split an oversized orchestrator into focused modules
• Define boundaries between tasks, sessions, and monitoring
• Design plugin extensions and domain events

Restructure claude-flow v3 into focused modules using Domain-Driven Design, which groups code by responsibility. Define module boundaries, event communication, and plugin interfaces to support a modular architecture with independently testable business logic.

• Split an oversized orchestrator into focused modules
• Define boundaries between tasks, sessions, and monitoring
• Design plugin extensions and domain events

Automate forms, clicks, screenshots, and website checks in a browser where you are already signed in. A separately launched browser also supports scraping and network capture, while login or verification steps can be handed to a person.

• Fill forms on websites where you are already signed in
• Capture screenshots and check website behavior
• Record network traffic in a separately launched browser

Analyze CSV, Parquet, and JSON files to answer questions through grouping, joins, cleaning, time series, and charts. Chooses DuckDB or Polars and a suitable processing location based on the task and available memory.

• Summarizing and joining data files
• Exploring trends and distributions
• Cleaning data before analysis

Combine laboratory animal welfare measurements into reference-relative RELSA severity scores. Analyze individual trajectories, explore forecasts for specified observation times, and derive candidate score zones, with explicit checks on normalization, reference selection, prediction intervals, and evaluation limits.

• Combine animal welfare measurements into daily scores
• Compare group severity using a shared reference
• Explore severity forecasts at specified observation times

Optimize scientific Python workloads for NVIDIA GPUs by choosing suitable libraries and reducing bottlenecks. Compare outputs with the CPU version and measure complete processing time, including data transfers, to determine whether the GPU implementation provides a useful improvement.

• Assess whether slow Python processing would benefit from a GPU
• Move NumPy or pandas workloads to suitable GPU libraries
• Validate GPU results against CPU outputs

Analyze how EDR, software that monitors endpoint threats, and antivirus products detect activity. Support authorized exercises by examining monitoring mechanisms, assessing evasion approaches, and checking detection results in an isolated test environment.

• Assessing EDR detection coverage in authorized exercises
• Examining internal monitoring mechanisms
• Testing an in-house implant against security products

Transfer known function and variable names from an older binary to a newer version. Compare disassembly and pseudocode with an LLM, produce structured mappings, and apply names and comments in IDA.

• Migrate known function names after a software update
• Locate kernel functions when the new PDB is unavailable
• Find updated function addresses and structure offsets

Measure denoising latency in SGLang diffusion models and identify slow operations with profiler traces. Compare performance and output quality on the same GPUs, check existing optimizations, and gather evidence before starting low-level kernel work.

• Measuring diffusion denoising latency
• Ranking slow operations from profiler traces
• Checking whether existing optimizations address a bottleneck

Analyze LLM serving traces to identify GPU time usage, opportunities to run operations concurrently, and known patterns for combining operations. Produce three consistent tables from saved traces or live captures on supported servers.

• Identify GPU operations that dominate inference time
• Compare input processing and token generation
• Trace GPU operations back to Python code

Investigate attempts to gain higher privileges on Windows and Linux using endpoint and security logs. Guide hypothesis testing, evidence analysis, false-positive checks, and reporting to help assess suspicious privilege changes and the scope of a compromise.

• Hunting for signs of privilege escalation
• Investigating alerts about suspicious privilege changes
• Assessing compromise scope during incident response

Create and tune Falco rules to detect possible container escapes, where a container gains access to its host. Define detection conditions, alert priorities, and output fields, then refine exceptions to reduce false positives.

• Writing rules for suspicious host filesystem access
• Investigating noisy container escape alerts
• Reusing detection conditions through macros and lists

Investigate malware hidden in boot records, UEFI firmware, or the operating system’s core. The skill guides evidence collection, boot integrity checks, firmware and memory analysis, and reporting of persistence mechanisms and remediation steps when compromise survives an OS reinstall.

• Investigating infections that survive an OS reinstall
• Examining unexplained Secure Boot integrity violations
• Finding hidden processes and suspicious kernel drivers

Compress large language models to 4-bit weights to reduce GPU memory use and accelerate inference. Covers loading compressed models, configuring quantization, and using Transformers or vLLM, with guidance on hardware requirements and backend choices.

• Running large models with limited GPU memory
• Compressing a model with domain-specific sample text
• Serving AWQ models with vLLM

Create and refine Jupyter notebooks for experiments, exploratory analysis, or tutorials. Bundled templates help organize runnable code and short explanations into clear steps, while validation guidance supports notebooks that others can read and rerun.

• Starting a notebook for an experiment
• Turning scripts or notes into a structured notebook
• Creating a step-by-step teaching notebook

Inspect Mac performance to find processes using excessive CPU, GPU, memory, or energy. Combine measurements with explanations of known system processes to diagnose slowness, heat, and startup load, then recommend actions without changing system settings.

• Find the cause of a slow Mac
• Investigate loud fans and overheating
• Check memory pressure and swap activity

Turn mathematical claims into definitions, lemmas, and proofs for Lean 4 and Mathlib. Check proofs with Lean’s trusted core, separately review whether the formal statement matches the original claim, and record verification evidence.

• Verifying an important lemma with Lean 4
• Breaking a theorem into definitions and supporting lemmas
• Checking proofs for sorry, admit, and unauthorized axioms