403WebShell

403Webshell
Server IP : 172.67.201.108 / Your IP : 216.73.217.39
Web Server : Apache/2.4.68 (Amazon Linux) OpenSSL/3.5.5
System : Linux ip-172-31-69-123.ec2.internal 6.1.176-223.369.amzn2023.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Jul 24 13:34:27 UTC 2026 x86_64
User : ec2-user ( 1000)
PHP Version : 8.4.23
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /lib64/python3.9/site-packages/awscrt/__pycache__/
Upload File :
[ Back ]
Current File : /lib64/python3.9/site-packages/awscrt/__pycache__/cbor.cpython-39.opt-1.pyc
a

ů�i*`�@shddlZddlmZddlmZddlmZmZmZGdd�de�Z	Gdd�de�Z
Gd	d
�d
e�ZdS)�N)�NativeResource)�IntEnum)�Callable�Any�Unionc@sTeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdZdZdZdZdZdS)�AwsCborTypeaCBOR data type enumeration.

    Corresponds to `enum aws_cbor_type` in aws/common/cbor.h from AWS C Common Runtime.
    These values represent the different types of data items that can be encoded/decoded in CBOR format
    according to RFC 8949.

    Attributes:
        Unknown: Unknown/uninitialized type
        UnsignedInt: Unsigned integer (major type 0)
        NegativeInt: Negative integer (major type 1)
        Float: Floating-point number (major type 7, simple value 25/26/27)
        Bytes: Byte string (major type 2)
        Text: Text string (major type 3)
        ArrayStart: Start of definite-length array (major type 4)
        MapStart: Start of definite-length map (major type 5)
        Tag: Semantic tag (major type 6)
        Bool: Boolean value (major type 7, simple value 20/21)
        Null: Null value (major type 7, simple value 22)
        Undefined: Undefined value (major type 7, simple value 23)
        Break: Break stop code for indefinite-length items (major type 7, simple value 31)
        IndefBytes: Start of indefinite-length byte string (major type 2)
        IndefStr: Start of indefinite-length text string (major type 3)
        IndefArray: Start of indefinite-length array (major type 4)
        IndefMap: Start of indefinite-length map (major type 5)
    r���������	�
���
���N)�__name__�
__module__�__qualname__�__doc__ZUnknownZUnsignedIntZNegativeIntZFloatZBytes�TextZ
ArrayStartZMapStartZTagZBool�Null�	Undefined�Break�
IndefBytes�IndefStr�
IndefArray�IndefMap�r$r$�1/usr/lib64/python3.9/site-packages/awscrt/cbor.pyrs$rcseZdZdZ�fdd�Zed�dd�Zdd�Zed	�d
d�Z	e
d	�dd
�Zed	�dd�Ze
d	�dd�Zed�dd�Zed�dd�Zed�dd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zed	�d(d)�Ze
d	�d*d+�Zed	�d,d-�Zed	�d.d/�Ze d0�d1d2�Z!�Z"S)3�AwsCborEncoderaMCBOR encoder for converting Python objects to CBOR binary format.

    This class provides methods to encode various Python data types into CBOR (Concise Binary Object
    Representation) format as defined in RFC 8949. The encoder builds CBOR data incrementally by
    calling write_* methods in sequence.

    Thread Safety:
        This class is NOT thread-safe. Each encoder instance should only be used from a single thread.
        Create separate encoder instances for concurrent encoding operations.

    Memory Management:
        The encoder automatically manages internal memory and integrates with AWS CRT memory management.
        Call reset() to clear internal buffers for reuse, or let the encoder be garbage collected.

    Typical Usage:
        ```python
        encoder = AwsCborEncoder()
        encoder.write_int(42)
        encoder.write_text("hello")
        encoder.write_array_start(2)
        encoder.write_bool(True)
        encoder.write_null()
        cbor_data = encoder.get_encoded_data()
        ```

    For complex data structures, use write_data_item() which automatically handles nested objects:
        ```python
        encoder = AwsCborEncoder()
        data = {"numbers": [1, 2, 3], "text": "example", "flag": True}
        encoder.write_data_item(data)
        cbor_data = encoder.get_encoded_data()
        ```
    cst���t��|_dS�N)�super�__init__�_awscrtZcbor_encoder_new�_binding��self��	__class__r$r%r)[s
zAwsCborEncoder.__init__��returncCst�|j�S)zqReturn the current encoded data as bytes

        Returns:
            bytes: The encoded data currently
        )r*Zcbor_encoder_get_encoded_datar+r,r$r$r%�get_encoded_data_szAwsCborEncoder.get_encoded_datacCst�|j�S)a�Clear the encoder's internal buffer and reset to initial state.

        After calling this method, the encoder is ready to encode new data from scratch.
        Any previously encoded data is discarded and cannot be recovered.

        This is useful for reusing the same encoder instance to encode multiple
        independent CBOR documents without creating new encoder objects.

        Note:
            This operation does not raise exceptions and always succeeds.
        )r*Zcbor_encoder_resetr+r,r$r$r%�resetgszAwsCborEncoder.reset)�valcCs0|dkrt�|j|�Sd|}t�|j|�SdS)a�Write an int as cbor formatted,
            val less than -2^64 will be encoded as Negative bignum for CBOR
            val between -2^64 to -1, inclusive, will be encode as negative integer for CBOR
            val between 0 to 2^64 - 1, inclusive, will be encoded as unsigned integer for CBOR
            val greater than 2^64 - 1 will be encoded as Unsigned bignum for CBOR (Not implemented yet)

        Args:
            val (int): value to be encoded and written to the encoded data.
        r���N)r*Zcbor_encoder_write_uintr+Zcbor_encoder_write_negint)r-r4Z
val_to_encoder$r$r%�	write_intus
zAwsCborEncoder.write_intcCst�|j|�S)z�Write a double as cbor formatted
            Encodes as the most compact CBOR representation without loss of precision.

        Args:
            val (float): value to be encoded and written to the encoded data.
        )r*�cbor_encoder_write_floatr+�r-r4r$r$r%�write_float�szAwsCborEncoder.write_floatcCst�|j|�S)z�Write bytes as cbor formatted

        Args:
            val (bytes): value to be encoded and written to the encoded data.
        )r*Zcbor_encoder_write_bytesr+r8r$r$r%�write_bytes�szAwsCborEncoder.write_bytescCst�|j|�S)z�Write text as cbor formatted

        Args:
            val (str): value to be encoded and written to the encoded data.
        )r*Zcbor_encoder_write_textr+r8r$r$r%�
write_text�szAwsCborEncoder.write_text)�number_entriescCs,|dks|dkrt|�d���t�|j|�S)a<Add a start of array element.
            for a number of the cbor data items to be included in the array.
            `number_entries` should 0 to 2^64 inclusive.
            Otherwise, ValueError will be raised.

        Args:
            number_entries (int): number of entries in the array to be written
        r�� must be between 0 and 2^64)�
ValueErrorr*Zcbor_encoder_write_array_startr+�r-r<r$r$r%�write_array_start�s	z AwsCborEncoder.write_array_startcCs,|dks|dkrt|�d���t�|j|�S)aVAdd a start of map element, with the `number_entries`
            for the number of pair of cbor data items to be included in the map.
            `number_entries` should 0 to 2^64 inclusive.
            Otherwise, ValueError will be raised.

        Args:
            number_entries (int): number of entries in the map to be written
        rr=r>)r?r*Zcbor_encoder_write_map_startr+r@r$r$r%�write_map_start�s	zAwsCborEncoder.write_map_start)�
tag_numbercCs,|dks|dkrt|�d���t�|j|�S)aAdd a tag number.
        Notes: it's user's responsibility to keep the integrity of the tagged value to follow the RFC8949 section 3.4

        Args:
            tag_number (int): the tag number, refer to RFC8949 section 3.4 for the valid tag number.
        rr=r>)r?r*�cbor_encoder_write_tagr+)r-rCr$r$r%�	write_tag�szAwsCborEncoder.write_tagcCst�|jtj�S)zDAdd a simple value 22 as null. Refer to RFC8949 section 3.3
        )r*�cbor_encoder_write_simple_typesr+rrr,r$r$r%�
write_null�szAwsCborEncoder.write_nullcCst�|jtj�S)zIAdd a simple value 23 as undefined. Refer to RFC8949 section 3.3
        )r*rFr+rrr,r$r$r%�write_undefined�szAwsCborEncoder.write_undefinedcCst�|jtj�S)ztBegin an indefinite-length array. Must be closed with write_break().
        Refer to RFC8949 section 3.2.2
        )r*rFr+rr"r,r$r$r%�write_indef_array_start�sz&AwsCborEncoder.write_indef_array_startcCst�|jtj�S)zrBegin an indefinite-length map. Must be closed with write_break().
        Refer to RFC8949 section 3.2.2
        )r*rFr+rr#r,r$r$r%�write_indef_map_start�sz$AwsCborEncoder.write_indef_map_startcCst�|jtj�S)z�Begin an indefinite-length byte string. Must be followed by definite-length
        byte strings and closed with write_break().
        Refer to RFC8949 section 3.2.2
        )r*rFr+rr r,r$r$r%�write_indef_bytes_start�sz&AwsCborEncoder.write_indef_bytes_startcCst�|jtj�S)z�Begin an indefinite-length text string. Must be followed by definite-length
        text strings and closed with write_break().
        Refer to RFC8949 section 3.2.2
        )r*rFr+rr!r,r$r$r%�write_indef_text_start�sz%AwsCborEncoder.write_indef_text_startcCst�|jtj�S)zmWrite a break code (0xFF) to close an indefinite-length item.
        Refer to RFC8949 section 3.2.2
        )r*rFr+rrr,r$r$r%�write_break�szAwsCborEncoder.write_breakcCst�|j|�S)zMAdd a simple value 20/21 as false/true. Refer to RFC8949 section 3.3
        )r*Zcbor_encoder_write_boolr+r8r$r$r%�
write_bool�szAwsCborEncoder.write_boolcCst�|jd�t�|j|�S)z�Helper to write second-based epoch time as cbor formatted
        Args:
            val (float): second-based epoch time, float value to represent the precision less than 1 second.
        r)r*rDr+r7r8r$r$r%�write_epoch_time�szAwsCborEncoder.write_epoch_timecCst�|j|�S)z�Generic helper API to write the whole list as cbor formatted.
        The content of the list will be encoded as data_item.
        )r*Zcbor_encoder_write_py_listr+r8r$r$r%�
write_listszAwsCborEncoder.write_listcCst�|j|�S)z�Generic helper API to write the whole dict as cbor formatted.
        The content of the dict will be encoded as data_item.
        )r*Zcbor_encoder_write_py_dictr+r8r$r$r%�
write_dictszAwsCborEncoder.write_dict)�	data_itemcCst�|j|�S)a�Generic API to write any type of an data_item as cbor formatted.
        Specifically, it will be based on the type of data_item to decide how to encode it.
        The supported type of data_item are:
        - int
        - float
        - bool
        - bytes
        - str
        - list
        - dict

        Args:
            data_item (Any): any type of data_item. If the type is not supported to be converted to cbor format, ValueError will be raised.
        )r*Zcbor_encoder_write_data_itemr+)r-rRr$r$r%�write_data_item
szAwsCborEncoder.write_data_item)#rrrrr)�bytesr2r3�intr6�floatr9r:�strr;rArBrErGrHrIrJrKrLrM�boolrNrO�listrP�dictrQrrS�
__classcell__r$r$r.r%r&8s."

r&csDeZdZdZd/eeeeefge	fd��fdd�
Z
eeefe	d�dd�Zed	�d
d�Z
ed	�dd
�Zed	�dd�Zed�dd�Zdd�Zdd�Zed	�dd�Zed	�dd�Zed	�dd�Zed	�dd�Zed	�dd �Zed	�d!d"�Zed	�d#d$�Zed	�d%d&�Zed	�d'd(�Zed	�d)d*�Ze d	�d+d,�Z!e	d	�d-d.�Z"�Z#S)0�AwsCborDecodera�CBOR decoder for converting CBOR binary format to Python objects.

    This class provides methods to decode CBOR (Concise Binary Object Representation) binary data
    into Python data types as defined in RFC 8949. The decoder processes CBOR data sequentially
    using a peek-and-pop approach, allowing fine-grained control over the decoding process.

    Thread Safety:
        This class is NOT thread-safe. Each decoder instance should only be used from a single thread.
        Create separate decoder instances for concurrent decoding operations.

    Memory Management:
        The decoder holds a reference to the source data and automatically manages internal state.
        Use reset_src() to decode new data with the same decoder instance, or let the decoder
        be garbage collected when no longer needed.

    Decoding Workflow:
        The decoder uses a sequential peek-and-pop pattern:
        1. Use peek_next_type() to inspect the next data item type without consuming it
        2. Use appropriate pop_next_*() method to decode and consume the data item
        3. Repeat until all expected data is decoded
        4. Check get_remaining_bytes_len() to get the remaining unprocessed data.

    Basic Usage:
        ```python
        # Decode simple values
        decoder = AwsCborDecoder(cbor_data)
        if decoder.peek_next_type() == AwsCborType.UnsignedInt:
            value = decoder.pop_next_unsigned_int()
        ```

    Generic Decoding:
        For automatic type detection and conversion, use pop_next_data_item():
        ```python
        decoder = AwsCborDecoder(cbor_data)
        python_object = decoder.pop_next_data_item()  # Automatically handles any CBOR type
        ```

    Complex Structures:
        ```python
        decoder = AwsCborDecoder(cbor_data)

        # Manually decode an array
        if decoder.peek_next_type() == AwsCborType.ArrayStart:
            array_length = decoder.pop_next_array_start()
            items = []
            for _ in range(array_length):
                items.append(decoder.pop_next_data_item())

        # Or use the convenience method
        array = decoder.pop_next_list()  # Handles both definite and indefinite arrays
        ```

    Tagged Values and Callbacks:
        Handle semantic tags (like timestamps) with custom processing:
        ```python
        def handle_timestamp(epoch_secs):
            return datetime.fromtimestamp(epoch_secs, tz=timezone.utc)

        decoder = AwsCborDecoder(cbor_data, on_epoch_time=handle_timestamp)
        timestamp = decoder.pop_next_data_item()  # Returns datetime object for tag 1
        ```

    Error Handling:
        The decoder raises exceptions for malformed data, type mismatches, and unexpected end-of-data.
        Always handle these exceptions in production code:
        ```python
        try:
            decoder = AwsCborDecoder(cbor_data)
            result = decoder.pop_next_data_item()
        except ValueError as e:
            print(f"CBOR decoding error: {e}")
        ```
    N)�src�
on_epoch_timecs(t���||_t�||�|_||_dS)a�Create an instance of AwsCborDecoder with the src data to be decoded.
        The src data should be a bytes of cbor formatted data.

        Args:
            src (bytes): the bytes of cbor formatted data to be decoded.
            on_epoch_time (Callable[[int, Any], Any], optional): Optional callback invoked once tags
                with id: 1, which is the epoch time, are encountered during decoding a data_item.

                The function should take the following arguments:
                    *   `epoch_secs` (int | float): the seconds since epoch.

                The function should return
                    *   `result` (Any): The PyObject the epoch time converted to.
        N)r(r)�_srcr*Zcbor_decoder_newr+�_on_epoch_time)r-r]r^�kwargsr.r$r%r)js
zAwsCborDecoder.__init__)�
epoch_secsr1cCs|jdur|�|�S|SdSr')r`)r-rbr$r$r%�_on_epoch_time_callback~s

