| Server IP : 216.238.111.58 / Your IP : 216.73.217.34 Web Server : LiteSpeed System : Linux hosting.smartskills.com.br 4.18.0-553.120.1.el8_10.x86_64 #1 SMP Mon Apr 20 18:04:27 EDT 2026 x86_64 User : skillsitcom ( 1002) PHP Version : 8.3.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /lib/python3.6/site-packages/sos/cleaner/mappings/__pycache__/ |
Upload File : |
3
ܓ�i./ � @ s6 d dl Z d dlmZ G dd� de�ZG dd� d�ZdS )� N)�SoSMapc @ sH e Zd ZdZi ZddddgZdgZdZdZd d
� Z d d � Z
ddd�Z dS )�
SoSIPv6Mapat Mapping for IPv6 addresses and networks.
Much like the IP map handles IPv4 addresses, this map is designed to take
IPv6 strings and obfuscate them consistently to maintain network topology.
To do this, addresses will be manipulated by the ipaddress library.
If an IPv6 address is encountered without a netmask, it is assumed to be a
/64 address.
z^::1/.*z::/0zfd53:.*z^53..:�534fF� c C s� d|kr dS x�|d D ]|}t j|�}|d | d }| j||�}|j| j|j< xB|d | d D ].}|d | d | }|j||� || j|< q`W qW dS )z�Override the base conf_update() so that we can load the existing
networks into ObfuscatedIPv6Network() objects for the current run.
�networksN�
obfuscated�hosts)� ipaddress�
ip_network� _get_network�obfuscated_address�dataset�original_address�add_obfuscated_host_address)�self�configZnetworkZ_origZ _obfuscated�_net�host�_ob_host� r � /usr/lib/python3.6/ipv6_map.py� conf_update) s
zSoSIPv6Map.conf_updatec C s� d|kr|j d�d nd}|}|s*|d7 }y tj|�}| j|�}|j}W nd tk
r� tj|dd�}| j|�}|j| jkr�|j| j|j< tj |j d�d �}|j
|�}Y nX |r�d|kr�|� d|� �S |S ) N�/r � z/64F)�strictr ���) �splitr r
r r �
ValueError� network_addrr
r Z
ip_address�obfuscate_host_address)r �item�_prefixZ_ipaddr�_addrr Z _hostaddrr r r �
sanitize_item9 s$
zSoSIPv6Map.sanitize_itemr c C s. |j }|| jkr$t||| j�| j|< | j| S )z�Attempt to find an existing ObfuscatedIPv6Network object from which
to either find an existing obfuscated match, or create a new one. If
no such object already exists, create it.
)�
compressedr �ObfuscatedIPv6Network� first_hexes)r Zaddressr r" r r r r V s
zSoSIPv6Map._get_networkN)r ) �__name__�
__module__� __qualname__�__doc__r Zignore_matchesr& Zcompile_regexes�versionr r# r r r r r r s r c @ sn e Zd ZdZi Zddd�Zedd� �Zedd � �Zd
d � Z d d
� Z
dd� Z dd� Z dd� Z
dd� Zdd� ZdS )r% a� An abstraction class that represents a network that is (to be) handled
by sos.
Each distinct IPv6 network that we encounter will have a representative
instance of this class, from which new obfuscated subnets and host
addresses will be generated.
This class should be built from an ``ipaddress.IPv6Network`` object. If
an obfuscation string is not passed, one will be created during init.
r Nc C s� t |tj�std��|| _|j| _|jj| _ i | _
|dkrDdg| _ n|| _ |sZ| j � | _
n,t |t�svtdt|�� ���|jd�d | _
dS )a� Basic setup for the obfuscated network. Minor validation on the addr
used to create the instance, as well as on an optional ``obfuscation``
which if set, will serve as the obfuscated_network address.
:param addr: The *un*obfuscated network to be handled
:type addr: ``ipaddress.IPv6Network``
:param obfuscation: An optional pre-determined string representation of
the obfuscated network address
:type obfuscation: ``str``
:param used_hexes: A list of already used hexes for the first hextet
of a potential global address obfuscation
:type used_hexes: ``list``
z*Invalid network: not an IPv6Network objectNr z;Pre-determined obfuscated network address must be str, not r r )�
isinstancer Z IPv6Network� Exception�addrZ prefixlen�prefixZnetwork_addressr$ r r r& �_obfuscate_network_address�_obfuscated_network�str� TypeError�typer )r r. Z obfuscationZ
used_hexesr r r �__init__q s
z ObfuscatedIPv6Network.__init__c C s | j � d| j� �S )Nr )r1 r/ )r r r r r � s z(ObfuscatedIPv6Network.obfuscated_addressc C s | j jS )N)r. r$ )r r r r r � s z&ObfuscatedIPv6Network.original_addressc s � fdd�|D �S )a# Generate a set of obfuscated hextets, based on the length of the
source hextet. If any hextets are compressed, keep that compression.
E.G. '::1234:bcd' will generate a leading empty '' hextet, followed by
two 4-character hextets, e.g. '::0005:0006'.
:param hextets: The extracted hextets from a source address
:type hextets: ``list``
:returns: A set of generated hextets for use in an obfuscated
address
:rtype: ``list``
c s g | ]}|r� j d �nd�qS )� r )�
obfuscate_hex)�.0�h)r r r �
<listcomp>� s z:ObfuscatedIPv6Network.generate_hextets.<locals>.<listcomp>r )r Zhextetsr )r r �generate_hextets� s z&ObfuscatedIPv6Network.generate_hextetsc C s, | j j|d�d }|| j |< |d|� d��S )a� Generate a string of size length of hex characters. Due to the need
of deterministic generation in concurrent cleaner, generation starts
from zero values and is incremented by one (for a given length).
:param length: The number of characters to generate
:type length: ``int``
:returns: A string of ``length`` hex characters
:rtype: ``str``
r r �0�x)� ob_counters�get)r Zlength�valr r r r7 � s
z#ObfuscatedIPv6Network.obfuscate_hexc C s4 | j jr| j� S | j jr | jS | j jr.| j� S | jS )z�Generate the obfuscated pair for the network address. This is
determined based on the netmask of the network this class was built
on top of.
)r. Z is_global�_obfuscate_global_addressZ
is_link_localr Z
is_private�_obfuscate_private_address)r r r r r0 � s z0ObfuscatedIPv6Network._obfuscate_network_addressc C s� | j jd�dd� }dg}tdd� |D ��r�dt| j�d }|� | jd �� �}x || jkrp|� | jd �� �}qRW | jj|� |g}| j|�}|j|� dj |�S )
a Global unicast addresses have a 48-bit global routing prefix and a
16-bit subnet. We set the global routing prefix to a static
sos-specific identifier that could never be seen in the wild,
'534f:'
We then obfuscate the subnet hextet.
�:r Nr c s s | ] }| V qd S )Nr )r8 �cr r r � <genexpr>� s zBObfuscatedIPv6Network._obfuscate_global_address.<locals>.<genexpr>�5 � � )
r r �all�lenr& r7 �appendr; �extend�join)r �_hextets�_ob_hexZ_startZextr r r rA � s
z/ObfuscatedIPv6Network._obfuscate_global_addressc C s4 | j jd�dd� }dg}|j| j|�� dj|�S )a The first 8 bits will always be 'fd', the next 40 bits are meant
to be a global ID, followed by 16 bits for the subnet. To keep things
relatively simply we maintain the first hextet as 'fd53', and then
obfuscate any remaining hextets.
rC r NZfd53)r r rL r; rM )r rN rO r r r rB � s z0ObfuscatedIPv6Network._obfuscate_private_addressc sz � fdd�}|j � jkrn� jjd�}|j t|�d� jd�}||�}x|� jj� kr^||�}qFW � j|j |� � j|j S )a� Given an unobfuscated address, generate an obfuscated match for it,
and save it to this network for tracking during the execution of clean.
Note: another way to do this would be to convert the obfuscated network
to bytes, and add a random amount to that based on the number of
addresses that the network can support and from that new bytes count
craft a new IPv6 address. This has the advantage of absolutely
guaranteeing the new address is within the network space (whereas the
method employed below could *theoretically* generate an overlapping
address), but would in turn remove any ability to compress obfuscated
addresses to match the general format/syntax of the address it is
replacing. For the moment, it is assumed that being able to maintain a
quick mental note of "unobfuscated device ff00::1 is obfuscated device
53ad::a1b2" is more desireable than "ff00::1 is now obfuscated as
53ad::1234:abcd:9876:a1b2:".
:param addr: The unobfuscated IPv6 address
:type addr: ``ipaddress.IPv6Address``
:returns: An obfuscated address within this network
:rtype: ``str``
c s" dj � jdj � j| jd���g�S )Nr rC )rM r1 r; r )r )r r r �_generate_address s zGObfuscatedIPv6Network.obfuscate_host_address.<locals>._generate_addressrC N)r$ r r �rstriprJ �lstrip�valuesr )r r. rP Z_nZ_hostr r )r r r � s z,ObfuscatedIPv6Network.obfuscate_host_addressc C s || j |< dS )zjAdds an obfuscated pair to the class for tracking and ongoing
consistency in obfuscation.
N)r )r r r r r r r s z1ObfuscatedIPv6Network.add_obfuscated_host_address)r N)r' r( r) r* r> r5 �propertyr r r; r7 r0 rA rB r r r r r r r% b s
" 'r% )r Zsos.cleaner.mappingsr r r% r r r r �<module> s R