Usando Proxies en PowerShell

Traducir este texto al español. Mantener TODO el formato Markdown, enlaces, bloques de código, tablas intactos. No añadir explicaciones.

Uso de Proxies en PowerShell

Proxies en PowerShell

PowerShell es una potente herramienta de automatización en Windows. Trabajar con proxies es crucial para scripts que operan en redes corporativas o que requieren anonimato.

Invoke-WebRequest con Proxies

Solicitud Básica a través de Proxy

$proxy = "http://proxy_ip:8080"
$response = Invoke-WebRequest -Uri "https://httpbin.org/ip" -Proxy $proxy
$response.Content

Con Autenticación

$proxy = "http://proxy_ip:8080"
$proxyCred = New-Object System.Management.Automation.PSCredential(
    "username",
    (ConvertTo-SecureString "password" -AsPlainText -Force)
)

$response = Invoke-WebRequest -Uri "https://httpbin.org/ip" `
    -Proxy $proxy `
    -ProxyCredential $proxyCred

$response.Content

Invoke-RestMethod (para API JSON)

$proxy = "http://proxy_ip:8080"
$result = Invoke-RestMethod -Uri "https://httpbin.org/ip" -Proxy $proxy
$result.origin  # tu IP a través del proxy

System.Net.WebProxy

Configuración Programática

$webProxy = New-Object System.Net.WebProxy("http://proxy_ip:8080", $true)
$webProxy.Credentials = New-Object System.Net.NetworkCredential("user", "pass")

# Aplicar a WebClient
$client = New-Object System.Net.WebClient
$client.Proxy = $webProxy
$result = $client.DownloadString("https://httpbin.org/ip")
Write-Host $result

Evitar Proxy para Direcciones Específicas

$webProxy = New-Object System.Net.WebProxy("http://proxy_ip:8080", $true)
$webProxy.BypassList = @("localhost", "*.local", "192.168.*")
$webProxy.BypassProxyOnLocal = $true

HttpClient (.NET)

Para escenarios avanzados, usa el HttpClient de .NET:

$proxy = New-Object System.Net.WebProxy("http://proxy_ip:8080")
$proxy.Credentials = New-Object System.Net.NetworkCredential("user", "pass")

$handler = New-Object System.Net.Http.HttpClientHandler
$handler.Proxy = $proxy
$handler.UseProxy = $true

$client = New-Object System.Net.Http.HttpClient($handler)
$response = $client.GetStringAsync("https://httpbin.org/ip").Result
Write-Host $response

Proxy del Sistema

Lectura de la Configuración Actual

# Desde el Registro de Windows
$regPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
$proxyEnabled = (Get-ItemProperty -Path $regPath).ProxyEnable
$proxyServer = (Get-ItemProperty -Path $regPath).ProxyServer
Write-Host "Proxy habilitado: $proxyEnabled"
Write-Host "Servidor proxy: $proxyServer"

Configuración del Proxy del Sistema

$regPath = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings"

# Habilitar proxy
Set-ItemProperty -Path $regPath -Name ProxyEnable -Value 1
Set-ItemProperty -Path $regPath -Name ProxyServer -Value "proxy_ip:8080"

# Excepciones
Set-ItemProperty -Path $regPath -Name ProxyOverride -Value "localhost;*.local"

Write-Host "Proxy configurado"

Deshabilitar el Proxy del Sistema

Set-ItemProperty -Path $regPath -Name ProxyEnable -Value 0
Write-Host "Proxy deshabilitado"

Variables de Entorno

Configuración

$env:HTTP_PROXY = "http://proxy_ip:8080"
$env:HTTPS_PROXY = "http://proxy_ip:8080"
$env:NO_PROXY = "localhost,*.local"

Configuración Persistente

[Environment]::SetEnvironmentVariable("HTTP_PROXY", "http://proxy_ip:8080", "User")
[Environment]::SetEnvironmentVariable("HTTPS_PROXY", "http://proxy_ip:8080", "User")

Verificación

Write-Host "HTTP_PROXY: $env:HTTP_PROXY"
Write-Host "HTTPS_PROXY: $env:HTTPS_PROXY"

Rotación de Proxies en Scripts

$proxies = @(
    "http://user:pass@proxy1:8080",
    "http://user:pass@proxy2:8080",
    "http://user:pass@proxy3:8080"
)

$urls = @(
    "https://httpbin.org/ip",
    "https://httpbin.org/headers",
    "https://httpbin.org/user-agent"
)

foreach ($url in $urls) {
    $proxy = $proxies | Get-Random
    try {
        $response = Invoke-RestMethod -Uri $url -Proxy $proxy -TimeoutSec 10
        Write-Host "OK: $url via $proxy"
        Write-Host $response
    } catch {
        Write-Host "FAIL: $url via $proxy - $($_.Exception.Message)"
    }
}

Prueba de Proxies

function Test-Proxy {
    param(
        [string]$ProxyServer,
        [string]$ProxyPort,
        [string]$Username,
        [string]$Password
    )

    $proxy = "http://${ProxyServer}:${ProxyPort}"
    $cred = $null

    if ($Username) {
        $cred = New-Object System.Management.Automation.PSCredential(
            $Username,
            (ConvertTo-SecureString $Password -AsPlainText -Force)
        )
    }

    try {
        $params = @{
            Uri = "https://httpbin.org/ip"
            Proxy = $proxy
            TimeoutSec = 10
        }
        if ($cred) { $params.ProxyCredential = $cred }

        $response = Invoke-RestMethod @params
        Write-Host "OK - IP: $($response.origin)" -ForegroundColor Green
        return $true
    } catch {
        Write-Host "FAIL - $($_.Exception.Message)" -ForegroundColor Red
        return $false
    }
}

# Uso
Test-Proxy -ProxyServer "proxy_ip" -ProxyPort "8080" -Username "user" -Password "pass"

Prueba Masiva de Proxies

$proxyList = Get-Content "proxies.txt"  # formato: ip:port:user:pass

$results = foreach ($line in $proxyList) {
    $parts = $line.Split(":")
    $ip = $parts[0]; $port = $parts[1]
    $user = $parts[2]; $pass = $parts[3]

    $proxy = "http://${ip}:${port}"
    try {
        $cred = New-Object PSCredential($user, (ConvertTo-SecureString $pass -AsPlainText -Force))
        $resp = Invoke-RestMethod "https://httpbin.org/ip" -Proxy $proxy -ProxyCredential $cred -TimeoutSec 5
        [PSCustomObject]@{Proxy=$line; Status="OK"; IP=$resp.origin}
    } catch {
        [PSCustomObject]@{Proxy=$line; Status="FAIL"; IP="N/A"}
    }
}

$results | Format-Table -AutoSize
$results | Export-Csv "proxy_check_results.csv" -NoTypeInformation

Conclusión

PowerShell proporciona herramientas flexibles para trabajar con proxies: desde cmdlets simples (Invoke-WebRequest) hasta la API completa de .NET. La capacidad de administrar proxies del sistema a través del registro y las variables de entorno hace que PowerShell sea ideal para automatizar la configuración de proxies en máquinas Windows.