z&AwsCborDecoder._on_epoch_time_callbackr0cCstt�|j��S)zPReturn the AwsCborType of the next data item in the cbor formatted data
        )rr*Zcbor_decoder_peek_typer+r,r$r$r%�peek_next_type�szAwsCborDecoder.peek_next_typecCst�|j�S)zEReturn the number of bytes not consumed yet of the src data.
        )r*�$cbor_decoder_get_remaining_bytes_lenr+r,r$r$r%�get_remaining_bytes_len�sz&AwsCborDecoder.get_remaining_bytes_lencCs4t�|j�}|dkrdSt|j�|}|j|d�S)aiReturn the remaining unprocessed CBOR data as bytes.

        This method returns a slice of the original source data that has not yet been
        consumed by the decoder. Useful for debugging, validation, or passing remaining
        data to another decoder instance.

        Returns:
            bytes: The remaining unprocessed CBOR data. Returns empty bytes (b'') if
                all data has been consumed.

        Warning:
            The returned bytes share memory with the original source data. Modifications
            to the source data after decoder creation may affect the returned bytes.
        r�N)r*rer+�lenr_)r-Zremaining_lengthZ	start_idxr$r$r%�get_remaining_bytes�s
z"AwsCborDecoder.get_remaining_bytes)r]cCs||_t�|j|�dS)z�Reset the src data to be decoded.
        Note: the previous src data will be discarded.
            Use `get_remaining_bytes` to fetch the remaining bytes if needed before invoking this function.
        N)r_r*Zcbor_decoder_reset_srcr+)r-r]r$r$r%�	reset_src�szAwsCborDecoder.reset_srccCst�|j�S)a�
        Consume the next single element, without the content followed by the element.

        As an example for the following cbor, this function will only consume the
        0xBF, "Start indefinite-length map", not any content of the map represented.
        The next element to decode will start from 0x63:

        0xbf6346756ef563416d7421ff
        BF         -- Start indefinite-length map
        63         -- First key, UTF-8 string length 3
            46756e --   "Fun"
        F5         -- First value, true
        63         -- Second key, UTF-8 string length 3
            416d74 --   "Amt"
        21         -- Second value, -2
        FF         -- "break"
        )r*Z!cbor_decoder_consume_next_elementr+r,r$r$r%�consume_next_single_element�sz*AwsCborDecoder.consume_next_single_elementcCst�|j�S)a-
        Consume the next data item, includes all the content within the data item.
        Specifically, it read extra for the types listed below:
        1. `AwsCborType.IndefArray`, `AwsCborType.IndefMap`, `AwsCborType.IndefBytes` and `AwsCborType.IndefStr`. It read until
            the `AwsCborType.Break` is read.
        2. `AwsCborType.ArrayStart` and `AwsCborType.MapStart`. It read the number of data items in the array/map.
        3. `AwsCborType.Tag`. It read the one extra data item as the value of the tag.

        As an example for the following cbor, this function will consume all the data
        as it's only one cbor data item, an indefinite map with 2 <key, value> pair:

        0xbf6346756ef563416d7421ff
        BF         -- Start indefinite-length map
        63         -- First key, UTF-8 string length 3
            46756e --   "Fun"
        F5         -- First value, true
        63         -- Second key, UTF-8 string length 3
            416d74 --   "Amt"
        21         -- Second value, -2
        FF         -- "break"
        )r*Z#cbor_decoder_consume_next_data_itemr+r,r$r$r%�consume_next_whole_data_item�sz+AwsCborDecoder.consume_next_whole_data_itemcCst�|j�S)z�Return and consume the next data item as unsigned int if it's a `AwsCborType.UnsignedInt`
        Otherwise, it will raise ValueError.
        )r*Z"cbor_decoder_pop_next_unsigned_intr+r,r$r$r%�pop_next_unsigned_int�sz$AwsCborDecoder.pop_next_unsigned_intcCst�|j�}d|S)a'Return and consume the next data item as negative int if it's a `AwsCborType.NegativeInt`
        Otherwise, it will raise ValueError.

        Note: CBOR stores negative integers as -(val + 1), so we convert back
        to the actual negative value by computing -(val + 1) = -1 - val.
        r5)r*Z"cbor_decoder_pop_next_negative_intr+)r-Zencoded_valr$r$r%�pop_next_negative_int�sz$AwsCborDecoder.pop_next_negative_intcCst�|j�S)z�Return and consume the next data item as float if it's a `AwsCborType.Float`
        Otherwise, it will raise ValueError.
        )r*Zcbor_decoder_pop_next_floatr+r,r$r$r%�pop_next_double�szAwsCborDecoder.pop_next_doublecCst�|j�S)z�Return and consume the next data item as bool if it's a `AwsCborType.Bool`
        Otherwise, it will raise ValueError.
        )r*Zcbor_decoder_pop_next_booleanr+r,r$r$r%�
