What causes "Unsupport slow update type 0x%x" in shadow1ng/fscan?

Enable/accept fast-path update negotiation so graphics arrive via FastPathPDU instead of unsupported slow-path streamed updates

shadow1ng/fscan · error

Unsupport slow update type 0x%x

Error message

Unsupport slow update type 0x%x

What it means

UpdateDataPDU.Unpack in libs/grdp/protocol/pdu/data.go parses slow-path graphics update PDUs. When d.UpdateType is not one of the supported slow-update kinds (bitmap, orders, colormap, pointer, etc.), the function returns this error. It means the server sent a slow-path update subtype this client cannot render.

Source

Thrown at libs/grdp/protocol/pdu/data.go:530

	//slow path update
	d.UpdateType, err = core.ReadUint16LE(r)
	glog.Debugf("UpdateType 0x%02x", d.UpdateType)
	var p UpdateData
	switch d.UpdateType {
	case FASTPATH_UPDATETYPE_ORDERS:
	case FASTPATH_UPDATETYPE_BITMAP:
		p = &BitmapUpdateDataPDU{}
	case FASTPATH_UPDATETYPE_PALETTE:
	case FASTPATH_UPDATETYPE_SYNCHRONIZE:
	}
	if p != nil {
		err = p.Unpack(r)
		if err != nil {
			//glog.Error("Unpack:", err)
			return err
		}
	} else {
		return errors.New(fmt.Sprintf("Unsupport slow update type 0x%x", d.UpdateType))
	}

	d.Udata = p

	return nil
}

type BitmapUpdateDataPDU struct {
	NumberRectangles uint16 `struc:"little,sizeof=Rectangles"`
	Rectangles       []BitmapData
}

func (*BitmapUpdateDataPDU) FastPathUpdateType() uint8 {
	return FASTPATH_UPDATETYPE_BITMAP
}
func (f *BitmapUpdateDataPDU) Unpack(r io.Reader) error {
	var err error
	f.NumberRectangles, err = core.ReadUint16LE(r)

View on GitHub (pinned to 95cc12e753)

Solutions

Enable/accept fast-path update negotiation so graphics arrive via FastPathPDU instead of unsupported slow-path streamed updates
Add a case for the printed 0x%x update type in UpdateDataPDU.Unpack (or skip it) in data.go
Check for earlier desync — if every subsequent PDU fails too, the reader is misaligned; reconnect and inspect the previous PDU parse
Use a grdp version that implements the streamed bitmap update types your server sends

Defensive patterns

Strategy: try-catch

Try / catch

err := session.Run()
if err != nil {
    if strings.Contains(err.Error(), "Unsupport slow update type") {
        log.Printf("reconnecting to negotiate fast-path updates: %v", err)
        return reconnectWithFastPath()
    }
    return err
}

Prevention

Negotiate fast-path updates so heavy graphics avoid slow-path encoding
Set conservative capabilities (lossy bitmap compression off, no streamed updates) in client caps
Upgrade grdp to cover streamed bitmap update types
Reconnect on first occurrence — a single hit after clean start may be desync

When it happens

Trigger: Server sends an UpdateDataPDU with updateType outside the implemented switch — e.g. StreamBitmapOnly/StreamBitmapOther updates, or a corrupt type after stream misalignment — during the session update loop.

Common situations: Windows 8+/Server 2012+ servers preferring streamed/remotefx updates over classic slow-path bitmap updates; a previously misparsed PDU leaving the reader misaligned so an arbitrary byte becomes UpdateType; connecting with caps that fail to negotiate fast-path updates.

Related errors

AI-assisted analysis of shadow1ng/fscan@95cc12e753 (2026-09-06). Data as JSON: /api/errors/7ac280e30b9f7ae8. Report an issue: GitHub.