client

import "github.com/TheManticoreProject/Manticore/network/smb/client"

const DefaultDialTimeout = 10 * time.Second

type Backend interface {
    // Dialect reports the negotiated protocol version this backend speaks.
    Dialect() smb.SMBProtocolVersion

    // ConnectionInfo reports the connection capabilities negotiated with the server
    // (signing requirement, maximum read/write sizes), normalized across dialects.
    ConnectionInfo() ConnectionInfo

    // Login authenticates a session with the server.
    Login(creds *credentials.Credentials) error

    // ServerIdentity reports the server identity (NetBIOS/DNS names, OS version)
    // learned during authentication. It is meaningful only after a successful Login;
    // fields are empty/zero otherwise or when the server did not advertise them.
    ServerIdentity() ServerIdentity

    // TreeConnect connects to a share by name (e.g. "C$"), making it the current
    // tree for subsequent file operations. The backend forms the full UNC path.
    TreeConnect(share string) error

    // OpenFile opens or creates a file on the current tree and returns a handle.
    OpenFile(path string, opts OpenOptions) (FileHandle, error)

    // ReadFile reads up to n bytes from the open file starting at off.
    ReadFile(h FileHandle, off uint64, n uint32) ([]byte, error)

    // WriteFile writes data to the open file starting at off and returns the
    // number of bytes written.
    WriteFile(h FileHandle, off uint64, data []byte) (uint32, error)

    // CloseFile closes a handle returned by OpenFile.
    CloseFile(h FileHandle) error

    // ListDirectory enumerates entries of a directory on the current tree that
    // match pattern (e.g. "*").
    ListDirectory(path, pattern string) ([]FileInfo, error)

    // QuerySecurityDescriptor returns the raw self-relative SECURITY_DESCRIPTOR
    // bytes for path on the current tree. info selects which parts (owner, group,
    // DACL, SACL) to retrieve. The bytes can be parsed with
    // github.com/TheManticoreProject/winacl.
    QuerySecurityDescriptor(path string, info SecurityInformation) ([]byte, error)

    // DeleteFile deletes a file on the current tree.
    DeleteFile(path string) error

    // CreateDirectory creates a directory on the current tree.
    CreateDirectory(path string) error

    // DeleteDirectory removes an empty directory on the current tree.
    DeleteDirectory(path string) error

    // RenameFile renames (or moves) a file or directory on the current tree. It
    // fails if newPath already exists.
    RenameFile(oldPath, newPath string) error

    // CheckDirectory returns nil if path names an existing directory on the
    // current tree, and an error otherwise.
    CheckDirectory(path string) error

    // RPCTransport opens a named pipe on the current tree (IPC$) and returns it as
    // a DCE/RPC PDU transport, framed for the negotiated dialect. It is the bridge
    // from the version-agnostic SMB client to the DCE/RPC stack, so callers can run
    // MS-RPC interfaces (srvsvc, lsarpc, …) without knowing whether SMB1 or SMB2 was
    // negotiated. The current tree must be IPC$.
    RPCTransport(pipeName string) (dcerpctransport.Transport, error)

    // TreeDisconnect disconnects the current tree.
    TreeDisconnect() error

    // Logoff tears down the authenticated session.
    Logoff() error

    // Disconnect closes the underlying transport connection.
    Disconnect() error
}

type Client struct {
    // contains filtered or unexported fields
}

func Dial(host string, port int, opts Options) (*Client, error)

package main

import (
	"fmt"
	"log"

	smbclient "github.com/TheManticoreProject/Manticore/network/smb/client"
	"github.com/TheManticoreProject/Manticore/windows/credentials"
	"github.com/TheManticoreProject/Manticore/windows/fileflags"
)

