@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
144 lines (134 loc) • 6.67 kB
text/typescript
import { isIP } from "node:net";
import type {
PublicArtifactV1,
PublicEvidenceBundleUnsignedV1,
PublicEvidenceBundleV1,
PublicEvidenceRecordV1,
PublicEvidenceSubjectV1,
} from "./types";
import { PublicEvidenceValidationError } from "./validate";
const FORBIDDEN_PUBLIC_STRING_PATTERNS: ReadonlyArray<{ label: string; pattern: RegExp }> = [
{ label: "URL", pattern: /(?:https?|file):\/\//i },
{
label: "local path",
pattern:
/(?:[A-Za-z]:[\\/]|\\\\[A-Za-z0-9._-]+\\|(?:^|[\s"'([{=:])\/(?:Users|home|root|tmp|var|opt|private|etc|mnt|media|srv|usr|dev|run|Library|System|Applications|Volumes|bin|sbin|lib|lib64|proc|sys|boot|Network|cores|nix|snap|app)(?:\/|$))/i,
},
{ label: "email", pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i },
{ label: "IP address", pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b|\[[0-9a-f:]{2,}\]/i },
{ label: "query string", pattern: /[?&][A-Za-z0-9_.~-]+=/ },
{ label: "authorization/header material", pattern: /\b(?:authorization|proxy-authorization|cookie|set-cookie|x-api-key|api[_-]?key|bearer)\b/i },
{ label: "credential", pattern: /\b(?:sk-[A-Za-z0-9_-]{8,}|gh[opusr]_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,}|AKIA[0-9A-Z]{12,})\b/ },
{ label: "private key", pattern: /-----BEGIN [^-]*PRIVATE KEY-----/i },
{ label: "local request/decision/Fabric id", pattern: /\b(?:request|decision|fabric)_[A-Za-z0-9_-]{6,}\b/i },
{ label: "account/project/tenant context", pattern: /\b(?:account|tenant|project|organization|deployment)[=:][^\s]+/i },
{ label: "precise timestamp", pattern: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/ },
];
const PUBLIC_TEXT_ARTIFACT_MEDIA_TYPES = new Set([
"application/json",
"application/json; charset=utf-8",
"text/markdown",
"text/markdown; charset=utf-8",
"text/plain",
"text/plain; charset=utf-8",
]);
function containsIpLiteral(value: string): boolean {
if (isIP(value) !== 0) return true;
for (const candidate of value.match(/[0-9A-Fa-f:]{2,}/g) ?? []) {
if (candidate.includes(":") && isIP(candidate) === 6) return true;
}
return false;
}
function assertPrivacySafeString(value: string, field: string): void {
// `PUBLIC_IDENTIFIER` intentionally permits `:` for reviewed identifiers, so use
// Node's IP parser to validate colon-bearing candidates instead of rejecting them
// with a broad regex. This catches both whole-string and embedded IPv6 literals.
if (containsIpLiteral(value)) {
throw new PublicEvidenceValidationError(
"privacy_rejected",
`${field} contains forbidden IP address material`,
);
}
for (const { label, pattern } of FORBIDDEN_PUBLIC_STRING_PATTERNS) {
if (pattern.test(value)) {
throw new PublicEvidenceValidationError(
"privacy_rejected",
`${field} contains forbidden ${label} material`,
);
}
}
}
function scanSubject(subject: PublicEvidenceSubjectV1, field: string): void {
if (subject.subjectKind === "protocol") {
assertPrivacySafeString(subject.compatibilityVersion, `${field}.compatibilityVersion`);
assertPrivacySafeString(subject.adapterFamily, `${field}.adapterFamily`);
assertPrivacySafeString(subject.inboundProtocol, `${field}.inboundProtocol`);
assertPrivacySafeString(subject.upstreamProtocol, `${field}.upstreamProtocol`);
assertPrivacySafeString(subject.surface, `${field}.surface`);
return;
}
if (subject.subjectKind === "route") {
assertPrivacySafeString(subject.providerId, `${field}.providerId`);
assertPrivacySafeString(subject.modelId, `${field}.modelId`);
assertPrivacySafeString(subject.adapterFamily, `${field}.adapterFamily`);
assertPrivacySafeString(subject.compatibilityVersion, `${field}.compatibilityVersion`);
return;
}
scanSubject(subject.route, `${field}.route`);
assertPrivacySafeString(subject.taskClassId, `${field}.taskClassId`);
assertPrivacySafeString(subject.taskClassVersion, `${field}.taskClassVersion`);
assertPrivacySafeString(subject.fabricCompatibilityVersion, `${field}.fabricCompatibilityVersion`);
}
function scanArtifact(artifact: PublicArtifactV1, index: number): void {
const field = `bundle.artifacts[${index}]`;
assertPrivacySafeString(artifact.artifactClass, `${field}.artifactClass`);
assertPrivacySafeString(artifact.mediaType, `${field}.mediaType`);
if (!PUBLIC_TEXT_ARTIFACT_MEDIA_TYPES.has(artifact.mediaType.toLowerCase())) {
throw new PublicEvidenceValidationError(
"privacy_rejected",
`${field}.mediaType is not in the closed public text-artifact set`,
);
}
if (typeof artifact.contentBase64 !== "string") {
throw new PublicEvidenceValidationError("privacy_rejected", `${field}.contentBase64 is invalid`);
}
const bytes = Buffer.from(artifact.contentBase64, "base64");
if (bytes.toString("base64") !== artifact.contentBase64 || bytes.byteLength !== artifact.byteCount) {
throw new PublicEvidenceValidationError(
"privacy_rejected",
`${field}.contentBase64 is non-canonical or does not match byteCount`,
);
}
let text: string;
try {
text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
} catch {
throw new PublicEvidenceValidationError("privacy_rejected", `${field} is not valid UTF-8 text`);
}
assertPrivacySafeString(text, `${field}.content`);
}
export function validatePublicEvidenceRecordPrivacy(record: PublicEvidenceRecordV1): void {
assertPrivacySafeString(record.suiteId, "record.suiteId");
assertPrivacySafeString(record.suiteVersion, "record.suiteVersion");
assertPrivacySafeString(record.scenarioId, "record.scenarioId");
assertPrivacySafeString(record.scenarioVersion, "record.scenarioVersion");
scanSubject(record.subject, "record.subject");
for (const [index, assertion] of record.assertions.entries()) {
assertPrivacySafeString(assertion.id, `record.assertions[${index}].id`);
}
for (const [index, incident] of (record.incidentRefs ?? []).entries()) {
assertPrivacySafeString(incident.corpusId, `record.incidentRefs[${index}].corpusId`);
}
}
/**
* Second-pass CL-10 export privacy boundary. Hashes, signatures and publisher public-key
* bytes are intentionally not pattern-scanned; every human-semantic public string and
* every final text artifact byte is scanned before local signing/storage or import.
*/
export function validatePublicEvidencePrivacy(
bundle: PublicEvidenceBundleUnsignedV1 | PublicEvidenceBundleV1,
): void {
assertPrivacySafeString(bundle.createdDayUtc, "bundle.createdDayUtc");
for (const record of bundle.records) validatePublicEvidenceRecordPrivacy(record);
for (const [index, artifact] of bundle.artifacts.entries()) scanArtifact(artifact, index);
}