Files
archived-orca/src/main/runtime/windows-firewall-remote-scope.ts
T
OrcaWinandOrcaWin 7d6603aa17 [comment audit] Complete repository-wide comment cleanup (#33249)
* [comment audit] Align legacy failure-read counts with cached display

* [comment audit] Condense shared provider lifecycle and browser recovery comments [skip ci]

* [comment audit] Condense shared generation, path and preview comments [skip ci]

* [comment audit] Condense host, file and Git contract rationale [skip ci]

* [comment audit] Tighten Git lifecycle and provider contract comments [skip ci]

* [comment audit] Clarify shared host authority and launch isolation [skip ci]

* [comment audit] simplify local access mobile and native chat contracts [skip ci]

* [comment audit] simplify native chat presentation and state contracts [skip ci]

* [comment audit] simplify native runtime and provider contracts [skip ci]

* [comment audit] simplify migration and orchestration contracts [skip ci]

* [comment audit] simplify plugin trust and process capture rationale [skip ci]

* [comment audit] simplify terminal delivery and remote compatibility rationale [skip ci]

* [comment audit] clarify remote recovery and launch wire rationale [skip ci]

* [comment audit] shorten shared RPC compatibility and runtime evidence comments [skip ci]

* [comment audit] simplify secure storage shell startup and sidebar rationale [skip ci]

* [comment audit] clarify sidebar, skill and SSH invariants [skip ci]

* [comment audit] condense structured chat delivery and timing rationale [skip ci]

* [comment audit] condense terminal replay and telemetry invariants [skip ci]

* [comment audit] clarify launch permission and terminal delivery rationale [skip ci]

* [comment audit] clarify workspace ownership and layout contracts [skip ci]

* [comment audit] wait for fitted and painted SSH terminal links

* [comment audit] clarify layout persistence and session ownership [skip ci]

* [comment audit] clarify host routing and workspace lifecycle contracts [skip ci]

* [comment audit] clarify startup persistence and app lifetime comments [skip ci]

* [comment audit] clarify recovery and activity boundaries [skip ci]

* [comment audit] condense activity and artifact invariants [skip ci]

* [comment audit] condense automation authority contracts [skip ci]

* [comment audit] simplify automation scheduling and history contracts [skip ci]

* [comment audit] clarify browser chrome and annotation lifecycles [skip ci]

* [comment audit] clarify browser routing and retained guest ownership [skip ci]

* [comment audit] clarify browser recovery and document ownership comments [skip ci]

* [comment audit] restore hosted runners required by native IME fixtures

* [comment audit] shorten preview, palette and dashboard invariants [skip ci]

* [comment audit] clarify terminal preview, dashboard and retention comments [skip ci]

* [comment audit] clarify diff-note recovery and editor lifecycle comments [skip ci]

* [comment audit] shorten rich-text and combined-diff ownership comments [skip ci]

* [comment audit] shorten autosave, draft recovery and model ownership comments [skip ci]

* [comment audit] shorten save-queue, notebook and Markdown constraints [skip ci]

* [comment audit] shorten Monaco, PDF and rich Markdown safeguards [skip ci]

* [comment audit] clarify rich Markdown source and selection safeguards [skip ci]

* [comment audit] clarify editor loading and emulator stream lifetimes [skip ci]

* [comment audit] trim emulator and feature tour narration [skip ci]

* [comment audit] clarify floating workspace and GitHub cache ownership [skip ci]

* [comment audit] trim provider controls and Linear filter explanations [skip ci]

* [comment audit] clarify pairing and chat resume lifetimes [skip ci]

* [comment audit] clarify chat delivery and transcript lifetimes [skip ci]

* [comment audit] clarify session options and host-owned status [skip ci]

* [comment audit] clarify draft durability and live-status precedence [skip ci]

* [comment audit] Trim chat send and model ownership explanations [skip ci]

* [comment audit] Shorten transcript ownership and send recovery comments [skip ci]

* [comment audit] Simplify native chat composer and transcript hook comments [skip ci]

* [comment audit] Shorten native chat scroll and structured session explanations [skip ci]

* [comment audit] Trim workspace picker and onboarding commentary [skip ci]

* [comment audit] Simplify pet rendering, review cache and quick open comments [skip ci]

* [comment audit] Trim sidebar and session history explanations [skip ci]

* [comment audit] Condense session resume and review checks comments [skip ci]

* [comment audit] Shorten checks state and file explorer refresh comments [skip ci]

* [comment audit] Trim plugin bridge and source-control action rationale [skip ci]

* [comment audit] Trim source-control listing and review rationale [skip ci]

* [comment audit] Shorten sidebar lifecycle and explorer safeguards [skip ci]

* [comment audit] Condense Settings account and appearance rationale [skip ci]

* [comment audit] Trim pairing and repository Settings explanations [skip ci]

* [comment audit] Condense Settings search SSH and terminal safeguards [skip ci]

* [comment audit] Shorten Settings voice and provider ownership comments [skip ci]

* [comment audit] Condense Settings draft persistence and host-state rationale [skip ci]

* [comment audit] Trim Settings hooks and sidebar setup rationale [skip ci]

* [comment audit] Condense sidebar deletion and board-filter safeguards [skip ci]

* [comment audit] Condense worktree cards, host ownership and Markdown contracts [skip ci]

* [comment audit] Condense sidebar drag, folder and filtering contracts [skip ci]

* [comment audit] Condense sidebar parity, sleep and host ownership contracts [skip ci]

* [comment audit] Prune focus-read baseline after comment cleanup

* [comment audit] Clarify sidebar visibility, board drops and agent evidence [skip ci]

* [comment audit] Tighten sidebar listing, drag and reveal contracts [skip ci]

* [comment audit] Clarify viewport geometry and skill update safeguards [skip ci]

* [comment audit] Tighten skill inventory, usage and host status comments [skip ci]

* [comment audit] Clarify usage ownership and resource kill safeguards [skip ci]

* [comment audit] Tighten tab selection, rename and search contracts [skip ci]

* [comment audit] Tighten tab-strip geometry and drag ownership comments [skip ci]

* [comment audit] Tighten Tasks recovery, pagination and mutation comments [skip ci]

* [comment audit] Tighten provider loading and terminal recovery comments [skip ci]

* [comment audit] Tighten completion, cadence and PTY ownership comments [skip ci]

* [comment audit] Clarify terminal restore and parked-pane boundaries [skip ci]

* [comment audit] Tighten PTY startup and replay explanations [skip ci]

* [comment audit] Clarify PTY identity and delivery ownership [skip ci]

* [comment audit] Shorten remote reconnect and input replay rationale [skip ci]

* [comment audit] Condense terminal parking clipboard and file link comments [skip ci]

* [comment audit] Clarify IME ownership and trim trace history [skip ci]

* [comment audit] Shorten pane recovery and parked watcher explanations [skip ci]

* [comment audit] Condense snapshot replay and visibility recovery rationale [skip ci]

* [comment audit] Shorten terminal parking and keyboard ownership rationale [skip ci]

* [comment audit] Trim renderer lifecycle and menu rationale [skip ci]

* [comment audit] Condense workspace cleanup ownership and settlement notes [skip ci]

* [comment audit] Clarify renderer hook evidence and source ownership [skip ci]

* [comment audit] Tighten IPC ownership and reconnect explanations [skip ci]

* [comment audit] Trim renderer focus, paste and attention comments [skip ci]

* [comment audit] Shorten scroll, locale and agent lifecycle comments [skip ci]

* [comment audit] Trim agent launch, resume and ownership commentary [skip ci]

* [comment audit] Shorten account, browser and editor comments [skip ci]

* [comment audit] Clarify host-mirror waits, previews and input ownership [skip ci]

* [comment audit] Condense launch recovery and editor tokenization comments [skip ci]

* [comment audit] Condense workspace selection and terminal pane rationale [skip ci]

* [comment audit] Condense terminal fitting and rendering recovery comments [skip ci]

* [comment audit] Condense terminal input and host routing explanations [skip ci]

* [comment audit] Condense ownership and sleeping-session recovery rationale [skip ci]

* [comment audit] Condense structured launch and terminal link explanations [skip ci]

* [comment audit] Condense terminal ownership and workspace file routing rationale [skip ci]

* [comment audit] Condense session persistence and workspace activation rationale [skip ci]

* [comment audit] Condense workspace routing and browser ownership rationale [skip ci]

* [comment audit] Condense mirror recovery and layout authority rationale [skip ci]

* [comment audit] Condense runtime transport and file safety rationale [skip ci]

* [comment audit] Condense runtime graph and structured session rationale [skip ci]

* [comment audit] Condense browser creation and remote tab recovery rationale [skip ci]

* [comment audit] Condense snapshot authority and publisher recovery rationale [skip ci]

* [comment audit] Condense frame, startup and provider cache rationale [skip ci]

* [comment audit] Condense host twin and agent lifecycle rationale [skip ci]

* [comment audit] Condense browser authority and editor cleanup rationale [skip ci]

* [comment audit] Condense editor buffer identity and review cache rationale [skip ci]

* [comment audit] Condense provider lifetime and repository ownership rationale [skip ci]

* [comment audit] Condense reconnect, hydration and terminal retirement rationale [skip ci]

* [comment audit] Condense recovery, reconciliation and persistence rationale [skip ci]

* [comment audit] Condense cleanup ownership and listing admission rationale [skip ci]

* [comment audit] Condense teardown ordering and terminal ownership rationale [skip ci]

* [comment audit] Condense recovery ledger and web host-boundary rationale [skip ci]

* [comment audit] Condense web reconnect and credential lifecycle rationale [skip ci]

* [comment audit] Condense cloud rollout and assignment safety rationale [skip ci]

* [comment audit] Condense relay session and database recovery rationale [skip ci]

* [comment audit] Condense relay placement and protocol compatibility rationale [skip ci]

* [comment audit] Condense build and packaging constraints [skip ci]

* [comment audit] Condense CI gates and validation isolation rationale [skip ci]

* [comment audit] Condense catalog identity and browser validation rationale [skip ci]

* [comment audit] Condense mobile browser and frame-budget rationale [skip ci]

* [comment audit] Shorten mobile route and browser test explanations [skip ci]

* [comment audit] Condense editor and session seam test rationale [skip ci]

* [comment audit] Trim session and terminal closure history [skip ci]

* [comment audit] Shorten terminal browser and census explanations [skip ci]

* [comment audit] Preserve root-only E2E diagnostic baseline

* [comment audit] Condense mobile seam and HTML preview test rationale [skip ci]

* [comment audit] Condense preview instrumentation and render harness rationale [skip ci]

* [comment audit] Condense bundle contracts and native-build constraints [skip ci]

* [comment audit] Shorten native packaging and CI routing rationale [skip ci]

* [comment audit] Condense release tooling and benchmark constraints [skip ci]

* [comment audit] Condense packaging and platform gate rationale [skip ci]

* [comment audit] Shorten mobile route and history rationale [skip ci]

* [comment audit] Condense mobile browser and component rationale [skip ci]

* [comment audit] Shorten drawer and workspace-form rationale [skip ci]

* [comment audit] Trim mobile review and editor-document explanations [skip ci]

* [comment audit] Condense editor lifecycle and Markdown explanations [skip ci]

* [comment audit] Trim mobile file, diagnostics and dictation commentary [skip ci]

* [comment audit] Simplify mobile host-list and workspace-view explanations [skip ci]

* [comment audit] Clarify mobile shell lifetime and bridge delivery constraints [skip ci]

* [comment audit] Condense bridge stream, native request and audio rationale [skip ci]

* [comment audit] Reduce bridge schema and page-client commentary [skip ci]

* [comment audit] Tighten mobile page bridge contracts [skip ci]

* [comment audit] Clarify mobile cache and session constraints [skip ci]

* [comment audit] Condense mobile route and lifecycle rationale [skip ci]

* [comment audit] Tighten mobile shell hook timing rationale [skip ci]

* [comment audit] Clarify route handoff and notification compatibility [skip ci]

* [comment audit] Clarify push registration and dictation cleanup constraints [skip ci]

* [comment audit] Condense keyboard geometry and native media ownership rationale [skip ci]

* [comment audit] Tighten mobile chat scroll and composer concurrency rationale [skip ci]

* [comment audit] Condense mobile reply compatibility and upload ownership rationale [skip ci]

* [comment audit] Condense optimistic echo and scroll ownership rationale [skip ci]

* [comment audit] Tighten stream replay and queued session ownership rationale [skip ci]

* [comment audit] Condense mobile composer and reply-schema constraints [skip ci]

* [comment audit] Clarify mobile transcript recovery and session ownership [skip ci]

* [comment audit] Clarify mobile queue and source-control compatibility [skip ci]

* [comment audit] Condense storage and task launch constraints [skip ci]

* [comment audit] Clarify task schemas and terminal document ownership [skip ci]

* [comment audit] Tighten terminal input and viewport rationale [skip ci]

* [comment audit] Shorten terminal and RPC recorder contracts [skip ci]

* [comment audit] Condense recorder engine and connection contracts [skip ci]

* [comment audit] Shorten host credential and relay recovery comments [skip ci]

* [comment audit] Tighten pairing recovery and bundle transport rationale [skip ci]

* [comment audit] Clarify RPC delivery and workspace catalog boundaries [skip ci]

* [comment audit] Condense catalog and relay entry contracts [skip ci]

* [comment audit] Shorten shutdown and SSH relay delivery contracts [skip ci]

* [comment audit] Condense WSL relay and E2E regression rationale [skip ci]

* [comment audit] Shorten cross-version harness and renderer fixture explanations [skip ci]

* [comment audit] Condense paired-host and E2E lifecycle rationale [skip ci]

* [comment audit] Shorten layout oracle and regression explanations [skip ci]

* [comment audit] Condense paired recovery and ownership regression contracts [skip ci]

* [comment audit] Shorten restart, sidebar and SSH lifecycle contracts [skip ci]

* [comment audit] Condense terminal rendering and IME regression rationale [skip ci]

* [comment audit] Shorten terminal recovery and benchmark contracts [skip ci]

* [comment audit] Condense tooling and Windows lifecycle proof rationale [skip ci]

* [comment audit] Condense workflow routing and release rationale [skip ci]

* [comment audit] Condense mobile security and installer contracts [skip ci]

* [comment audit] Shorten native rationale and stylesheet workarounds [skip ci]

* [comment audit] Shorten Windows visibility probe rationale [skip ci]

* [comment audit] Condense embedded release and signing rationale [skip ci]

* [comment audit] Retain current main test behavior in final reconciliation [skip ci]

* [comment audit] Complete final comment review across current source inventory

* [comment audit] Handle consolidated audit reports before final CI

* [comment audit] Preserve credential storage census detail [skip ci]

* [comment audit] Scale broad changed E2E selections with verified timing shards

* [comment audit] Align E2E assertions with browser close and settled session metadata

* [comment audit] Match existing E2Es to current resource and windowing contracts

* [comment audit] Observe the shared server outage notice in reconnect coverage

* [comment audit] Make existing renderer probes measure settled tab and PTY work

* [comment audit] Align palette E2E selector with task search

* [comment audit] Refresh remaining palette search selectors

* [comment audit] Keep selector correction within selected audit specs

* [comment audit] Await emoji fixture settings inside renderer evaluation

* [comment audit] Cancel fixture fit retries between terminal tests

---------

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-10-25 04:05:46 -07:00

214 lines
6.8 KiB
TypeScript

type IpVersion = 4 | 6
type ParsedIpAddress = {
version: IpVersion
bits: 32 | 128
value: bigint
}
type IpRange = {
version: IpVersion
start: bigint
end: bigint
}
export function hasSufficientWindowsFirewallRemoteScope(
ruleScopes: unknown,
localAddress: unknown,
localPrefixLength: unknown
): boolean {
const rules = Array.isArray(ruleScopes) ? ruleScopes : [ruleScopes]
const localSubnet = parseSubnet(localAddress, localPrefixLength)
// Why: coverage is checked per scope, never unioned across rules — this
// advisory check fails safe, so accepting fragmented rules only adds risk.
return rules.some((rule) => ruleHasSufficientScope(rule, localSubnet))
}
function ruleHasSufficientScope(rule: unknown, localSubnet: IpRange | null): boolean {
if (!isRecord(rule)) {
return false
}
const addresses = Array.isArray(rule.remoteAddresses)
? rule.remoteAddresses
: [rule.remoteAddresses]
return addresses.some(
(address) => typeof address === 'string' && addressScopeIsSufficient(address, localSubnet)
)
}
function addressScopeIsSufficient(scope: string, localSubnet: IpRange | null): boolean {
const normalized = scope.trim().toLowerCase()
if (normalized === 'any' || normalized === 'localsubnet') {
return true
}
if (
normalized === 'any4' ||
normalized === 'any6' ||
normalized === 'localsubnet4' ||
normalized === 'localsubnet6'
) {
// Why: these keywords cover a single family, so they need the selected
// interface's family; an unknown family (null subnet) fails closed.
return localSubnet?.version === (normalized.endsWith('4') ? 4 : 6)
}
if (!localSubnet) {
return false
}
// Without a phone IP, require whole-subnet coverage; single-host /32 or /128 ranges prove only desktop access.
const explicitRange = parseIpRange(scope)
return (
localSubnet.start !== localSubnet.end &&
explicitRange?.version === localSubnet.version &&
explicitRange.start <= localSubnet.start &&
explicitRange.end >= localSubnet.end
)
}
function parseSubnet(address: unknown, prefixLength: unknown): IpRange | null {
if (typeof address !== 'string' || typeof prefixLength !== 'number') {
return null
}
const parsed = parseIpAddress(address)
return parsed ? subnetFromParsed(parsed, prefixLength) : null
}
function subnetFromParsed(parsed: ParsedIpAddress, prefixLength: number): IpRange | null {
if (!Number.isInteger(prefixLength) || prefixLength < 0 || prefixLength > parsed.bits) {
return null
}
const hostBits = BigInt(parsed.bits - prefixLength)
const hostMask = hostBits === 0n ? 0n : (1n << hostBits) - 1n
const start = parsed.value & ~hostMask
return { version: parsed.version, start, end: start | hostMask }
}
// Accept Windows dotted-netmask CIDR only for contiguous masks; refuse holey masks.
function maskPrefixLength(maskText: string, version: IpVersion): number | null {
const mask = parseIpAddress(maskText)
if (!mask || mask.version !== version) {
return null
}
const fullMask = (1n << BigInt(mask.bits)) - 1n
const hostPart = ~mask.value & fullMask
if ((hostPart & (hostPart + 1n)) !== 0n) {
return null
}
let hostBits = 0
for (let remaining = hostPart; remaining > 0n; remaining >>= 1n) {
hostBits += 1
}
return mask.bits - hostBits
}
function parseIpRange(scope: string): IpRange | null {
const trimmed = scope.trim()
const dashIndex = trimmed.indexOf('-')
if (dashIndex !== -1) {
if (dashIndex !== trimmed.lastIndexOf('-')) {
return null
}
const start = parseIpAddress(trimmed.slice(0, dashIndex))
const end = parseIpAddress(trimmed.slice(dashIndex + 1))
if (!start || !end || start.version !== end.version || start.value > end.value) {
return null
}
return { version: start.version, start: start.value, end: end.value }
}
const slashIndex = trimmed.indexOf('/')
if (slashIndex !== -1) {
if (slashIndex !== trimmed.lastIndexOf('/')) {
return null
}
const address = parseIpAddress(trimmed.slice(0, slashIndex))
if (!address) {
return null
}
const suffix = trimmed.slice(slashIndex + 1)
const prefixLength = /^\d+$/.test(suffix)
? Number(suffix)
: maskPrefixLength(suffix, address.version)
return prefixLength === null ? null : subnetFromParsed(address, prefixLength)
}
const address = parseIpAddress(trimmed)
return address ? { version: address.version, start: address.value, end: address.value } : null
}
function parseIpAddress(input: string): ParsedIpAddress | null {
const trimmed = input.trim()
const bracketed = trimmed.startsWith('[') || trimmed.endsWith(']')
if (bracketed && !(trimmed.startsWith('[') && trimmed.endsWith(']'))) {
return null
}
const address = (bracketed ? trimmed.slice(1, -1) : trimmed).split('%', 1)[0] ?? ''
return address.includes(':') ? parseIpv6(address) : parseIpv4(address)
}
function parseIpv4(address: string): ParsedIpAddress | null {
const octets = address.split('.')
if (octets.length !== 4 || octets.some((octet) => !/^\d{1,3}$/.test(octet))) {
return null
}
const values = octets.map(Number)
if (values.some((octet) => octet > 255)) {
return null
}
const value = values.reduce((result, octet) => (result << 8n) | BigInt(octet), 0n)
return { version: 4, bits: 32, value }
}
function parseIpv6(address: string): ParsedIpAddress | null {
const expandedAddress = expandEmbeddedIpv4(address)
if (!expandedAddress) {
return null
}
const halves = expandedAddress.split('::')
if (halves.length > 2) {
return null
}
const left = splitIpv6Half(halves[0] ?? '')
const right = splitIpv6Half(halves[1] ?? '')
if (!left || !right) {
return null
}
const hasCompression = halves.length === 2
const missingGroups = 8 - left.length - right.length
if ((!hasCompression && missingGroups !== 0) || (hasCompression && missingGroups < 1)) {
return null
}
const groups = [...left, ...Array<string>(missingGroups).fill('0'), ...right]
const value = groups.reduce((result, group) => (result << 16n) | BigInt(`0x${group}`), 0n)
return { version: 6, bits: 128, value }
}
function expandEmbeddedIpv4(address: string): string | null {
if (!address.includes('.')) {
return address
}
const lastColon = address.lastIndexOf(':')
const ipv4 = parseIpv4(address.slice(lastColon + 1))
if (lastColon === -1 || !ipv4) {
return null
}
const high = ((ipv4.value >> 16n) & 0xffffn).toString(16)
const low = (ipv4.value & 0xffffn).toString(16)
return `${address.slice(0, lastColon)}:${high}:${low}`
}
function splitIpv6Half(half: string): string[] | null {
if (half === '') {
return []
}
const groups = half.split(':')
return groups.every((group) => /^[\da-f]{1,4}$/i.test(group)) ? groups : null
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}