pop_next_bool�szAwsCborDecoder.pop_next_boolcCst�|j�S)z�Return and consume the next data item as bytes if it's a `AwsCborType.Bytes`
        Otherwise, it will raise ValueError.
        )r*Zcbor_decoder_pop_next_bytesr+r,r$r$r%�pop_next_bytes�szAwsCborDecoder.pop_next_bytescCst�|j�S)z�Return and consume the next data item as text if it's a `AwsCborType.Text`
        Otherwise, it will raise ValueError.
        )r*Zcbor_decoder_pop_next_textr+r,r$r$r%�
pop_next_text�szAwsCborDecoder.pop_next_textcCst�|j�S)aFReturn and consume the next data item as int if it's a `AwsCborType.ArrayStart`
        Otherwise, it will raise ValueError.
        The return value is the number of date items followed as the content of the array.

        Notes: For indefinite-length, this function will fail with unexpected type. The designed way to
        handle indefinite-length array is:
        - Get `AwsCborType.IndefArray` from `peek_next_type`
        - call `consume_next_single_element` to pop the indefinite-length start.
        - Decode the next data item until `AwsCborType.Break` read.
        )r*Z!cbor_decoder_pop_next_array_startr+r,r$r$r%�pop_next_array_startsz#AwsCborDecoder.pop_next_array_startcCst�|j�S)a8Return and consume the next data item as int if it's a `AwsCborType.MapStart`
        Otherwise, it will raise ValueError.
        The return value is the number of paired date items followed as the content of the map.

        Notes: For indefinite-length, this function will fail with unexpected type.
        )r*Zcbor_decoder_pop_next_map_startr+r,r$r$r%�pop_next_map_start
