feat(v-ecosystem): expand final 4 connector stubs — ptp, smb, deception, federation

v-ptp: IEEE 1588-2019 PTP — PtpMessageType.is_event(), PtpTimestamp.to_nanos(),
  encode_ptp_header (34 bytes), compute_mean_path_delay + clock_offset, 9 tests.

v-smb: SMB2 — Smb2Command.min_structure_size(), encode/decode_smb2_header (64 bytes
  LE, magic verify), encode_negotiate_request (3 dialects incl. 0x0311), 8 tests.

v_deception: Moving-target defence — DecoyType.default_ttl(), Canarytoken + triggered
  state, MovingTargetPolicy with deploy/trigger/rotate_decoys, 9 tests.

v_federation: SAML2/OIDC/CAS — build_saml_authn_request (SHA-256-derived request ID),
  parse_saml_response_issuer, validate_oidc_id_token_claims (iss/sub/aud/exp),
  FederationSession.is_expired(), 6 tests.

v-ecosystem connector completion: all 95 connectors now ≥ 200 lines (33 081 total).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

v-ecosystem/v-api-interfaces/v-ptp/src/ptp.v

@@ -49,6 +49,36 @@ const flag_freq_traceable    = u16(0x8000)
 // PTP transport domain default.
 const default_domain = u8(0)
 
+// ptp_domain_default is the IANA-standard default PTP domain (IEEE 1588 §7.1).
+pub const ptp_domain_default = u8(0)
+
+// --- Message type enumeration ---
+
+// PtpMessageType is a typed enumeration of PTP message type codes.
+pub enum PtpMessageType {
+	sync        // 0x0 — periodic reference time from master clock
+	delay_req   // 0x1 — sent by slave to start path delay measurement
+	follow_up   // 0x8 — carries precise t1 for two-step clocks
+	delay_resp  // 0x9 — master's response to Delay_Req, carries t4
+	announce    // 0xB — master identity advertisement for BMCA
+}
+
+// is_event returns true for message types transported on the event port (319).
+pub fn (m PtpMessageType) is_event() bool {
+	return m == .sync || m == .delay_req
+}
+
+// code returns the 4-bit wire value for this message type.
+pub fn (m PtpMessageType) code() u8 {
+	return match m {
+		.sync       { u8(0x0) }
+		.delay_req  { u8(0x1) }
+		.follow_up  { u8(0x8) }
+		.delay_resp { u8(0x9) }
+		.announce   { u8(0xB) }
+	}
+}
+
 // --- Clock class enumeration ---
 
 // ClockClass indicates the quality of the clock source.
@@ -70,6 +100,21 @@ pub:
 	nanoseconds u32    // Nanoseconds within the second
 }
 
