`dissect.target.helpers.sunrpc.serializer`¶

Module Contents¶

Classes¶

`MessageType`	Enum where members are also (and must be) ints
`Serializer`	Helper class that provides a standard way to create an ABC using
`Deserializer`	Helper class that provides a standard way to create an ABC using
`Int32Serializer`	Helper class that provides a standard way to create an ABC using
`UInt32Serializer`	Helper class that provides a standard way to create an ABC using
`OpaqueVarLengthSerializer`	Helper class that provides a standard way to create an ABC using
`StringSerializer`	Helper class that provides a standard way to create an ABC using
`XdrSerializer`	Abstract base class for generic types.
`XdrDeserializer`	Abstract base class for generic types.
`ReplyStat`	Enum where members are also (and must be) ints
`AuthFlavor`	Enum where members are also (and must be) ints
`AuthSerializer`	Abstract base class for generic types.
`AuthNullSerializer`	Abstract base class for generic types.
`AuthUnixSerializer`	Abstract base class for generic types.
`MessageSerializer`	Abstract base class for generic types.
`PortMappingSerializer`	Abstract base class for generic types.

Attributes¶

`ProcedureParams`
`ProcedureResults`
`Credentials`
`Verifier`
`Serializable`
`AuthProtocol`
`EnumType`
`ElementType`
`ALIGNMENT`

dissect.target.helpers.sunrpc.serializer.ProcedureParams¶

dissect.target.helpers.sunrpc.serializer.ProcedureResults¶

dissect.target.helpers.sunrpc.serializer.Credentials¶

dissect.target.helpers.sunrpc.serializer.Verifier¶

dissect.target.helpers.sunrpc.serializer.Serializable¶

dissect.target.helpers.sunrpc.serializer.AuthProtocol¶

dissect.target.helpers.sunrpc.serializer.EnumType¶

dissect.target.helpers.sunrpc.serializer.ElementType¶

class dissect.target.helpers.sunrpc.serializer.MessageType¶

Bases: enum.IntEnum

Enum where members are also (and must be) ints

CALL = 0¶

REPLY = 1¶

dissect.target.helpers.sunrpc.serializer.ALIGNMENT = 4¶

class dissect.target.helpers.sunrpc.serializer.Serializer¶

Bases: abc.ABC, Generic[Serializable]

Helper class that provides a standard way to create an ABC using inheritance.

abstract serialize(_: Serializable) → bytes¶

class dissect.target.helpers.sunrpc.serializer.Deserializer¶

Bases: abc.ABC, Generic[Serializable]

Helper class that provides a standard way to create an ABC using inheritance.

deserialize_from_bytes(payload: bytes) → Serializable¶

abstract deserialize(_: io.BytesIO) → Serializable¶

class dissect.target.helpers.sunrpc.serializer.Int32Serializer¶

Bases: Serializer[int], Deserializer[int]

Helper class that provides a standard way to create an ABC using inheritance.

serialize(i: int) → bytes¶

deserialize(payload: io.BytesIO) → int¶

class dissect.target.helpers.sunrpc.serializer.UInt32Serializer¶

Bases: Int32Serializer

Helper class that provides a standard way to create an ABC using inheritance.

class dissect.target.helpers.sunrpc.serializer.OpaqueVarLengthSerializer¶

Bases: Serializer[bytes], Deserializer[bytes]

Helper class that provides a standard way to create an ABC using inheritance.

serialize(body: bytes) → bytes¶

deserialize(payload: io.BytesIO) → bytes¶

class dissect.target.helpers.sunrpc.serializer.StringSerializer¶

Bases: Serializer[str], Deserializer[str]

Helper class that provides a standard way to create an ABC using inheritance.

serialize(s: str) → bytes¶

deserialize(payload: io.BytesIO) → str¶

class dissect.target.helpers.sunrpc.serializer.XdrSerializer¶

Bases: Generic[Serializable], Serializer[Serializable]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

class dissect.target.helpers.sunrpc.serializer.XdrDeserializer¶

Bases: Generic[Serializable], Deserializer[Serializable]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

class dissect.target.helpers.sunrpc.serializer.ReplyStat¶

Bases: enum.IntEnum

Enum where members are also (and must be) ints

MSG_ACCEPTED = 0¶

MSG_DENIED = 1¶

class dissect.target.helpers.sunrpc.serializer.AuthFlavor¶

Bases: enum.IntEnum

Enum where members are also (and must be) ints

AUTH_NULL = 0¶

AUTH_UNIX = 1¶

AUTH_SHORT = 2¶

AUTH_DES = 3¶

class dissect.target.helpers.sunrpc.serializer.AuthSerializer¶

Bases: Generic[AuthProtocol], XdrSerializer[AuthProtocol], XdrDeserializer[AuthProtocol]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

serialize(protocol: AuthProtocol) → bytes¶

deserialize(payload: io.BytesIO) → AuthProtocol¶

class dissect.target.helpers.sunrpc.serializer.AuthNullSerializer¶

Bases: AuthSerializer[dissect.target.helpers.sunrpc.sunrpc.AuthNull]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

class dissect.target.helpers.sunrpc.serializer.AuthUnixSerializer¶

Bases: AuthSerializer[dissect.target.helpers.sunrpc.sunrpc.AuthUnix]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

class dissect.target.helpers.sunrpc.serializer.MessageSerializer(params_serializer: XdrSerializer[ProcedureParams], results_deserializer: XdrDeserializer[ProcedureResults], credentials_serializer: AuthSerializer[Credentials], verifier_serializer: AuthSerializer[Verifier])¶

Bases: Generic[ProcedureParams, ProcedureResults, Credentials, Verifier], XdrSerializer[dissect.target.helpers.sunrpc.sunrpc.Message[ProcedureParams, ProcedureResults, Credentials, Verifier]], XdrDeserializer[dissect.target.helpers.sunrpc.sunrpc.Message[ProcedureParams, ProcedureResults, Credentials, Verifier]]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

serialize(message: dissect.target.helpers.sunrpc.sunrpc.Message[ProcedureParams, ProcedureResults, Credentials, Verifier]) → bytes¶

deserialize(payload: io.BytesIO) → dissect.target.helpers.sunrpc.sunrpc.Message[ProcedureParams, ProcedureResults, Credentials, Verifier]¶

class dissect.target.helpers.sunrpc.serializer.PortMappingSerializer¶

Bases: XdrSerializer[dissect.target.helpers.sunrpc.sunrpc.PortMapping]

Abstract base class for generic types.

A generic type is typically declared by inheriting from this class parameterized with one or more type variables. For example, a generic mapping type might be defined as:

class Mapping(Generic[KT, VT]):
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

This class can then be used as follows:

def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

serialize(port_mapping: dissect.target.helpers.sunrpc.sunrpc.PortMapping) → bytes¶

dissect.target.helpers.sunrpc.serializer¶

Module Contents¶

Classes¶

Attributes¶

`dissect.target.helpers.sunrpc.serializer`¶