3

\��h��@s6dd
lZdd
l
Z
dd
lZddlmZ
Gdd�d�Zd
S)�N)
�Pathc@s|eZ
dZd
ZgZgZdZdZdZdd�Z	dd�Z
dd	�Zd
d�Zdd
�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�ZdS)�SoSMapz�Standardized way to store items with their obfuscated counterparts.

    Each type of sanitization that SoSCleaner supports should have a
    corresponding SoSMap() object, to allow for easy retrieval of obfuscated
    items.
    TFcCsJi|_t
�|_g|_|jjj�|_|
|_t	j
j|jd
|j�|_|j
�
dS)NZ
cleaner_cache)�dataset�set�
_regexes_made�compiled_regexes�	__class__�__name__�lowerZcname�workdir�os�path�join�	cache_dir�load_entries)�selfr�r�/usr/lib/python3.6/__init__.py�__init__ s







zSoSMap.__init__c

Cs"t|j
�
jd
d
d�
|jd�

dS)ai Load cached entries from the disk. This method must be called when
        we initialize a Map instance and whenever we want to retrieve
        self.dataset (e.g. to store default_mapping file). The later is
        essential since a concurrent Map can add more objects to the cache,
        so we need to update self.dataset up to date.

        Keep in mind that size of self.dataset is usually bigger than number
        of files in the corresponding cleaner's directory: directory contains
        just whole items (e.g. IP addresses) while dataset contains more
        derived objects (e.g. subnets).
        T)�parents�exist_ok�
N)rr�mkdir�load_new_entries_from_dir)
rrrrr,s

zSoSMap.load_entriescCs\|
s0|
|jks0|
|j
j�ks0|jr4t|
�
d
k
r4dSx"|jD]}tj||
tj�r<dSq<WdS)z�Some items need to be completely ignored, for example link-local or
        loopback addresses should not be obfuscated
        �TF)	�	skip_keysr�values�ignore_short_items�len�ignore_matches�re�match�
I)r�item�skiprrr�ignore_item<s





zSoSMap.ignore_itemcCsHy|j|
�
|j
|
<Wntk
r2


|
|j
|
<YnX|jrD|j|
�

dS)
N)�
sanitize_itemr�	Exception�compile_regexes�add_regex_item)rr#rrr�add_sanitised_item_to_datasetHs





z$SoSMap.add_sanitised_item_to_datasetc
Cs�d
}x�|dkr�tj
j|j|
��}xhtj
j|�
r�d
}t|ddd��}|j�}WdQRX|jj|d�sl|j	|�

|
d7}
tj
j|j|
��}q"W|d8}|
d7}
qWdS)N�r
�
rzutf-8)
�encodingFr)
rr
rr�isfile�open�readr�getr*)r�counterZno_files_cntZfname�
fr#rrrrPs












z SoSMap.load_new_entries_from_dircCs�|j|
�
r|
Sd
}x�|j
j|
d�s�|sZtj|jd�
}t|jddd��}|j|
�

Wd
QRXy8t	|j
�
d}t
j|jt
jj
|j|���
|j|
�

Wqtk
r�


|j|�

YqXqW|j
|
S)z�Add a particular item to the map, generating an obfuscated pair
        for it.

        Positional arguments:

            :param item:        The plaintext object to obfuscate
        NF)
�dir�
wzutf-8)
r-r)r%rr1�tempfileZNamedTemporaryFilerr/�name�writerr�linkr
rr*�FileExistsErrorr)rr#Ztmpfiler3r2rrr�addfs 













z
SoSMap.addcCsR|j|
�
rd
S|
|j
krN|j
j|
�

|jj|
|j|
�
f�

|jjdd�dd�
d
S)z�Add an item to the regexes dict and then re-sort the list that the
        parsers will use during parse_line()

        :param item:    The unobfuscated item to generate a regex for
        :type item:     ``str``
        Nc

Sst|d
�
S)Nr
)
r)
�
xrrr�<lambda>�sz'SoSMap.add_regex_item.<locals>.<lambda>T)�key�reverse)r%rr;r�append�get_regex_result�sort)rr#rrrr)�s




zSoSMap.add_regex_itemcCs2|jrd
t
j|
�
�d�}
n
t
j|
�
}
t
j|
t
j�S)a9Generate the object/value that is used by the parser when iterating
        over pre-generated regexes during parse_line(). For most parsers this
        will simply be a ``re.Pattern()`` object, but for more complex parsers
        this can be overridden to provide a different object, e.g. a tuple,
        for that parer's specific iteration needs.

        :param item:    The unobfuscated string to generate the regex for
        :type item:     ``str``

        :returns:       A compiled regex pattern for the item
        :rtype:         ``re.Pattern``
        z
(?<![a-z0-9])z
(?=\b|_|-))�match_full_words_onlyr �escape�compiler")rr#rrrrA�s



zSoSMap.get_regex_resultc
Cs|
S)
z�Perform the obfuscation relevant to the item being added to the map.

        This should be overridden by each type of map that subclasses SoSMap

        Positional arguments:

            :param item:        The plaintext object to obfuscate
        r)rr#rrrr&�s	zSoSMap.sanitize_itemcCs,|j|
�
r|
S|
|j
kr"|j|
�
S|j
|
S)
z�Retrieve an item's obfuscated counterpart from the map. If the item
        does not yet exist in the map, add it by generating one on the fly
        )r%rr;)rr#rrrr1�s







z
SoSMap.getcCs|jj
|
�

d
S)a%
Update the map using information from a previous run to ensure that
        we have consistent obfuscation between reports

        Positional arguments:

            :param config:    A dict of mappings with the form of
                              {clean_entry: 'obfuscated_entry'}
        N)r�update)r�configrrr�conf_update�s	zSoSMap.conf_updateN)r	�
__module__�__qualname__�__doc__rrr(rrCrrr%r*rr;r)rAr&r1rHrrrrrs"



r)r rr6Zpathlibrrrrrr�<module>s