+// PtpTimestamp is the canonical 10-byte PTP timestamp (IEEE 1588 §5.3.3).
+// seconds field is 48 bits, split as seconds_msb (u16) + seconds (u32).
+pub struct PtpTimestamp {
+pub:
+	seconds_msb u16  // Upper 16 bits of the 48-bit seconds field
+	seconds     u32  // Lower 32 bits of the seconds field
+	nanoseconds u32  // Sub-second [0, 999_999_999]
+}
+
+// to_nanos converts PtpTimestamp to a single i64 nanosecond value.
+pub fn (t PtpTimestamp) to_nanos() i64 {
+	secs := i64(t.seconds_msb) << 32 | i64(t.seconds)
+	return secs * 1_000_000_000 + i64(t.nanoseconds)
+}
+
 // ClockIdentity is an 8-byte unique clock identifier.
 pub struct ClockIdentity {
 pub:
@@ -147,6 +192,25 @@ pub fn (mut c Client) compute_offset(t1 Timestamp, t2 Timestamp, t3 Timestamp, t
 	return c.offset_ns
 }
 
+// --- Path delay / offset computation ---
+
+// compute_mean_path_delay computes the mean path delay from the four IEEE 1588
+// exchange timestamps (all in nanoseconds since epoch):
+//   t1 = master Sync egress (from Follow_Up)
+//   t2 = slave  Sync ingress (measured locally)
+//   t3 = slave  Delay_Req egress (measured locally)
+//   t4 = master Delay_Req ingress (from Delay_Resp)
+// Formula: ((t2 - t1) + (t4 - t3)) / 2
+pub fn compute_mean_path_delay(t1 i64, t2 i64, t3 i64, t4 i64) i64 {
+	return ((t2 - t1) + (t4 - t3)) / 2
+}
+
+// compute_clock_offset computes the slave clock offset from master.
+// Formula: (t2 - t1) - mean_path_delay
+pub fn compute_clock_offset(t1 i64, t2 i64, t3 i64, t4 i64) i64 {
+	return (t2 - t1) - compute_mean_path_delay(t1, t2, t3, t4)
+}
+
 // --- Encoding ---
 
 // encode_ptp_header serialises the common PTP header portion (34 bytes)
@@ -274,3 +338,25 @@ fn test_parse_header_too_short() {
 	assert false
 }
 
+fn test_ptp_message_type_is_event() {
+	assert PtpMessageType.sync.is_event()       == true
+	assert PtpMessageType.delay_req.is_event()  == true
+	assert PtpMessageType.follow_up.is_event()  == false
+	assert PtpMessageType.delay_resp.is_event() == false
+	assert PtpMessageType.announce.is_event()   == false
+}
+
+fn test_compute_mean_path_delay_symmetric() {
+	// t2-t1 = 100ns, t4-t3 = 100ns → delay = 100ns, offset = 0
+	delay  := compute_mean_path_delay(i64(1000), i64(1100), i64(1150), i64(1250))
+	offset := compute_clock_offset(i64(1000), i64(1100), i64(1150), i64(1250))
+	assert delay  == i64(100)
+	assert offset == i64(0)
+}
+
+fn test_ptp_timestamp_to_nanos() {
+	ts := PtpTimestamp{ seconds_msb: u16(0), seconds: u32(1), nanoseconds: u32(500_000_000) }
+	nanos := ts.to_nanos()
+	assert nanos == i64(1_500_000_000)
+}
+

v-ecosystem/v-api-interfaces/v-smb/src/smb.v

@@ -42,6 +42,9 @@ const dialect_smb_300 = u16(0x0300)
 const dialect_smb_302 = u16(0x0302)
 const dialect_smb_311 = u16(0x0311)
 
+// smb2_dialect_311 is the SMB 3.1.1 dialect identifier (public alias).
+pub const smb2_dialect_311 = u16(0x0311)
+
 // SMB2 NEGOTIATE request structure size constant.
 const negotiate_struct_size = u16(36)
 
@@ -71,6 +74,63 @@ pub enum ShareType {
 	print   // Printer share
 }
 
+// --- SMB2 command enumeration ---
+
+// Smb2Command enumerates SMB2 command codes (MS-SMB2 §2.2.1).
+pub enum Smb2Command {
+	negotiate      // 0x0000 — Negotiate protocol dialect
+	session_setup  // 0x0001 — Authenticate and set up session
+	tree_connect   // 0x0003 — Connect to a named share
+	create         // 0x0005 — Open or create a file
+	read           // 0x0008 — Read data from a file
+	write          // 0x0009 — Write data to a file
+	close          // 0x0006 — Close a file handle
+}
+
+// min_structure_size returns the minimum StructureSize for the request body
+// of each SMB2 command, per MS-SMB2 specification tables.
+pub fn (c Smb2Command) min_structure_size() int {
+	return match c {
+		.negotiate     { 36 }   // §2.2.3
+		.session_setup { 25 }   // §2.2.5
+		.tree_connect  { 9  }   // §2.2.9
+		.create        { 57 }   // §2.2.13
+		.read          { 49 }   // §2.2.19
+		.write         { 49 }   // §2.2.21
+		.close         { 24 }   // §2.2.15
+	}
+}
+
+// code returns the 2-byte little-endian command code for this command.
+pub fn (c Smb2Command) code() u16 {
+	return match c {
+		.negotiate     { u16(0x0000) }
+		.session_setup { u16(0x0001) }
+		.tree_connect  { u16(0x0003) }
+		.create        { u16(0x0005) }
+		.read          { u16(0x0008) }
+		.write         { u16(0x0009) }
+		.close         { u16(0x0006) }
+	}
+}
+
+// --- SMB2 header struct ---
+
+// Smb2Header holds all fields of the 64-byte SMB2 packet header (MS-SMB2 §2.2.1.2).
+pub struct Smb2Header {
+pub:
+	protocol_id      [4]u8        // Must be [0xFE, 'S', 'M', 'B']
+	header_length    u16          // Fixed: 64
+	credit_charge    u16          // Credits consumed by this request
+	status           u32          // NT status code (response) or channel sequence (request)
+	command          Smb2Command  // SMB2 command code
+	credits_requested u16         // Credits requested (client) or granted (server)
+	flags            u32          // Header flags bitmask
+	message_id       u64          // Unique message identifier per session
+	session_id       u64          // Session identifier (0 before auth)
+	signature        [16]u8       // Message signature (when signing enabled)
+}
+
 // --- Data structures ---
 
 // SmbHeader holds the parsed SMB2 protocol header fields.
@@ -244,6 +304,87 @@ pub fn parse_header(data []u8) !SmbHeader {
 	}
 }
 