func main() {
	creds, err := credentials.NewCredentials("", "Administrator", "secret", "")
	if err != nil {
		log.Fatal(err)
	}

	// Empty Options: offer all supported versions, best first.
	c, err := smbclient.Dial("fileserver", 445, smbclient.Options{})
	if err != nil {
		log.Fatal(err)
	}
	defer c.Disconnect()

	if err := c.Login(creds); err != nil {
		log.Fatal(err)
	}
	fmt.Println("negotiated", c.Dialect())

	if err := c.TreeConnect("C$"); err != nil {
		log.Fatal(err)
	}
	defer c.TreeDisconnect()

	h, err := c.OpenFile(`Windows\win.ini`, smbclient.OpenOptions{
		DesiredAccess:     fileflags.GENERIC_READ | fileflags.FILE_READ_ATTRIBUTES,
		ShareAccess:       fileflags.FILE_SHARE_READ | fileflags.FILE_SHARE_WRITE,
		CreateDisposition: fileflags.FILE_OPEN,
		CreateOptions:     fileflags.FILE_NON_DIRECTORY_FILE,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer c.CloseFile(h)

	data, err := c.ReadFile(h, 0, 4096)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("read %d bytes\n", len(data))
}

package main

import (
	"fmt"
	"log"

	"github.com/TheManticoreProject/Manticore/network/smb"
	smbclient "github.com/TheManticoreProject/Manticore/network/smb/client"
)

func main() {
	c, err := smbclient.Dial("fileserver", 445, smbclient.Options{
		Preferred: []smb.SMBProtocolVersion{
			smb.SMB_VERSION_1_0,
			smb.SMB_VERSION_2_0_2,
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	defer c.Disconnect()
	fmt.Println("negotiated", c.Dialect())
}

func (c *Client) CheckDirectory(path string) error

func (c *Client) CloseFile(h FileHandle) error

func (c *Client) ConnectionInfo() ConnectionInfo

func (c *Client) CreateDirectory(path string) error

func (c *Client) DeleteDirectory(path string) error

func (c *Client) DeleteFile(path string) error

func (c *Client) Dialect() smb.SMBProtocolVersion

func (c *Client) Disconnect() error

func (c *Client) ListDirectory(path, pattern string) ([]FileInfo, error)

package main

import (
	"fmt"
	"log"

	smbclient "github.com/TheManticoreProject/Manticore/network/smb/client"
)

func main() {
	var c *smbclient.Client // obtained from Dial + Login + TreeConnect

	entries, err := c.ListDirectory("Windows", "*")
	if err != nil {
		log.Fatal(err)
	}
	for _, e := range entries {
		fmt.Printf("%s\tdir=%v\tsize=%d\n", e.Name, e.IsDir(), e.Size)
	}
}

func (c *Client) Login(creds *credentials.Credentials) error

func (c *Client) Logoff() error

func (c *Client) OpenFile(path string, opts OpenOptions) (FileHandle, error)

func (c *Client) QuerySecurityDescriptor(path string, info SecurityInformation) ([]byte, error)

func (c *Client) RPCTransport(pipeName string) (dcerpctransport.Transport, error)

func (c *Client) ReadFile(h FileHandle, off uint64, n uint32) ([]byte, error)

func (c *Client) RenameFile(oldPath, newPath string) error

func (c *Client) ServerIdentity() ServerIdentity

func (c *Client) TreeConnect(share string) error

func (c *Client) TreeDisconnect() error

func (c *Client) WriteFile(h FileHandle, off uint64, data []byte) (uint32, error)

type ConnectionInfo struct {
    // SigningRequired reports whether the server requires SMB message signing.
    SigningRequired bool
    // MaxReadSize is the largest read the server will accept, in bytes.
    MaxReadSize uint32
    // MaxWriteSize is the largest write the server will accept, in bytes.
    MaxWriteSize uint32
    // SupportsNTLMv2 reports whether the server advertised NTLM2 / extended session
    // security (NTLMv2) in its NTLM CHALLENGE. Meaningful only after Login.
    SupportsNTLMv2 bool
}

type FileHandle struct {
    // contains filtered or unexported fields
}

func (h FileHandle) Dialect() smb.SMBProtocolVersion

type FileInfo struct {
    Name           string
    FileAttributes uint32
    Size           uint64
    AllocationSize uint64
    CreationTime   time.Time
    LastAccessTime time.Time
    LastWriteTime  time.Time
    ChangeTime     time.Time
}

func (fi FileInfo) IsDir() bool

type NegotiationPolicy int

const (
    // PolicyStrictOrder tries the preferred versions in order and selects the
    // first one the server accepts. It honors the caller's order exactly — it
    // can select a lower dialect (e.g. SMB1) even when the server also supports
    // a higher one. Out-of-order lists may cost a reconnect per attempt.
    PolicyStrictOrder NegotiationPolicy = iota
    // PolicyHighestInSet performs a single multi-protocol negotiate over the
    // whole preference set and uses the server's highest-supported dialect
    // within it. One round-trip; the list acts as an allow-list rather than a
    // strict order.
    PolicyHighestInSet
)

type OpenOptions struct {
    DesiredAccess     uint32 // fileflags GENERIC_* / FILE_* access rights
    ShareAccess       uint32 // fileflags FILE_SHARE_*
    CreateDisposition uint32 // fileflags FILE_OPEN / FILE_CREATE / ...
    CreateOptions     uint32 // fileflags FILE_DIRECTORY_FILE / FILE_NON_DIRECTORY_FILE / ...
    FileAttributes    uint32 // fileflags FILE_ATTRIBUTE_*
}

type Options struct {
    // Preferred is the ordered list of protocol versions, highest priority
    // first. When empty, the client offers all supported versions, best first.
    Preferred []smb.SMBProtocolVersion
    // Policy selects how Preferred is applied. The zero value is
    // PolicyStrictOrder.
    Policy NegotiationPolicy
    // Workstation is the NetBIOS workstation name sent during authentication.
    // When empty, a default is used.
    Workstation string
    // DialTimeout bounds each connect/negotiate attempt during Dial, so that a
    // server which silently drops a probe (e.g. an SMB1-only host receiving an
    // SMB2 negotiate) fails the attempt instead of blocking forever, letting
    // PolicyStrictOrder move on to the next preferred version. The bound is
    // lifted once negotiation completes, so it does not constrain long-blocking
    // operations such as CHANGE_NOTIFY. Zero applies DefaultDialTimeout; a
    // negative value disables the bound.
    DialTimeout time.Duration
}

type SecurityInformation uint32

const (
    // OwnerSecurityInformation requests the owner SID.
    OwnerSecurityInformation SecurityInformation = 0x00000001
    // GroupSecurityInformation requests the primary-group SID.
    GroupSecurityInformation SecurityInformation = 0x00000002
    // DaclSecurityInformation requests the discretionary ACL.
    DaclSecurityInformation SecurityInformation = 0x00000004
    // SaclSecurityInformation requests the system ACL (requires extra privilege).
    SaclSecurityInformation SecurityInformation = 0x00000008
)

type ServerIdentity struct {
    NetBIOSComputerName string
    NetBIOSDomainName   string
    DNSComputerName     string
    DNSDomainName       string
    OSVersionMajor      uint8
    OSVersionMinor      uint8
    OSVersionBuild      uint16
    // OSName is the server's native OS string from the SMB1 SESSION_SETUP response.
    // It is populated for SMB1 only; SMB2/SMB3 do not transmit an OS name on the wire
    // (use the OSVersion* fields there).
    OSName string
}