sz!AwsCborDecoder.pop_next_map_startcCst�|j�S)aReturn and consume the next data item as int if it's a `AwsCborType.Tag`
        Otherwise, it will raise ValueError.

        The return value is the tag ID. Refer the RFC8949 section 3.4 for
        corresponding expected data item to follow by the tag id as value.
        )r*Zcbor_decoder_pop_next_tagr+r,r$r$r%�pop_next_tag_valszAwsCborDecoder.pop_next_tag_valcCst�|j�S)z�Return and consume the next data item as list if it's a `AwsCborType.ArrayStart` or `AwsCborType.IndefArray`
        Otherwise, it will raise ValueError.
        It consumes the all the content of the array as `pop_next_data_item`.
        )r*Zcbor_decoder_pop_next_py_listr+r,r$r$r%�
pop_next_listszAwsCborDecoder.pop_next_listcCst�|j�S)z�Return and consume the next data item as list if it's a `AwsCborType.MapStart` or `AwsCborType.IndefMap`
        Otherwise, it will raise ValueError.
        It consumes the all the content of the map as `pop_next_data_item`.
        )r*Zcbor_decoder_pop_next_py_dictr+r,r$r$r%�pop_next_map&szAwsCborDecoder.pop_next_mapcCst�|j�S)a6Generic API to decode cbor formatted data to a python object.
        This consumes the next data item and return the decoded object.
        The type of the python object will be based on the cbor data item type.
        a full map from the cbor data item type to the python object type is:
        - `AwsCborType.UnsignedInt` or `AwsCborType.NegativeInt` -> int
        - `AwsCborType.Float` -> float
        - `AwsCborType.Bytes` or `AwsCborType.IndefBytes` -> bytes
        - `AwsCborType.Text` or `AwsCborType.IndefStr` -> str
        - `AwsCborType.Null` or `AwsCborType.Undefined` -> none
        - `AwsCborType.Bool` -> bool
        - `AwsCborType.ArrayStart` or `AwsCborType.IndefArray` and all the followed data items in the array -> list
        - `AwsCborType.MapStart` or `AwsCborType.IndefMap` and all the followed data items in the map -> dict
        - `AwsCborType.Tag`: For tag with id 1, as the epoch time, it invokes the _on_epoch_time for python to convert to expected type.
                             For the reset tag, exception will be raised.
        )r*Zcbor_decoder_pop_next_data_itemr+r,r$r$r%�pop_next_data_item-sz!AwsCborDecoder.pop_next_data_item)N)$rrrrrTrrrUrVrr)rcrrdrfrirjrkrlrmrnrorXrprqrWrrrsrtrurYrvrZrwrxr[r$r$r.r%r\s*J(

		r\)r*Zawscrtr�enumr�typingrrrrr&r\r$r$r$r%�<module>s-h
Youez - 2016 - github.com/yon3zu
LinuXploit