+// encode_smb2_header serialises a Smb2Header to the 64-byte SMB2 wire
+// format (MS-SMB2 §2.2.1.2), using little-endian byte order throughout.
+pub fn encode_smb2_header(h Smb2Header) []u8 {
+	mut out := []u8{len: 0, cap: 64}
+	// ProtocolId (4 bytes)
+	for b in h.protocol_id { out << b }
+	// StructureSize (2 bytes LE) = 64
+	out << u8(64 & 0xFF) << u8(64 >> 8)
+	// CreditCharge (2 bytes LE)
+	out << u8(h.credit_charge & 0xFF) << u8(h.credit_charge >> 8)
+	// Status (4 bytes LE)
+	out << u8(h.status & 0xFF) << u8((h.status >> 8) & 0xFF)
+	out << u8((h.status >> 16) & 0xFF) << u8((h.status >> 24) & 0xFF)
+	// Command (2 bytes LE)
+	cmd_code := h.command.code()
+	out << u8(cmd_code & 0xFF) << u8(cmd_code >> 8)
+	// CreditsRequested (2 bytes LE)
+	out << u8(h.credits_requested & 0xFF) << u8(h.credits_requested >> 8)
+	// Flags (4 bytes LE)
+	out << u8(h.flags & 0xFF) << u8((h.flags >> 8) & 0xFF)
+	out << u8((h.flags >> 16) & 0xFF) << u8((h.flags >> 24) & 0xFF)
+	// NextCommand (4 bytes) = 0
+	out << u8(0x00) << u8(0x00) << u8(0x00) << u8(0x00)
+	// MessageId (8 bytes LE)
+	for i in 0..8 { out << u8((h.message_id >> (u64(i) * 8)) & 0xFF) }
+	// Reserved / AsyncId / TreeId (4 bytes) = 0
+	out << u8(0x00) << u8(0x00) << u8(0x00) << u8(0x00)
+	// SessionId (8 bytes LE)
+	for i in 0..8 { out << u8((h.session_id >> (u64(i) * 8)) & 0xFF) }
+	// Signature (16 bytes)
+	for b in h.signature { out << b }
+	return out
+}
+
+// decode_smb2_header parses the first 64 bytes of a received SMB2 buffer.
+// Returns an error if the buffer is too short or the magic bytes are wrong.
+pub fn decode_smb2_header(data []u8) !Smb2Header {
+	if data.len < 64 {
+		return error('SMB2 header requires 64 bytes, got ${data.len}')
+	}
+	// Verify magic
+	if data[0] != 0xFE || data[1] != 0x53 || data[2] != 0x4D || data[3] != 0x42 {
+		return error('invalid SMB2 magic bytes: expected FE534D42')
+	}
+	mut pid := [4]u8{}
+	for i in 0..4 { pid[i] = data[i] }
+	credit_charge    := (u16(data[5]) << 8) | u16(data[4])
+	status           := u32(data[8]) | (u32(data[9]) << 8) | (u32(data[10]) << 16) | (u32(data[11]) << 24)
+	cmd_code         := u16(data[12]) | (u16(data[13]) << 8)
+	credits_req      := u16(data[14]) | (u16(data[15]) << 8)
+	flags            := u32(data[16]) | (u32(data[17]) << 8) | (u32(data[18]) << 16) | (u32(data[19]) << 24)
+	msg_id           := u64(data[24]) | (u64(data[25]) << 8) | (u64(data[26]) << 16) | (u64(data[27]) << 24) |
+	                    (u64(data[28]) << 32) | (u64(data[29]) << 40) | (u64(data[30]) << 48) | (u64(data[31]) << 56)
+	sess_id          := u64(data[40]) | (u64(data[41]) << 8) | (u64(data[42]) << 16) | (u64(data[43]) << 24) |
+	                    (u64(data[44]) << 32) | (u64(data[45]) << 40) | (u64(data[46]) << 48) | (u64(data[47]) << 56)
+	mut sig := [16]u8{}
+	for i in 0..16 { sig[i] = data[48 + i] }
+	command := match cmd_code {
+		u16(0x0000) { Smb2Command.negotiate }
+		u16(0x0001) { Smb2Command.session_setup }
+		u16(0x0003) { Smb2Command.tree_connect }
+		u16(0x0005) { Smb2Command.create }
+		u16(0x0006) { Smb2Command.close }
+		u16(0x0008) { Smb2Command.read }
+		u16(0x0009) { Smb2Command.write }
+		else         { return error('unknown SMB2 command code 0x${cmd_code:04X}') }
+	}
+	return Smb2Header{
+		protocol_id:       pid
+		header_length:     u16(64)
+		credit_charge:     credit_charge
+		status:            status
+		command:           command
+		credits_requested: credits_req
+		flags:             flags
+		message_id:        msg_id
+		session_id:        sess_id
+		signature:         sig
+	}
+}
+
 // --- Tests ---
 
 fn test_smb2_magic() {
@@ -284,3 +425,41 @@ fn test_parse_header_invalid_magic() {
 	assert false
 }
 
+fn test_negotiate_request_contains_dialect_311() {
+	pkt := encode_negotiate_request()
+	// Dialects start after the 64-byte header + 34 bytes of NEGOTIATE body prefix
+	// (StructureSize(2) + DialectCount(2) + SecurityMode(2) + Reserved(2) +
+	//  Capabilities(4) + ClientGuid(16) + NegotiateContextOffset(4) + DialectCount × 2)
+	// Check that 0x0311 appears somewhere in the last 6 bytes (3 dialects × 2 bytes)
+	last6 := pkt[pkt.len - 6..]
+	found_311 := (last6[4] == u8(smb2_dialect_311 & 0xFF) && last6[5] == u8(smb2_dialect_311 >> 8))
+	assert found_311
+}
+
+fn test_smb2_command_min_structure_size() {
+	assert Smb2Command.negotiate.min_structure_size()     == 36
+	assert Smb2Command.session_setup.min_structure_size() == 25
+	assert Smb2Command.create.min_structure_size()        == 57
+}
+
+fn test_encode_decode_smb2_header_roundtrip() {
+	hdr := Smb2Header{
+		protocol_id:       [u8(0xFE), 0x53, 0x4D, 0x42]!
+		header_length:     u16(64)
+		credit_charge:     u16(1)
+		status:            u32(0)
+		command:           .negotiate
+		credits_requested: u16(31)
+		flags:             u32(0)
+		message_id:        u64(1)
+		session_id:        u64(0)
+		signature:         [16]u8{}
+	}
+	wire := encode_smb2_header(hdr)
+	assert wire.len == 64
+	decoded := decode_smb2_header(wire) or { panic(err) }
+	assert decoded.command    == hdr.command
+	assert decoded.message_id == hdr.message_id
+	assert decoded.protocol_id[0] == u8(0xFE)
+}
+