112 lines
9.4 KiB
TypeScript
112 lines
9.4 KiB
TypeScript
import { ipsecPeerPatchSchema } from "@mmapp/contracts/ipsec"
|
||
import { z } from "zod"
|
||
import { getServerRowById, type ServerRow } from "../modules/servers/repository/servers-repository.js"
|
||
import { fingerprint, McpError, privateFingerprinter } from "../modules/mcp/security.js"
|
||
import { readIpsecPeerDeleteState, ipsecPeerDeleteValue, type IpsecPeerDeleteState } from "./ipsec-peer-delete.js"
|
||
import { observedBoolean } from "./ospf-observed-values.js"
|
||
import { MikrotikClient } from "./mikrotik.js"
|
||
import { sameWireguardEndpoint } from "./wireguard-source.js"
|
||
import { captureIpsecSnapshot } from "./ipsec-live.js"
|
||
import { captureAndAppendRevision } from "./config-revisions.js"
|
||
import { withApplicationMutationLock, withConfigMutationLock } from "./config-mutation-lock.js"
|
||
import { executeGuardedApplicationWrite } from "./config-mutation-policy.js"
|
||
|
||
export const ipsecPeerUpdatePatchSchema=ipsecPeerPatchSchema.omit({certificate:true}).extend({address:z.string().max(16384).optional(),exchangeMode:z.string().max(16384).optional(),profile:z.string().max(16384).optional(),comment:z.string().max(16384).optional()}).strict()
|
||
type State=IpsecPeerDeleteState
|
||
const fail=(code:string,message:string,status=code==="INVALID_INPUT"?400:code==="NOT_FOUND"?404:["MUTATION_OUTCOME_UNKNOWN","VERIFICATION_FAILED"].includes(code)?502:409)=>new McpError(code,message,status)
|
||
export function ipsecPeerUpdateBody(raw:unknown){
|
||
if(raw&&typeof raw==="object"&&Object.hasOwn(raw,"certificate"))throw fail("INVALID_INPUT","Сертификат задаётся в IPsec identity, а не в peer")
|
||
const parsed=ipsecPeerUpdatePatchSchema.safeParse(raw)
|
||
if(!parsed.success)throw fail("INVALID_INPUT","Некорректные параметры IPsec peer")
|
||
const d=parsed.data,body:Record<string,string>={}
|
||
for(const key of["name","address","profile","comment"]as const)if(d[key]!==undefined)body[key]=d[key]
|
||
if(d.exchangeMode!==undefined)body["exchange-mode"]=d.exchangeMode
|
||
if(d.passive!==undefined)body.passive=d.passive?"yes":"no"
|
||
if(d.disabled!==undefined)body.disabled=d.disabled?"yes":"no"
|
||
return body
|
||
}
|
||
/** Native generic alias must enter this same REST contract, never raw rosPatch. */
|
||
export function ipsecPeerUpdateNativePatch(raw:unknown){
|
||
if(!raw||typeof raw!=="object"||Array.isArray(raw))throw fail("INVALID_INPUT","Некорректные native поля IPsec peer")
|
||
const fields=raw as Record<string,unknown>,patch:Record<string,unknown>={}
|
||
for(const[key,value]of Object.entries(fields)){
|
||
if(key==="certificate")throw fail("INVALID_INPUT","Сертификат задаётся в IPsec identity, а не в peer")
|
||
if(!["name","address","exchange-mode","passive","profile","disabled","comment"].includes(key))throw fail("INVALID_INPUT","Неизвестное native поле IPsec peer")
|
||
if(key==="passive"||key==="disabled"){
|
||
const observed=typeof value==="boolean"?value:typeof value==="string"?observedBoolean(value):null
|
||
if(observed===null)throw fail("INVALID_INPUT","Не подтверждён native boolean IPsec peer")
|
||
patch[key]=observed
|
||
}else patch[key==="exchange-mode"?"exchangeMode":key]=value
|
||
}
|
||
ipsecPeerUpdateBody(patch)
|
||
return ipsecPeerUpdatePatchSchema.parse(patch)
|
||
}
|
||
/** Only native boolean spellings are normalized; opaque properties/order stay sealed. */
|
||
export function ipsecPeerUpdateValue(state:State){
|
||
const value=ipsecPeerDeleteValue(state)
|
||
for(const row of value.catalogs["/ip/ipsec/peer"]??[])for(const key of["passive","disabled"]){
|
||
if(row[key]!==undefined){const observed=observedBoolean(row[key]);if(observed===null)throw fail("STATE_UNAVAILABLE","Не подтверждён native boolean IPsec peer");row[key]=String(observed)}
|
||
}
|
||
return value
|
||
}
|
||
export async function ipsecPeerUpdateProof(state:State){return(await privateFingerprinter("ipsec-peer-update-v2"))(fingerprint(ipsecPeerUpdateValue(state)))}
|
||
export async function readIpsecPeerUpdateState(server:ServerRow,authorize:()=>Promise<unknown>=async()=>{}){
|
||
const state=await readIpsecPeerDeleteState(server,authorize)
|
||
return{...state,proof:await ipsecPeerUpdateProof(state)}
|
||
}
|
||
export function planIpsecPeerUpdate(state:State,id:string,raw:unknown){
|
||
const body=ipsecPeerUpdateBody(raw)
|
||
if(!/^\*[a-z0-9]+$/i.test(id)||id.length>100)throw fail("INVALID_INPUT","Требуется точный native ID IPsec peer")
|
||
const peer=state.catalogs["/ip/ipsec/peer"].find(row=>row[".id"]===id)
|
||
if(!peer)throw fail("NOT_FOUND","Peer не найден")
|
||
for(const flag of["dynamic","builtin","default"])if(peer[flag]!==undefined&&observedBoolean(peer[flag])!==false)throw fail("PROTECTED_OBJECT","Системный или неподтверждённый IPsec peer нельзя изменять")
|
||
const rename=body.name!==undefined&&body.name!==peer.name,oldName=peer.name??""
|
||
if(rename&&(!oldName||state.catalogs["/ip/ipsec/peer"].filter(row=>row.name===oldName).length!==1||state.catalogs["/ip/ipsec/peer"].some(row=>row[".id"]!==id&&row.name===body.name)))throw fail("STATE_CONFLICT","Неоднозначное имя IPsec peer")
|
||
const projected=structuredClone(state),target=projected.catalogs["/ip/ipsec/peer"].find(row=>row[".id"]===id)!
|
||
Object.assign(target,body)
|
||
const companions:Array<{kind:string;id:string}>=[]
|
||
if(rename){
|
||
// Expected RouterOS named-reference projection, NOT companion writes. Native
|
||
// acceptance remains a separate gate; any different result fails read-back.
|
||
for(const row of projected.catalogs["/ip/ipsec/identity"])if(row.peer===oldName){row.peer=body.name;companions.push({kind:"ipsec_identity",id:row[".id"]})}
|
||
for(const row of projected.catalogs["/ip/ipsec/policy"]){
|
||
if(observedBoolean(row.dynamic)===true)continue
|
||
const tokens=(row.peer??"").split(",")
|
||
if(tokens.some(token=>token.trim()===oldName)){
|
||
row.peer=tokens.map(token=>token.trim()===oldName?token.replace(oldName,()=>body.name):token).join(",")
|
||
companions.push({kind:"ipsec_policy",id:row[".id"]})
|
||
}
|
||
}
|
||
}
|
||
return{body,projected,companions,rename,commandCount:Object.keys(body).length?1:0}
|
||
}
|
||
export async function updateIpsecPeerGuarded(server:ServerRow,id:string,patch:unknown,expectedProof?:string,authorize:()=>Promise<unknown>=async()=>{},options:{recordRevision?:typeof captureAndAppendRevision;receiptId?:string;checkpoint?:(value:{receiptId:string;completedCommands:number;commandCount:number;afterProof:string})=>Promise<void>}={}){
|
||
ipsecPeerUpdateBody(patch) // Reject certificate presence before SQL, native reads or history.
|
||
return withApplicationMutationLock(()=>withConfigMutationLock([server.id],()=>executeGuardedApplicationWrite({kind:"ipsec_peer",id},[server.id],async()=>{
|
||
const source=async()=>{await authorize();const fresh=await getServerRowById(server.id);if(!fresh||!sameWireguardEndpoint(fresh,server))throw fail("STATE_CONFLICT","Источник IPsec изменился")}
|
||
const before=await readIpsecPeerUpdateState(server,source)
|
||
if(expectedProof&&before.proof!==expectedProof)throw fail("STATE_CONFLICT","IPsec или зависимости изменились после подготовки")
|
||
const plan=planIpsecPeerUpdate(before,id,patch),desired=await ipsecPeerUpdateProof(plan.projected)
|
||
let completedCommands=0
|
||
if(plan.commandCount){
|
||
let dispatched=false
|
||
try{
|
||
await MikrotikClient.fromServer(server).patch(`/ip/ipsec/peer/${encodeURIComponent(id)}`,plan.body,10000,async()=>{
|
||
const fresh=await readIpsecPeerUpdateState(server,source)
|
||
if(fresh.proof!==before.proof)throw fail("STATE_CONFLICT","IPsec изменился после durable intent; PATCH не отправлен")
|
||
await source();dispatched=true
|
||
})
|
||
completedCommands=1
|
||
}catch(error){if(!dispatched&&error instanceof McpError)throw error;throw fail("MUTATION_OUTCOME_UNKNOWN","Исход PATCH IPsec не подтверждён; повтор запрещён")}
|
||
}
|
||
let after:State
|
||
try{after=await readIpsecPeerUpdateState(server,source)}catch{throw fail("MUTATION_OUTCOME_UNKNOWN","Read-back IPsec недоступен; повтор запрещён")}
|
||
if(after.proof!==desired)throw fail("VERIFICATION_FAILED","PATCH или точная сохранность конфигурации и ссылок IPsec не подтверждены; повтор запрещён")
|
||
try{await source();await options.checkpoint?.({receiptId:options.receiptId??"",commandCount:plan.commandCount,completedCommands,afterProof:after.proof})}catch{throw fail("MUTATION_OUTCOME_UNKNOWN","Проверенный PATCH checkpoint не сохранён; повтор запрещён")}
|
||
const reader={get:async(path:string)=>{await source();if(!Object.hasOwn(after.catalogs,path))throw fail("STATE_UNAVAILABLE","Неизвестный каталог истории IPsec");return structuredClone(after.catalogs[path])}}as unknown as MikrotikClient
|
||
let historyRecorded=false
|
||
try{await source();historyRecorded=Boolean(await(options.recordRevision??captureAndAppendRevision)({serverId:server.id,section:"ipsec",source:"apply",capture:()=>captureIpsecSnapshot(server,reader)}))}catch{/* A history failure never replays the native PATCH. */}
|
||
return{ok:true,verified:true,receiptId:options.receiptId??null,peerId:id,commandCount:plan.commandCount,completedCommands,afterProof:after.proof,historyRecorded,revisionRecorded:historyRecorded,renameCompanions:plan.companions.length,nativeRenameAcceptanceVerified:false,forwardingVerified:false,automaticReplay:false,state:"applied"}
|
||
})))
|
||
}
|