58 lines
4.6 KiB
TypeScript
58 lines
4.6 KiB
TypeScript
import {z} from "zod"
|
|
import {certificateObservedSchema,certificateServerStateSchema,certificatesStateSchema,type CertificateServerState,type CertificatesState} from "@mmapp/contracts/certificates"
|
|
import {mapRosCertificateRow,type RosCertificateRow} from "./certificate-parse.js"
|
|
type ServerContext={id:number;name:string}
|
|
const rawSchema=z.array(z.record(z.string(),z.string().optional()).refine(row=>!!row.name?.trim(),"Отсутствует имя сертификата"))
|
|
const dateSchema=z.string().datetime({offset:true})
|
|
const nativeDate=/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/
|
|
function validOffset(value:unknown):value is string {
|
|
return typeof value==="string"&&/^[+-](?:0\d|1[0-4]):[0-5]\d$/.test(value)&&(!value.slice(1).startsWith("14:")||value.endsWith(":00"))
|
|
}
|
|
export async function readCertificateRowsWithClock(read:()=>Promise<unknown>,clock:()=>Promise<unknown>):Promise<unknown> {
|
|
const offset=async()=>{try {const row=await clock();const value=row&&typeof row==="object"?(row as Record<string,unknown>)["gmt-offset"]:null;return validOffset(value)?value:null}catch{return null}}
|
|
const before=await offset(),rows=await read()
|
|
if(!Array.isArray(rows)||!rows.some(row=>row&&[row["invalid-before"],row["invalid-after"]].some(value=>typeof value==="string"&&nativeDate.test(value.trim()))))return rows
|
|
const after=await offset()
|
|
return {rows,gmtOffset:before!==null&&before===after?before:null}
|
|
}
|
|
function observedDate(raw:string|undefined,gmtOffset?:string|null) {
|
|
const value=raw?.trim()
|
|
const qualified=value&&nativeDate.test(value)&&validOffset(gmtOffset)?value.replace(" ","T")+gmtOffset:value
|
|
return qualified&&dateSchema.safeParse(qualified).success?new Date(qualified):null
|
|
}
|
|
export function parseCertificateCatalogInput(raw: unknown) {
|
|
const envelope = Array.isArray(raw) ? null : z.object({rows:rawSchema,gmtOffset:z.string().nullable()}).strict().parse(raw)
|
|
return { rows: rawSchema.parse(envelope ? envelope.rows : raw), gmtOffset: envelope?.gmtOffset ?? null }
|
|
}
|
|
export function mapObservedCertificate(server:ServerContext,row:RosCertificateRow,now=new Date(),gmtOffset?:string|null) {
|
|
const base=mapRosCertificateRow(server.id,server.name,row)
|
|
if(!base)throw new Error("Отсутствует сертификат")
|
|
const from=observedDate(row["invalid-before"],gmtOffset),until=observedDate(row["invalid-after"],gmtOffset)
|
|
const flags=row.flags?.toUpperCase()
|
|
const revoked=flags?.includes("R")||row.revoked==="true"||row.revoked==="yes"
|
|
const expired=flags?.includes("E")||row.expired==="true"||row.expired==="yes"||!!until&&until.getTime()<now.getTime()
|
|
const revocationKnown=flags!==undefined||row.revoked==="false"||row.revoked==="no"
|
|
const valid=revocationKnown&&!!from&&!!until&&from.getTime()<=now.getTime()&&until.getTime()>=now.getTime()
|
|
const size=row["key-size"]?.trim()
|
|
const keySize=size&&/^\d+$/.test(size)&&Number.isSafeInteger(Number(size))&&Number(size)>0?Number(size):null
|
|
const trusted=row.trusted==="true"||row.trusted==="yes"?true:row.trusted==="false"||row.trusted==="no"?false:flags!==undefined?flags.includes("T"):null
|
|
return certificateObservedSchema.parse({...base,rosId:row[".id"]?.trim()||null,
|
|
validFrom:from?.toISOString()??null,validUntil:until?.toISOString()??null,
|
|
rawValidFrom:row["invalid-before"]??null,rawValidUntil:row["invalid-after"]??null,
|
|
daysLeft:until?Math.ceil((until.getTime()-now.getTime())/86_400_000):null,keySize,trusted,
|
|
status:revoked?"revoked":expired?"expired":valid?"valid":"unknown"})
|
|
}
|
|
export async function readCertificateServerState(server:ServerContext,read:()=>Promise<unknown>):Promise<CertificateServerState> {
|
|
try{
|
|
const {rows,gmtOffset}=parseCertificateCatalogInput(await read()),now=new Date()
|
|
const result={serverId:String(server.id),serverName:server.name,collectedAt:now.toISOString(),certificates:rows.map(row=>mapObservedCertificate(server,row,now,gmtOffset)),error:null}
|
|
return certificateServerStateSchema.parse(result)
|
|
}catch(error){
|
|
return certificateServerStateSchema.parse({serverId:String(server.id),serverName:server.name,collectedAt:new Date().toISOString(),certificates:[],error:error instanceof z.ZodError?"Некорректный ответ каталога сертификатов":error instanceof Error?error.message.slice(0,500)||"Ошибка RouterOS":"Ошибка RouterOS"})
|
|
}
|
|
}
|
|
export async function collectCertificatesState<T extends ServerContext>(servers:T[],makeReader:(server:T)=>()=>Promise<unknown>):Promise<CertificatesState>{
|
|
const states=await Promise.all(servers.map(server=>readCertificateServerState(server,()=>makeReader(server)())))
|
|
return certificatesStateSchema.parse({collectedAt:new Date().toISOString(),servers:states})
|
|
}
|