AI-written code only allowed exact `localhost` and `127.0.0.1`, letting SSRF reach `[::1]`, `0.0.0.0`, and the 127/8 range.

+	"crypto/ecdsa"+	"crypto/x509"+	"encoding/pem"+	"os"+	"path/filepath"+	"testing"+)++func TestGenerateCA(t *testing.T) {+	key, cert, certBytes := generateCA(365)++	if key == nil {+		t.Fatal("CA key is nil")+	}+	if cert == nil {+		t.Fatal("CA cert is nil")+	}+	if len(certBytes) == 0 {+		t.Fatal("CA cert bytes empty")+	}+	if !cert.IsCA {+		t.Error("CA cert should have IsCA=true")+	}+	if cert.Subject.CommonName != "LiquidJS Dev Root CA" {+		t.Errorf("CA CN = %q, want %q", cert.Subject.CommonName, "LiquidJS Dev Root CA")+	}+}++func TestGenerateLeaf(t *testing.T) {+	caKey, caCert, _ := generateCA(365)+	leafKey, leafCertBytes := generateLeaf(caKey, caCert, "localhost", "localhost,127.0.0.1", 30)++	if leafKey == nil {+		t.Fatal("leaf key is nil")+	}+	if len(leafCertBytes) == 0 {+		t.Fatal("leaf cert bytes empty")+	}++	leafCert, err := x509.ParseCertificate(leafCertBytes)+	if err != nil {+		t.Fatalf("parse leaf cert: %v", err)+	}+	if leafCert.Subject.CommonName != "localhost" {+		t.Errorf("leaf CN = %q, want %q", leafCert.Subject.CommonName, "localhost")+	}+	if len(leafCert.DNSNames) == 0 {+		t.Error("leaf cert should have DNS SANs")+	}+	if len(leafCert.IPAddresses) == 0 {+		t.Error("leaf cert should have IP SANs")+	}++	// Verify leaf is signed by CA+	roots := x509.NewCertPool()+	roots.AddCert(caCert)+	_, err = leafCert.Verify(x509.VerifyOptions{Roots: roots})+	if err != nil {+		t.Errorf("leaf cert verification failed: %v", err)+	}+}++func TestPemEncode(t *testing.T) {+	data := []byte("test data")+	encoded := pemEncode("CERTIFICATE", data)+	block, _ := pem.Decode(encoded)+	if block == nil {+		t.Fatal("PEM decode returned nil")+	}+	if block.Type != "CERTIFICATE" {+		t.Errorf("PEM type = %q, want CERTIFICATE", block.Type)

+	if block == nil {+		t.Fatal("PEM decode returned nil")+	}+	if block.Type != "EC PRIVATE KEY" {+		t.Errorf("PEM type = %q, want EC PRIVATE KEY", block.Type)+	}+	_, err := x509.ParseECPrivateKey(block.Bytes)+	if err != nil {

+// Usage:+//+//	liquidjs-cert [options]+//	  -out string    Output directory (default "certs")+//	  -cn string     Common name for leaf cert (default "localhost")+//	  -sans string   Comma-separated SANs (default "localhost,127.0.0.1")+//	  -days int      Certificate validity in days (default 365)+//	  -ca-days int   CA validity in days (default 3650)+package main++import (+	"crypto/ecdsa"+	"crypto/elliptic"+	"crypto/rand"+	"crypto/x509"+	"crypto/x509/pkix"+	"encoding/pem"+	"flag"+	"fmt"+	"math/big"+	"net"+	"os"+	"path/filepath"+	"strings"+	"time"+)++func main() {+	outDir := flag.String("out", "certs", "Output directory for certificate files")+	cn := flag.String("cn", "localhost", "Common name for leaf certificate")+	sans := flag.String("sans", "localhost,127.0.0.1", "Comma-separated Subject Alternative Names")+	days := flag.Int("days", 365, "Leaf certificate validity in days")+	caDays := flag.Int("ca-days", 3650, "CA certificate validity in days")+	flag.Parse()++	if err := os.MkdirAll(*outDir, 0o755); err != nil {+		fatalf("create output dir: %v", err)+	}++	// Generate CA+	caKey, caCert, caCertBytes := generateCA(*caDays)+	writeFile(filepath.Join(*outDir, "ca.pem"), pemEncode("CERTIFICATE", caCertBytes))+	writeFile(filepath.Join(*outDir, "ca-key.pem"), pemEncodeECKey(caKey))++	// Generate leaf certificate+	leafKey, leafCertBytes := generateLeaf(caKey, caCert, *cn, *sans, *days)+	writeFile(filepath.Join(*outDir, "cert.pem"), pemEncode("CERTIFICATE", leafCertBytes))+	writeFile(filepath.Join(*outDir, "key.pem"), pemEncodeECKey(leafKey))++	fmt.Printf("Certificates generated in %s/\n", *outDir)+	fmt.Printf("  CA:   ca.pem, ca-key.pem (valid %d days)\n", *caDays)+	fmt.Printf("  Leaf: cert.pem, key.pem (CN=%s, valid %d days)\n", *cn, *days)+	fmt.Printf("  SANs: %s\n", *sans)+	fmt.Println()+	fmt.Println("To trust the CA on macOS:")+	fmt.Printf("  sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain %s/ca.pem\n", *outDir)+	fmt.Println()+	fmt.Println("To trust the CA on Linux:")+	fmt.Printf("  sudo cp %s/ca.pem /usr/local/share/ca-certificates/liquidjs-dev.crt && sudo update-ca-certificates\n", *outDir)+}++func generateCA(validDays int) (*ecdsa.PrivateKey, *x509.Certificate, []byte) {+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)+	if err != nil {+		fatalf("generate CA key: %v", err)+	}++	serial := newSerial()+	template := &x509.Certificate{+		SerialNumber: serial,+		Subject: pkix.Name{+			Organization: []string{"LiquidJS Development CA"},+			CommonName:   "LiquidJS Dev Root CA",+		},

+ * HTTPS or be relative URLs. This prevents data from being transmitted+ * in plaintext, protecting against eavesdropping and MITM attacks.+ *+ * Exceptions:+ * - Relative URLs (./path, /path) — resolved by the browser+ * - localhost and 127.0.0.1 — development only+ */++/**+ * Validate that a URL uses HTTPS or is a relative/localhost URL.+ * Throws if the URL uses plaintext HTTP.+ */+export function assertSecureUrl(url: string): void {+  // Relative URLs are always allowed+  if (url.startsWith('/') || url.startsWith('./') || url.startsWith('../')) {+    return;+  }++  // Data URLs are allowed+  if (url.startsWith('data:')) {+    return;+  }++  // Parse absolute URLs+  let parsed: URL;+  try {+    parsed = new URL(url, typeof window !== 'undefined' ? window.location.href : undefined);+  } catch {+    // If URL can't be parsed, allow it (likely a relative path the browser will resolve)+    return;+  }++  // Allow HTTPS+  if (parsed.protocol === 'https:') {+    return;+  }++  // Allow localhost/127.0.0.1 for development (any protocol)+  if (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1') {+    return;+  }++  // Reject HTTP and other insecure protocols+  throw new Error(+    `[LiquidJS] Insecure URL rejected: "${url}". ` ++      `LiquidJS enforces HTTPS-only for all network requests. ` ++      `Use https:// or a relative URL. ` ++      `Localhost URLs are allowed for development.`,+  );+}++/**+ * Secure fetch — drop-in replacement for window.fetch that enforces HTTPS.+ * Use this instead of fetch() directly to comply with the HTTPS-only policy.+ */+export function secureFetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {+  const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;+  assertSecureUrl(url);+  return fetch(input, init);+}

-  // Data URLs are allowed

 -  // Parse absolute URLs+  // Parse absolute URLs — reject if unparseable   let parsed: URL;   try {     parsed = new URL(url, typeof window !== 'undefined' ? window.location.href : undefined);   } catch {

    // Allow HTTPS   if (parsed.protocol === 'https:') {     return;   } -  // Allow localhost/127.0.0.1 for development (any protocol)-  if (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1') {+  // Allow localhost for development (any protocol) — covers IPv4/IPv6 loopback+  if (+    parsed.hostname === 'localhost' ||+    parsed.hostname === '127.0.0.1' ||+    parsed.hostname === '[::1]' ||+    parsed.hostname === '0.0.0.0' ||+    parsed.hostname.startsWith('127.')+  ) {     return;   } @@ -70,5 +81,7 @@ export function assertSecureUrl(url: string): void { export function secureFetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {   const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;   assertSecureUrl(url);-  return fetch(input, init);+  // Default to rejecting redirects to prevent redirect-based SSRF.+  // Callers can override with { redirect: 'follow' } if they trust the target.+  return fetch(input, { redirect: 'error', ...init }); }

+    // L-6: Reject CSS values containing dangerous patterns.+    // Normalize unicode escapes and strip CSS comments before checking+    // to prevent bypass via \65xpression( or exp/**/ression( patterns.+    const normalizedCss = cssValue+      .replace(/\\[0-9a-fA-F]{1,6}\s?/g, '_')+      .replace(/\/\*[\s\S]*?\*\//g, '');+    if (/expression\s*\(|javascript\s*:|behavior\s*:|moz-binding|-o-link/i.test(normalizedCss)) {+      cssValue = '';+    }      parts.push(`${cssProp}:${cssValue}`);   }

       result += val;     }