Your IP : 216.73.217.13
U
���b�� � @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ d dlmZ d dl m
Z
d dl m Z d dl
mZ d dlmZ d dlmZ d d lmZ d d
lmZ d d lmZ d d lmZmZm Z m Z d d
l m Z m Z d dl!m"Z" d dl#m$Z$ d dl%m&Z& G dd� de�Z'dS )� N)�ThreadPoolExecutor)�datetime)�getpwuid)� __version__)� SoSComponent)� SoSIPParser)� SoSMacParser)�SoSHostnameParser)�SoSKeywordParser)�SoSUsernameParser)�SoSReportArchive�SoSReportDirectory�SoSCollectorArchive�SoSCollectorDirectory)�DataDirArchive�TarballArchive)�InsightsArchive)�get_human_readable)�fillc sH e Zd ZdZdZdg g dg dddddg d � ZdH� fd
d � ZdId d
�ZdJdd�ZdKdd�Z dLdd�Z
dd� Z e dd� �Z
dd� Zdd� Ze d d � �Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� ZdMd.d/�Zd0d1� Zd2d3� Zd4d5� Z d6d7� Z d8d9� Z d:d;� Z dNd<d=�Z d>d?� Z!d@dA� Z"dBdC� Z#dOdDdE�Z$dFdG� Z%� Z&S )P�
SoSCleanera�
This function is designed to obfuscate potentially sensitive information
from an sos report archive in a consistent and reproducible manner.
It may either be invoked during the creation of a report by using the
--clean option in the report command, or may be used on an already existing
archive by way of 'sos clean'.
The target of obfuscation are items such as IP addresses, MAC addresses,
hostnames, usernames, and also keywords provided by users via the
--keywords and/or --keyword-file options.
For every collection made in a report the collection is parsed for such
items, and when items are found SoS will generate an obfuscated replacement
for it, and in all places that item is found replace the text with the
obfuscated replacement mapped to it. These mappings are saved locally so
that future iterations will maintain the same consistent obfuscation
pairing.
In the case of IP addresses, support is for IPv4 and efforts are made to
keep network topology intact so that later analysis is as accurate and
easily understandable as possible. If an IP address is encountered that we
cannot determine the netmask for, a random IP address is used instead.
For hostnames, domains are obfuscated as whole units, leaving the TLD in
place.
For instance, 'example.com' may be obfuscated to 'obfuscateddomain0.com'
and 'foo.example.com' may end up being 'obfuscateddomain1.com'.
Users will be notified of a 'mapping' file that records all items and the
obfuscated counterpart mapped to them for ease of reference later on. This
file should be kept private.
z6Obfuscate sensitive networking information in a report�auto� N� /etc/sos/cleaner/default_mappingF� ) � archive_type�domains�disable_parsers�jobs�keywords� keyword_file�map_file� no_update�keep_binary_files�target� usernamesc s� |s t t| ��|||� d| _n�|d | _|d | _|d | _|d | _|d | _d| _t | jd�sld | j_
d
| j_ t �
d �| _t �
d �| _tjtj�| jd
�dd� | �� | _t�d� || _| j�� | _| jj�d
�| _ t | j| jj �t | j�t | j�t!| j| jj"| jj#�t$| j| jj%�g| _&| jj'D ]h}| j&D ]Z}|j(�)� �*d�d �+� }|�)� �+� |k�r4| �,d| � | j�-d| � | j&�.|� �q4�q*t/t0t1t2t3t4t5g| _6d | _7| �,d| j � d S )NTZoptions�tmpdir�sys_tmp�policy�manifestFr r r �sosZsos_uiZcleaner��exist_ok�? �parserr zDisabling parser: %szaDisabling the '%s' parser. Be aware that this may leave sensitive plain-text data in the archive.z%Cleaner initialized. From cmdline: %s)8�superr �__init__� from_cmdline�optsr% r& r' r( �hasattrr r �loggingZ getLogger�soslog�ui_log�os�makedirs�path�join�
load_map_fileZcleaner_mapping�umask�in_placeZget_preferred_hash_name� hash_nameZ
components� add_section�
cleaner_mdr r r r r
r r r r$ �parsersr �name�lower�split�strip�log_info�warn�remover
r r r r r r �
archive_types�nested_archive) �selfr- �argsZcmdliner< Z hook_commons�_parserZ_loadedZ _loaded_name�� __class__� �6/usr/lib/python3/dist-packages/sos/cleaner/__init__.pyr/ Y sf
��
���
�zSoSCleaner.__init__c C s d|rd| nd|f S )Nz[cleaner%s] %sz:%sr rO �rJ �msg�callerrO rO rP � _fmt_log_msg� s zSoSCleaner._fmt_log_msgc C s | j �| �||�� d S �N)r4 �debugrT rQ rO rO rP � log_debug� s zSoSCleaner.log_debugc C s | j �| �||�� d S rU )r4 �inforT rQ rO rO rP rE � s zSoSCleaner.log_infoc C s | j �| �||�� d S rU )r4 �errorrT rQ rO rO rP � log_error� s zSoSCleaner.log_errorc C s0 d}d}|� � D ]}|t||dd� d }q|S )N�P r F)Zreplace_whitespace�
)�
splitlinesr )rJ rR �widthZ_fmt�linerO rO rP �_fmt_msg� s
zSoSCleaner._fmt_msgc C s |� d� |�| j� d S )NzSoS Cleaner Detailed Help)Z set_titleZadd_text�__doc__)�clsZsectionrO rO rP � display_help� s
zSoSCleaner.display_helpc C s� i }d}t j�| jj�r(td| jj ��t j�| jj�sX| jj|kr�| �d| jj � n�t| jjd��l}zt �
|�}W nV t j k
r� | �d� Y n8 tk
r� } z| �d| jj|f � W 5 d}~X Y nX W 5 Q R X |S )z�Verifies that the map file exists and has usable content.
If the provided map file does not exist, or it is empty, we will print
a warning and continue on with cleaning building a fresh map
r z$Requested map file %s is a directoryzHERROR: map file %s does not exist, will not load any obfuscation matches�rzOERROR: Unable to parse map file, json is malformed. Will not load any mappings.z ERROR: Could not load '%s': %sN) r6 r8 �isdirr1 r � Exception�existsrZ �open�json�loadZJSONDecodeError)rJ Z_confZ default_map�mf�errrO rO rP r: � s. � ��
�"zSoSCleaner.load_map_filec
C s� | � d�}| j�dt � | j�|� | jjs�z td� W nV tk
rd | j�d� | �d� Y n. t k
r� } z| �d|� W 5 d}~X Y nX dS )z�When we are directly running `sos clean`, rather than hooking into
SoSCleaner via report or collect, print a disclaimer banner
a� This command will attempt to obfuscate information that is generally considered to be potentially sensitive. Such information includes IP addresses, MAC addresses, domain names, and any user-provided keywords.
Note that this utility provides a best-effort approach to data obfuscation, but it does not guarantee that such obfuscation provides complete coverage of all such data in the archive, or that any obfuscation is provided to data that does not fit the description above.
Users should review any resulting data and/or archives generated or processed by this utility for remaining sensitive content before being passed to a third party.
z
sos clean (version %s)
z-
Press ENTER to continue, or CTRL-C to quit.
z
Exiting on user cancel� � N)
r` r5 rX r r1 Zbatch�input�KeyboardInterrupt�_exitrf )rJ rR �erO rO rP �print_disclaimer� s
zSoSCleaner.print_disclaimerc C s� d|_ |�dd�}|jdddd� |jdd d d
d d d
dgdd� |jddg dd� |jddg ddd� |jdddtd d � |jd dg d d d� |jd!d d"d#d$� |jd%d&d'd(d)� |jd*d+d,d-d.d/� |jd0d,d-d1d2d3� |jd4d5g dd6d/� d S )7Nz sos clean|mask TARGET [options]zCleaner/Masking Optionsz7These options control how data obfuscation is performedr# ZTARGETz%The directory or archive to obfuscate)�metavar�helpz--archive-typer �reportZcollectZinsightszdata-dir�tarballz8Specify what kind of archive the target was generated as)�default�choicesru z --domains�extendz!List of domain names to obfuscate)�actionrx ru z--disable-parsersr zCDisable specific parsers, so that those elements are not obfuscated)r{ rx �destru z-jz--jobsr z&Number of concurrent archives to clean)rx �typeru z
--keywordsr z List of keywords to obfuscatez--keyword-filer z&Provide a file a keywords to obfuscate)rx r| ru z
--map-filer r z;Provide a previously generated mapping file for obfuscation)r| rx ru z --no-updater! F�
store_truez<Do not update the --map-file with new mappings from this run)r| rx r{ ru z--keep-binary-filesr" zGKeep unprocessable binary files in the archive instead of removing them)rx r{ r| ru z --usernamesr$ z List of usernames to obfuscate)ZusageZadd_argument_group� add_argument�int)rb r- Z clean_grprO rO rP �add_parser_options� sh �� ��
� � �
���
��
�z SoSCleaner.add_parser_optionsc C s || j _dS )z�For use by report and collect to set the TARGET option appropriately
so that execute() can be called just as if we were running `sos clean`
directly from the cmdline.
N)r1 r# )rJ r8 rO rO rP �set_target_path s zSoSCleaner.set_target_pathc C s� d}| j jdkrH| j j�dd�}| jD ] }|j|kr&|| j j| j�}q&n.| jD ]&}|�| j j�rN|| j j| j�} qvqN|s~dS | j� |� |j
r�| j� |� � � | j�
|� || _| jr�| jj| j_dS )z�The target path is not a directory, so inspect it for being an
archive or an archive of archives.
In the event the target path is not an archive, abort.
Nr �-�_)r1 r �replacerH Z type_namer# r% Z
check_is_type� report_paths�append� is_nestedrz Zget_nested_archivesrG rI Z descriptionZui_name)rJ �_arcZ
check_type�archive�arcrO rO rP �inspect_target_archive" s&
z!SoSCleaner.inspect_target_archivec C s@ | j j�d�d �d�d | _| jr,| �� g | _tj� | j j�s`| j
� d| j j � | � d� | �
� | js�| j
� d� | � d� g | _| �� | �� | �� | js�| jr�dS | j
�d � | � d� | j
�d
t| j� � | �� }| �|�}| �|� | �� | j�r"d d � | jD �}||fS d}t| j�dk�r@| �� }nx| jd }|j}| �|j�}|dk �r�| � d
|�d�d | j f �}t tj� | j |�d��} | �!|� W 5 Q R X | �"� | � tj� | j |�d�d ��}t#�$||� t�%|�}
t&d| � t&d| � t&dt'|
j(� � t&dt)|
j*�j+ � t&d� | �,� dS )a, SoSCleaner will begin by inspecting the TARGET option to determine
if it is a directory, archive, or archive of archives.
In the case of a directory, the default behavior will be to edit the
data in place. For an archive will we unpack the archive, iterate
over the contents, and then repack the archive. In the case of an
archive of archives, such as one from SoSCollector, each archive will
be unpacked, cleaned, and repacked and the final top-level archive will
then be repacked as well.
�/���z.tarr z,Invalid target: no such file or directory %srn z'No valid archives or directories found
Nz#No reports obfuscated, aborting...
z&
Successfully obfuscated %s report(s)
c S s g | ]
}|j �qS rO )�final_archive_path)�.0�arO rO rP �
<listcomp>n s z&SoSCleaner.execute.<locals>.<listcomp>z%s.%s�wz4A mapping of obfuscated elements is available at
%sz,
The obfuscated archive is available at
%s
z Size %sz
Owner %s
zcPlease send the obfuscated archive to your support representative and keep the mapping file private)-r1 r# rC �arc_namer0 rs r� r6 r8 rg r5 rY rq r� �completed_reports� preload_all_archives_into_maps� generate_parser_item_regexes�obfuscate_report_pathsr< rX �len�compile_mapping_dict�write_map_for_archive�write_map_for_config�write_stats_to_manifest�rebuild_nested_archiver� �get_new_checksum�obfuscate_stringr= rh r9 r& �write�write_cleaner_log�shutil�move�stat�printr �st_sizer �st_uidZpw_nameZcleanup) rJ �_map�map_pathZ arc_pathsZ
final_path�arc_pathr� �checksumZ chksum_nameZcfZarcstatrO rO rP �execute? st �
�
��
� zSoSCleaner.executec C s� | j d }| j|d� | jD ]F}|j�d�d }| �|j�}|dk r d|| jf }| jj||d� q t �
| j j �D ]X\}}}|D ]H} t j
�|| �}
|
�| j j �d }|�d�}| jj|
|d� t �|
� q�qr| jdd � | j�| jj�S )
z�Handles repacking the nested tarball, now containing only obfuscated
copies of the reports, log files, manifest, etc...
z -obfuscated)rA r� r� Nzchecksums/%s.%s�r| T)r� )r� Z
setup_archiver� r� rC r� r= r� Z
add_stringr6 �walkrI �extracted_pathr8 r9 �lstrip�add_filerG r� �finalizer1 Zcompression_type) rJ r� r� Zarc_destr� ZdnameZdirn�dirs�files�filename�fnamerO rO rP r� � s"
z!SoSCleaner.rebuild_nested_archivec C s2 i }| j D ]"}i ||j< ||j �|jj� q
|S )a Build a dict that contains each parser's map as a key, with the
contents as that key's value. This will then be written to disk in the
same directory as the obfuscated report so that sysadmins have a way
to 'decode' the obfuscation locally
)r@ Z map_file_key�update�mapping�dataset)rJ r� r- rO rO rP r� � s
z SoSCleaner.compile_mapping_dictc C s. t |d��}|�tj|dd�� W 5 Q R X |S )zjWrite the mapping to a file on disk that is in the same location as
the final archive(s).
r� r )�indent)rh r� ri �dumps)rJ r� r8 rk rO rO rP �write_map_to_file� s z SoSCleaner.write_map_to_filec
C sf z*t j�| j| �d| j ��}| �||�W S tk
r` } z| �d| � W Y �d S d }~X Y nX d S )Nz%s-private_mapz$Could not write private map file: %s) r6 r8 r9 r& r� r� r� rf rZ )rJ r� r� rl rO rO rP r� � s �z SoSCleaner.write_map_for_archivec
C s� | j jr�| j js�tj�| j j�}z4tj|dd� | �|| j j� | �d| j j � W n0 t k
r� } z| �
d| � W 5 d}~X Y nX dS )z}Write the mapping to the config file so that subsequent runs are
able to provide the same consistent mapping
Tr* zWrote mapping to %sz(Could not update mapping config file: %sN) r1 r r! r6 r8 �dirnamer7 r� rW rf rZ )rJ r� Z cleaner_dirrl rO rO rP r� � s �z SoSCleaner.write_map_for_configc C st t j�| jd| j �}t|d��,}| j�d� | j�� D ]}|� |� q8W 5 Q R X |rp| �
|� | j j |dd� dS )z�When invoked via the command line, the logging from SoSCleaner will
not be added to the archive(s) it processes, so we need to write it
separately to disk
z%s-obfuscation.logr� r zsos_logs/cleaner.logr� N)
r6 r8 r9 r& r� rh Z sos_log_file�seek� readlinesr� �obfuscate_filer� r� )rJ r� Zlog_nameZlogfiler_ rO rO rP r� � s �
z SoSCleaner.write_cleaner_logc
C s� zLd}t |d�}t�| j�}|�|�}|s,q8|�|� q |�� |�� d W S tk
r| } z| � d| � W 5 d}~X Y nX dS )zvCalculate a new checksum for the obfuscated archive, as the previous
checksum will no longer be valid
i �rbr\ z#Could not generate new checksum: %sN)
rh �hashlib�newr= �readr� �closeZ hexdigestrf rW )rJ � archive_pathZ hash_sizeZ
archive_fpZdigestZhashdatarl rO rO rP r� � s
zSoSCleaner.get_new_checksumc C s� z�dt | j�| jjf }| j�|� | jjr8| j�d� t| jj�}|j | j
| jdd� |j dd� | j r~| �
� | �
| j � W n* tk
r� | j�d� t�d� Y nX d S )
z�Perform the obfuscation for each archive or sos directory discovered
during setup.
Each archive is handled in a separate thread, up to self.opts.jobs will
be obfuscated concurrently.
zFFound %s total reports to obfuscate, processing up to %s concurrently
zpWARNING: binary files that potentially contain sensitive information will NOT be removed from the final archive
rn )Z chunksizeT)�waitzExiting on user cancelrm N)r� r� r1 r r5 rX r" Zwarningr �map�obfuscate_reportZshutdownrI � _replace_obfuscated_archivesrp r6 rq )rJ rR ZpoolrO rO rP r� s& �� � z!SoSCleaner.obfuscate_report_pathsc C sV | j D ]J}t�|j� | jj}|j�d�d }tj� ||�}t
� |j|� ||_qdS )z�When we have a nested archive, we need to rebuild the original
archive, which entails replacing the existing archives with their
obfuscated counterparts
r� r� N) r� r6 rG r� rI r� r� rC r8 r9 r� r� )rJ r� r| rw Z dest_namerO rO rP r� s
z'SoSCleaner._replace_obfuscated_archivesc C s | j D ] }|�� qdS )z�For the parsers that use prebuilt lists of items, generate those
regexes now since all the parsers should be preloaded by the archive(s)
as well as being handed cmdline options and mapping file configuration.
N)r@ Zgenerate_item_regexes)rJ r- rO rO rP r� * s
z'SoSCleaner.generate_parser_item_regexesc
C sR | � d� | jD �]:}| jD �],}z$|j|j�� �� d }|sDW q W n ttfk
rb Y q Y nX t |t
�rt|g}|D ]�}| � d| � z~|� |�}|s�W qxt |t
�r�|�|� nRt |t�r�d|kr�|�|�� d � nd|kr�|�|� n|�� D ]}| �|� q�W qx tk
�rF } z | � d|j||j|f � W 5 d}~X Y qxX qxq qdS )a Before doing the actual obfuscation, if we have multiple archives
to obfuscate then we need to preload each of them into the mappings
to ensure that node1 is obfuscated in node2 as well as node2 being
obfuscated in node1's archive.
z.Pre-loading all archives into obfuscation mapsr zAttempting to load %sZhostnamez etc/hostsz.Could not prepare %s from %s (archive: %s): %sN)rE r� r@ Z
prep_filesrA rB rC �
IndexError�KeyError�
isinstance�strrW Zget_file_contentr Zload_usernames_into_mapr Zload_hostname_into_mapr] Z load_hostname_from_etc_hosts�obfuscate_linerf � archive_name)rJ r� rL ZpfileZ
parse_fileZcontentr_ rl rO rO rP r� 2 sL
��
���z)SoSCleaner.preload_all_archives_into_mapsc C s� �z|| j �|j�}t�� }|�d|� |js4|�� |�d� |� � D ]�}|�
|jd �d }|� |�rjqF| j j
s�|�|�r�|�|� qFz$| �|||j�}|r�|�||� W qF tk
r� } z| �d||f � W 5 d}~X Y qFX qFz| �|� W n8 tk
�r* } z| jd| |jd� W 5 d}~X Y nX z| �|� W n8 tk
�rr } z| jd | |jd� W 5 d}~X Y nX |j�s|�� }|�r|�d
� z |�| �|j�� |�|� W nN tk
�r } z.| �d |j|f � |�d | � W Y �W dS d}~X Y nX | j � |� t�� } |�d
| � |�d| | � |�dt |j �� |�d|j � d}
|j!�rnd}
|
|j! }
|�d|
� W n: tk
�r� } z| j"�#d|j|f � W 5 d}~X Y nX dS )z�Individually handle each archive or directory we've discovered by
running through each file therein.
Positional arguments:
:param report str: Filepath to the directory or archive
�
start_timezBeginning obfuscation...r� rn zUnable to parse file %s: %sNz#Failed to obfuscate directories: %s�rS z Failed to obfuscate symlinks: %szRe-compressing...z!Archive %s failed to compress: %sz!Failed to re-compress archive: %s�end_timeZrun_timeZfiles_obfuscatedZtotal_substitutionsr z! [removed %s unprocessable files]zObfuscation completed%sz!Exception while processing %s: %s)$r? r> r� r Znow� add_fieldZ is_extracted�extractZ
report_msgZ
get_file_listrC Zshould_skip_filer1 r" Zshould_remove_fileZ remove_filer� Zupdate_sub_countrf rW �obfuscate_directory_namesrE �obfuscate_symlinksr� Zget_compressionZrename_top_dirr� �compressr� r� r� Z
file_sub_listZtotal_sub_countZremoved_file_countr5 rX ) rJ r� Zarc_mdr� r� �
short_name�countrl �methodr� ZrmsgrO rO rP r� ^ s�
�
��
�
�
���
�zSoSCleaner.obfuscate_reportc s� |sdS d}� s |� d�d � tj�|��s | jd� p:||d� tjd| jd�}� fd d
�| jD �}t |d ��p}|D ]d}z&| �
||�\}} || 7 }|� |� W qv t k
r� }
z| jd � |
f |d� W 5 d}
~
X Y qvX qvW 5 Q R X |�
d� |�rt�|j|� |�� | �� � d�d �} � �� � d�d | �} | � k�r�|� � �d }
tj�|
| �}tj�|��sxt�||� n&| �t�|��}t�|� t�||� |S )
a5 Obfuscate and individual file, line by line.
Lines processed, even if no substitutions occur, are then written to a
temp file without our own tmpdir. Once the file has been completely
iterated through, if there have been substitutions then the temp file
overwrites the original file. If there are no substitutions, then the
original file is left in place.
Positional arguments:
:param filename str: Filename relative to the extracted
archive root
Nr r� r� zObfuscating %sr� r� )�mode�dirc s( g | ] }t � fd d�|jD ��s|�qS )c 3 s | ]}|� � �V qd S rU )�match)r� Z_skip�r� rO rP � <genexpr>� s z7SoSCleaner.obfuscate_file.<locals>.<listcomp>.<genexpr>)�anyZ
skip_patterns)r� Z_pr� rO rP r� � s
��z-SoSCleaner.obfuscate_file.<locals>.<listcomp>rd zUnable to obfuscate %s: %s)rC r6 r8 �islinkrW �tempfileZNamedTemporaryFiler% r@ rh r� r� rf r� r� �copyrA r� r� r� r9 �rename�readlinkrG �symlink)rJ r� r� r� ZsubsZtfileZ_parsersr� r_ r� rl Z_ob_short_nameZ _ob_filenamer� Z_ob_pathZ
_target_obrO r� rP r� � sT �
� ��$
�
zSoSCleaner.obfuscate_filec C s� | j d|jd� |�� D ]�}z~|�|j�d �d�}| jd| |jd� t�|�}tj �
|j| � |��}| � |�}||ks�||kr�t� |� t�
||� W q tk
r� } z| � d||f � W 5 d}~X Y qX qdS )a� Iterate over symlinks in the archive and obfuscate their names.
The content of the link target will have already been cleaned, and this
second pass over just the names of the links is to ensure we avoid a
possible race condition dependent on the order in which the link or the
target get obfuscated.
:param archive: The archive being obfuscated
:type archive: ``SoSObfuscationArchive``
zObfuscating symlink namesr� rn r� zObfuscating symlink %sz"Error obfuscating symlink '%s': %sN)rE r� Z get_symlinksrC r� r� rW r6 r� r8 r9 r� rG r� rf )rJ r� r� Z_symZ_targetZ _ob_sym_nameZ
_ob_targetrl rO rO rP r� � s&
�
�
�z SoSCleaner.obfuscate_symlinksc C s� | � d|j � t|�� dd�D ]~}t�|�D ]n}tj�||�}|�|j �d }tj�
|�r.| � |�}||kr.|� |�}tj�|j |�
d�|�}t�||� q.q dS )z�For all directories that exist within the archive, obfuscate the
directory name if it contains sensitive strings found during execution
z)Obfuscating directory names in archive %sT)�reverser� r� N)rE r� �sortedZget_directory_listr6 �listdirr8 r9 rC r� re r� �rstripr� r� )rJ r� �dirpath�_nameZ_dirnameZ_arc_dirZ _ob_dirnameZ _ob_arc_dirrO rO rP r� s" �
�z$SoSCleaner.obfuscate_directory_namesc C sP | j D ]D}z|�|�}W q tk
rH } z| �d| � W 5 d }~X Y qX q|S )Nz!Error obfuscating string data: %s)r@ Zparse_string_for_keysrf rE )rJ Z string_datar- rl rO rO rP r� + s
"zSoSCleaner.obfuscate_stringc C s� d}|� � s||fS |dkr"| j}|D ]T}z|�|�\}}||7 }W q& tk
rx } z| �d| |j� W 5 d}~X Y q&X q&||fS )a� Run a line through each of the obfuscation parsers, keeping a
cumulative total of substitutions done on that particular line.
Positional arguments:
:param line str: The raw line as read from the file being
processed
:param parsers: A list of parser objects to obfuscate
with. If None, use all.
Returns the fully obfuscated line and the number of substitutions made
r Nzfailed to parse line: %s)rD r@ Z
parse_linerf rW rA )rJ r_ r@ r� r- �_countrl rO rO rP r� 3 s &zSoSCleaner.obfuscate_linec C sL | j �d�}| jD ]4}|�|j�dd��� �}|�dt|jj �
� �� qdS )zLWrite some cleaner-level, non-report-specific stats to the manifest
r@ � r� �entriesN) r? r> r@ rA r� rB r� r� r� r� �keys)rJ Z parse_secr- Z_secrO rO rP r� O s
z"SoSCleaner.write_stats_to_manifest)NNNFN)N)N)N)N)F)NN)N)'�__name__�
__module__� __qualname__ra ZdescZ arg_defaultsr/ rT rW rE rZ r` � classmethodrc r: rs r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� �
__classcell__rO rO rM rP r % sb #� �D
, T
,O
F#
r )(r� ri r3 r6 r� r� Zconcurrent.futuresr r �pwdr r) r Z
sos.componentr Z sos.cleaner.parsers.ip_parserr Z sos.cleaner.parsers.mac_parserr Z#sos.cleaner.parsers.hostname_parserr Z"sos.cleaner.parsers.keyword_parserr
Z#sos.cleaner.parsers.username_parserr Zsos.cleaner.archives.sosr r
r r Z sos.cleaner.archives.genericr r Z sos.cleaner.archives.insightsr Z
sos.utilitiesr �textwrapr r rO rO rO rP �<module> s*