redacted-py 1.0.4__tar.gz

redacted-py-1.0.4/LICENSE

@@ -0,0 +1,17 @@
+Copyright (c) 2024 Cyril Dever
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+Subject to the terms and conditions of this license, each copyright holder and contributor hereby grants to those receiving rights under this license a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except for failure to satisfy the conditions of this license) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer this software, where such license applies only to those patent claims, already acquired or hereafter acquired, licensable by such copyright holder or contributor that are necessarily infringed by:
+
+  (a) their Contribution(s) (the licensed copyrights of copyright holders and non-copyrightable additions of contributors, in source or binary form) alone; or
+  (b) combination of their Contribution(s) with the work of authorship to which such Contribution(s) was added by such copyright holder or contributor, if, at the time the Contribution is added, such addition causes such combination to be necessarily infringed. The patent license shall not apply to any other combinations which include the Contribution.
+
+Except as expressly stated above, no rights or licenses from any copyright holder or contributor is granted under this license, whether expressly, by implication, estoppel or otherwise.
+
+DISCLAIMER
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

redacted-py-1.0.4/MANIFEST.in

@@ -0,0 +1,3 @@
+# MANIFEST.in
+
+exclude publish.sh

redacted-py-1.0.4/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: redacted-py
+Version: 1.0.4
+Summary: Redacting classified documents
+Author-email: Cyril Dever <cdever@pep-s.com>
+License: Copyright (c) 2024 Cyril Dever
+        
+        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+        
+          1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+          2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+        
+        Subject to the terms and conditions of this license, each copyright holder and contributor hereby grants to those receiving rights under this license a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except for failure to satisfy the conditions of this license) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer this software, where such license applies only to those patent claims, already acquired or hereafter acquired, licensable by such copyright holder or contributor that are necessarily infringed by:
+        
+          (a) their Contribution(s) (the licensed copyrights of copyright holders and non-copyrightable additions of contributors, in source or binary form) alone; or
+          (b) combination of their Contribution(s) with the work of authorship to which such Contribution(s) was added by such copyright holder or contributor, if, at the time the Contribution is added, such addition causes such combination to be necessarily infringed. The patent license shall not apply to any other combinations which include the Contribution.
+        
+        Except as expressly stated above, no rights or licenses from any copyright holder or contributor is granted under this license, whether expressly, by implication, estoppel or otherwise.
+        
+        DISCLAIMER
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/cyrildever/redacted
+Keywords: data,obfuscation,data masking,redacted,classified
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: feistel-py>=0.2.0
+
+# redacted-py
+_Redacting classified documents_
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/redacted)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/redacted)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/redacted)
+![GitHub license](https://img.shields.io/github/license/cyrildever/redacted)
+![PyPI - Version](https://img.shields.io/pypi/v/redacted-py)
+
+This repository holds the code base for my `redacted-py` library in Python. \
+It is mainly based off my [Feistel cipher for Format-Preserving Encryption](https://github.com/cyrildever/feistel-py) to which I added a few tools to handle document, database and file manipulation to ease out the operation.
+
+### Motivation
+
+In some fields (like healthcare for instance), protecting the privacy of data whilst being able to conduct in-depth studies is both vital and mandatory. Redacting documents and databases is therefore the obligatory passage.
+With `redacted-py`, I provide a simple yet secure tool to help redacting documents based on either a dictionary, a record layout or a tag to decide which parts should actually be redacted.
+
+
+### Usage
+
+You can use either a dictionary or a tag (or both) to identify the words you want to redact in a document.
+The tag should be placed before any word that should be redacted. The default tag is the tilde character (`~`).
+
+For example, the following sentence will only see the word `tagged` redacted: `"This is a ~tagged sentence"`.
+
+```console
+$ pip install redacted-py
+```
+
+```python
+from redacted import DefaultRedactor, Dictionary
+from feistel import FPECipher, SHA_256
+
+source = "Some text ~tagged or using words in a dictionary"
+
+cipher = FPECipher(SHA_256, key, 10)
+redactor = DefaultRedactor(cipher)
+redacted = redactor.redact(source)
+
+expanded = redactor.expand(redacted)
+assert expanded == source, "Original data should equal ciphered then deciphered data"
+
+cleansed = redactor.clean(expanded)
+assert cleansed == "Some text tagged or using words in a dictionary", "Cleaning should remove any tag mark"
+```
+
+You may also use it in the console with the following command line instructions:
+```
+usage: python3 -m redacted [-h] [-b | --both | --no-both] [-d DICTIONARY] [-H HASH] [-i INPUT] [-k KEY] [-o OUTPUT] [-r ROUNDS] [-t TAG] [-x | --expand | --no-expand]
+
+options:
+  -h, --help            show this help message and exit
+  -b, --both, --no-both
+                        Add to use both dictionary and tag
+  -d DICTIONARY, --dictionary DICTIONARY
+                        The optional path to the dictionary of words to redact
+  -H HASH, --hash HASH  The hash engine for the round function [default sha-256]
+  -i INPUT, --input INPUT
+                        The path to the document to be redacted
+  -k KEY, --key KEY     The optional key for the FPE scheme (leave it empty to use default)
+  -o OUTPUT, --output OUTPUT
+                        The name of the output file
+  -r ROUNDS, --rounds ROUNDS
+                        The number of rounds for the Feistel cipher [default 10]
+  -t TAG, --tag TAG     The optional tag that prefixes words to redact [default ~]
+  -x, --expand, --no-expand
+                        Add to expand a redacted document
+```
+
+
+### Tests
+
+```console
+$ git clone https://github.com/cyrildever/redacted.git
+$ cd redacted/py/
+$ pip install -e .
+$ python3 -m unittest discover
+```
+
+
+### License
+
+The use of the `redacted` libraries and executables are subject to fees for commercial purpose and to the respect of the [BSD-2-Clause-Patent license](LICENSE). \
+Please [contact me](mailto:cdever@pep-s.com) to get further information.
+
+_NB: It is still under development so use in production at your own risk for now._
+
+
+<hr />
+&copy; 2024 Cyril Dever. All rights reserved.

redacted-py-1.0.4/README.md

@@ -0,0 +1,90 @@
+# redacted-py
+_Redacting classified documents_
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/redacted)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/redacted)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/redacted)
+![GitHub license](https://img.shields.io/github/license/cyrildever/redacted)
+![PyPI - Version](https://img.shields.io/pypi/v/redacted-py)
+
+This repository holds the code base for my `redacted-py` library in Python. \
+It is mainly based off my [Feistel cipher for Format-Preserving Encryption](https://github.com/cyrildever/feistel-py) to which I added a few tools to handle document, database and file manipulation to ease out the operation.
+
+### Motivation
+
+In some fields (like healthcare for instance), protecting the privacy of data whilst being able to conduct in-depth studies is both vital and mandatory. Redacting documents and databases is therefore the obligatory passage.
+With `redacted-py`, I provide a simple yet secure tool to help redacting documents based on either a dictionary, a record layout or a tag to decide which parts should actually be redacted.
+
+
+### Usage
+
+You can use either a dictionary or a tag (or both) to identify the words you want to redact in a document.
+The tag should be placed before any word that should be redacted. The default tag is the tilde character (`~`).
+
+For example, the following sentence will only see the word `tagged` redacted: `"This is a ~tagged sentence"`.
+
+```console
+$ pip install redacted-py
+```
+
+```python
+from redacted import DefaultRedactor, Dictionary
+from feistel import FPECipher, SHA_256
+
+source = "Some text ~tagged or using words in a dictionary"
+
+cipher = FPECipher(SHA_256, key, 10)
+redactor = DefaultRedactor(cipher)
+redacted = redactor.redact(source)
+
+expanded = redactor.expand(redacted)
+assert expanded == source, "Original data should equal ciphered then deciphered data"
+
+cleansed = redactor.clean(expanded)
+assert cleansed == "Some text tagged or using words in a dictionary", "Cleaning should remove any tag mark"
+```
+
+You may also use it in the console with the following command line instructions:
+```
+usage: python3 -m redacted [-h] [-b | --both | --no-both] [-d DICTIONARY] [-H HASH] [-i INPUT] [-k KEY] [-o OUTPUT] [-r ROUNDS] [-t TAG] [-x | --expand | --no-expand]
+
+options:
+  -h, --help            show this help message and exit
+  -b, --both, --no-both
+                        Add to use both dictionary and tag
+  -d DICTIONARY, --dictionary DICTIONARY
+                        The optional path to the dictionary of words to redact
+  -H HASH, --hash HASH  The hash engine for the round function [default sha-256]
+  -i INPUT, --input INPUT
+                        The path to the document to be redacted
+  -k KEY, --key KEY     The optional key for the FPE scheme (leave it empty to use default)
+  -o OUTPUT, --output OUTPUT
+                        The name of the output file
+  -r ROUNDS, --rounds ROUNDS
+                        The number of rounds for the Feistel cipher [default 10]
+  -t TAG, --tag TAG     The optional tag that prefixes words to redact [default ~]
+  -x, --expand, --no-expand
+                        Add to expand a redacted document
+```
+
+
+### Tests
+
+```console
+$ git clone https://github.com/cyrildever/redacted.git
+$ cd redacted/py/
+$ pip install -e .
+$ python3 -m unittest discover
+```
+
+
+### License
+
+The use of the `redacted` libraries and executables are subject to fees for commercial purpose and to the respect of the [BSD-2-Clause-Patent license](LICENSE). \
+Please [contact me](mailto:cdever@pep-s.com) to get further information.
+
+_NB: It is still under development so use in production at your own risk for now._
+
+
+<hr />
+&copy; 2024 Cyril Dever. All rights reserved.

redacted-py-1.0.4/pyproject.toml

@@ -0,0 +1,35 @@
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools>=58.1.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "redacted-py"
+version = "1.0.4"
+description = "Redacting classified documents"
+readme = "README.md"
+authors = [{ name = "Cyril Dever", email = "cdever@pep-s.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "data",
+    "obfuscation",
+    "data masking",
+    "redacted",
+    "classified",
+]
+dependencies = [
+    "feistel-py >= 0.2.0",
+]
+requires-python = ">=3.10.2"
+
+[project.urls]
+Homepage = "https://github.com/cyrildever/redacted"
+
+[project.scripts]
+redacted-py = "redacted.__main__:main"

redacted-py-1.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

redacted-py-1.0.4/src/redacted/__init__.py

@@ -0,0 +1,7 @@
+# __init__.py
+
+__version__ = "1.0.4"
+
+from .tag import *
+from .dictionary import *
+from .redactor import *

redacted-py-1.0.4/src/redacted/__main__.py

@@ -0,0 +1,114 @@
+import argparse
+from feistel import FPECipher, Engine, is_available_engine, SHA_256
+
+
+from redacted import (
+    DEFAULT_TAG,
+    file2Dictionary,
+    Redactor,
+    RedactorWithDictionary,
+    RedactorWithTag,
+)
+
+
+DEFAULT_KEY = "d51e1d9a9b12cd88a1d232c1b8730a05c8a65d9706f30cdb8e08b9ed4c7b16a0"
+DEFAULT_ROUNDS = 10
+
+
+def main(args):
+    if not args.input or not args.output:
+        raise Exception("Input and output file paths are mandatory")
+    if not args.tag and not args.dictionary:
+        raise Exception("Use to set either a tag or a dictionary")
+    tag = args.tag
+    if args.both:
+        if not args.dictionary:
+            raise Exception(
+                "Tag and dictionary must be set if you want to use them both"
+            )
+        elif not args.tag:
+            print("WARN - Tag not set: default ~ will be used!")
+            tag = DEFAULT_TAG
+
+    hash_engine = Engine(args.hash)
+    if not args.hash and not is_available_engine(hash_engine):
+        print("WARN - Wrong hash engine: default SHA-256 will be used instead!")
+        hash_engine = SHA_256
+    key = args.key
+    if not key:
+        key = DEFAULT_KEY
+    rounds = int(args.rounds) if args.rounds else 0
+    if rounds < 2:
+        print("WARN - Not enough rounds: default 10 will be used instead!")
+        rounds = DEFAULT_ROUNDS
+
+    msg = "Start redacting..."
+    if args.expand:
+        msg = "Start expanding..."
+    print(f"INFO - {msg}")
+
+    # Prepare processing
+    if args.dictionary:
+        dic = file2Dictionary(args.dictionary)
+
+    cipher = FPECipher(hash_engine, key, rounds)
+    if args.both:
+        redactor = Redactor(dictionary=dic, tag=tag, cipher=cipher, both=True)
+    elif not args.expand and not dic.is_empty():
+        redactor = RedactorWithDictionary(dictionary=dic, cipher=cipher)
+    else:
+        redactor = RedactorWithTag(tag=tag, cipher=cipher)
+
+    # Do process
+    with open(args.input, "r") as inputfile, open(args.output, "w") as outputfile:
+        for line in inputfile:
+            if not args.expand:
+                redacted_line = redactor.redact(line)
+                outputfile.write(redacted_line + "\n")
+            else:
+                expanded_line = redactor.expand(line)
+                outputfile.write(expanded_line + "\n")
+
+    print("INFO - Process completed.")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-b",
+        "--both",
+        action=argparse.BooleanOptionalAction,
+        help="Add to use both dictionary and tag",
+    )
+    parser.add_argument(
+        "-d",
+        "--dictionary",
+        help="The optional path to the dictionary of words to redact",
+    )
+    parser.add_argument(
+        "-H", "--hash", help="The hash engine for the round function [default sha-256]"
+    )
+    parser.add_argument("-i", "--input", help="The path to the document to be redacted")
+    parser.add_argument(
+        "-k",
+        "--key",
+        help="The optional key for the FPE scheme (leave it empty to use default)",
+    )
+    parser.add_argument("-o", "--output", help="The name of the output file")
+    parser.add_argument(
+        "-r",
+        "--rounds",
+        help="The number of rounds for the Feistel cipher [default 10]",
+    )
+    parser.add_argument(
+        "-t", "--tag", help="The optional tag that prefixes words to redact [default ~]"
+    )
+    parser.add_argument(
+        "-x",
+        "--expand",
+        action=argparse.BooleanOptionalAction,
+        help="Add to expand a redacted document",
+    )
+    args = parser.parse_args()
+
+    main(args)

redacted-py-1.0.4/src/redacted/dictionary.py

@@ -0,0 +1,83 @@
+class Dictionary:
+    """
+    A Dictionary holds the list of words to be tagged
+    """
+
+    def __init__(self, words: list[str]):
+        self.words = words
+
+    def contains(self, word: str) -> bool:
+        """
+        Check whether the passed word is already in the Dictionary
+        """
+        return (
+            word in self.words
+            or (word.endswith("'s") and word[: len(word) - 2]) in self.words
+            or _remove_punctuation(word.strip()) in self.words
+        )
+
+    def is_empty(self) -> bool:
+        """
+        Returns `True` if there is no word in the Dictionary
+        """
+        return len(self.words) == 0
+
+    def length(self) -> int:
+        """
+        Gets the number of words
+        """
+        return len(self.words)
+
+    def to_string(self) -> str:
+        """
+        Returns the dictionay as a space-separated list of words
+        """
+        return " ".join(self.words)
+
+    def __eq__(self, other) -> bool:
+        return self.words == other.words
+
+
+def file2Dictionary(path: str) -> Dictionary:
+    """
+    Upload the content of a file to a Dictionary
+    """
+    with open(path, "r") as f:
+        data = f.read()
+
+    return string2Dictionary(data)
+
+
+def string2Dictionary(string: str, *delimiters) -> Dictionary:
+    """
+    Transforms a string into a dictionary (using the optionally passed delimiters [default space])
+    """
+    if len(delimiters) == 0:
+        delimiters = [" "]
+
+    words = [string]
+    for delimiter in delimiters:
+        tmp = list[str]()
+        for word in words:
+            tmp.extend(word.split(delimiter))
+        words = tmp
+
+    return Dictionary(words)
+
+
+def _remove_punctuation(string: str) -> str:
+    return (
+        string.strip(".")
+        .strip(",")
+        .strip(":")
+        .strip(";")
+        .strip("?")
+        .strip("!")
+        .strip("(")
+        .strip(")")
+        .strip("-")
+        .strip("_")
+        .strip("+")
+        .strip("/")
+        .strip("\\")
+    )

redacted-py-1.0.4/src/redacted/redactor.py

@@ -0,0 +1,116 @@
+import re
+from feistel import FPECipher
+
+
+from redacted import Dictionary, DEFAULT_TAG
+
+
+class Redactor:
+    """
+    Parent class for redactors
+    """
+
+    def __init__(self, dictionary: Dictionary, tag: str, cipher: FPECipher, both: bool):
+        self.dictionary = dictionary
+        self.tag = tag
+        self.cipher = cipher
+        self.both = both
+
+    def redact(self, line: str, *delimiters) -> str:
+        """
+        Returns the ciphered version of the passed input data
+        """
+        actual_delimiters = "\\s" + "".join(
+            [
+                (
+                    delim
+                    if delim != " "
+                    and delim != "\t"
+                    and delim != "\n"
+                    and delim != "\\s"
+                    else ""
+                )
+                for delim in delimiters
+            ]
+        )
+        words = re.split(actual_delimiters, line)
+        tokens = list[str]()
+        for word in words:
+            if self.both or not self.dictionary.is_empty():
+                if self.dictionary.contains(word):
+                    tokens.append(self.cipher.encrypt(word))
+                else:
+                    if self.tag and word.startswith(self.tag):
+                        tokens.append(
+                            self.tag + self.cipher.encrypt(word[len(self.tag) :])
+                        )
+                    else:
+                        tokens.append(word)
+            else:
+                if (
+                    not self.both
+                    and self.dictionary.is_empty()
+                    and self.tag
+                    and word.startswith(self.tag)
+                ):
+                    tokens.append(self.tag + self.cipher.encrypt(word[len(self.tag) :]))
+                else:
+                    tokens.append(word)
+
+        return " ".join(tokens)
+
+    def expand(self, line: str) -> str:
+        """
+        Returns the deciphered version of the passed input data
+        """
+        words = list[str]()
+        for word in line.split(" "):
+            if self.both or not self.dictionary.is_empty():
+                if self.tag and word.startswith(self.tag):
+                    words.append(self.tag + self.cipher.decrypt(word[len(self.tag) :]))
+                else:
+                    if not word.strip():
+                        # Avoid using new lines
+                        continue
+                    else:
+                        deciphered = self.cipher.decrypt(word)
+                        if deciphered and self.dictionary.contains(deciphered):
+                            words.append(deciphered)
+                        else:
+                            words.append(word)
+            else:
+                if not self.both and self.dictionary.is_empty():
+                    if self.tag and word.startswith(self.tag):
+                        words.append(
+                            self.tag + self.cipher.decrypt(word[len(self.tag) :])
+                        )
+                    else:
+                        words.append(word)
+                else:
+                    words.append(word)
+
+        return " ".join(words)
+
+    def clean(self, string: str) -> str:
+        """
+        Removes any delimiters from the passed string
+        """
+        if self.tag:
+            return string.replace(self.tag, "")
+        else:
+            return string
+
+
+class DefaultRedactor(Redactor):
+    def __init__(self, cipher: FPECipher):
+        super().__init__(Dictionary([]), DEFAULT_TAG, cipher, False)
+
+
+class RedactorWithDictionary(Redactor):
+    def __init__(self, dictionary: Dictionary, cipher: FPECipher):
+        super().__init__(dictionary, "", cipher, False)
+
+
+class RedactorWithTag(Redactor):
+    def __init__(self, tag: str, cipher: FPECipher):
+        super().__init__(Dictionary([]), tag, cipher, False)

redacted-py-1.0.4/src/redacted/tag.py

@@ -0,0 +1 @@
+DEFAULT_TAG = "~"

redacted-py-1.0.4/src/redacted_py.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: redacted-py
+Version: 1.0.4
+Summary: Redacting classified documents
+Author-email: Cyril Dever <cdever@pep-s.com>
+License: Copyright (c) 2024 Cyril Dever
+        
+        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+        
+          1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+          2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+        
+        Subject to the terms and conditions of this license, each copyright holder and contributor hereby grants to those receiving rights under this license a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except for failure to satisfy the conditions of this license) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer this software, where such license applies only to those patent claims, already acquired or hereafter acquired, licensable by such copyright holder or contributor that are necessarily infringed by:
+        
+          (a) their Contribution(s) (the licensed copyrights of copyright holders and non-copyrightable additions of contributors, in source or binary form) alone; or
+          (b) combination of their Contribution(s) with the work of authorship to which such Contribution(s) was added by such copyright holder or contributor, if, at the time the Contribution is added, such addition causes such combination to be necessarily infringed. The patent license shall not apply to any other combinations which include the Contribution.
+        
+        Except as expressly stated above, no rights or licenses from any copyright holder or contributor is granted under this license, whether expressly, by implication, estoppel or otherwise.
+        
+        DISCLAIMER
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/cyrildever/redacted
+Keywords: data,obfuscation,data masking,redacted,classified
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: feistel-py>=0.2.0
+
+# redacted-py
+_Redacting classified documents_
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/redacted)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/redacted)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/redacted)
+![GitHub license](https://img.shields.io/github/license/cyrildever/redacted)
+![PyPI - Version](https://img.shields.io/pypi/v/redacted-py)
+
+This repository holds the code base for my `redacted-py` library in Python. \
+It is mainly based off my [Feistel cipher for Format-Preserving Encryption](https://github.com/cyrildever/feistel-py) to which I added a few tools to handle document, database and file manipulation to ease out the operation.
+
+### Motivation
+
+In some fields (like healthcare for instance), protecting the privacy of data whilst being able to conduct in-depth studies is both vital and mandatory. Redacting documents and databases is therefore the obligatory passage.
+With `redacted-py`, I provide a simple yet secure tool to help redacting documents based on either a dictionary, a record layout or a tag to decide which parts should actually be redacted.
+
+
+### Usage
+
+You can use either a dictionary or a tag (or both) to identify the words you want to redact in a document.
+The tag should be placed before any word that should be redacted. The default tag is the tilde character (`~`).
+
+For example, the following sentence will only see the word `tagged` redacted: `"This is a ~tagged sentence"`.
+
+```console
+$ pip install redacted-py
+```
+
+```python
+from redacted import DefaultRedactor, Dictionary
+from feistel import FPECipher, SHA_256
+
+source = "Some text ~tagged or using words in a dictionary"
+
+cipher = FPECipher(SHA_256, key, 10)
+redactor = DefaultRedactor(cipher)
+redacted = redactor.redact(source)
+
+expanded = redactor.expand(redacted)
+assert expanded == source, "Original data should equal ciphered then deciphered data"
+
+cleansed = redactor.clean(expanded)
+assert cleansed == "Some text tagged or using words in a dictionary", "Cleaning should remove any tag mark"
+```
+
+You may also use it in the console with the following command line instructions:
+```
+usage: python3 -m redacted [-h] [-b | --both | --no-both] [-d DICTIONARY] [-H HASH] [-i INPUT] [-k KEY] [-o OUTPUT] [-r ROUNDS] [-t TAG] [-x | --expand | --no-expand]
+
+options:
+  -h, --help            show this help message and exit
+  -b, --both, --no-both
+                        Add to use both dictionary and tag
+  -d DICTIONARY, --dictionary DICTIONARY
+                        The optional path to the dictionary of words to redact
+  -H HASH, --hash HASH  The hash engine for the round function [default sha-256]
+  -i INPUT, --input INPUT
+                        The path to the document to be redacted
+  -k KEY, --key KEY     The optional key for the FPE scheme (leave it empty to use default)
+  -o OUTPUT, --output OUTPUT
+                        The name of the output file
+  -r ROUNDS, --rounds ROUNDS
+                        The number of rounds for the Feistel cipher [default 10]
+  -t TAG, --tag TAG     The optional tag that prefixes words to redact [default ~]
+  -x, --expand, --no-expand
+                        Add to expand a redacted document
+```
+
+
+### Tests
+
+```console
+$ git clone https://github.com/cyrildever/redacted.git
+$ cd redacted/py/
+$ pip install -e .
+$ python3 -m unittest discover
+```
+
+
+### License
+
+The use of the `redacted` libraries and executables are subject to fees for commercial purpose and to the respect of the [BSD-2-Clause-Patent license](LICENSE). \
+Please [contact me](mailto:cdever@pep-s.com) to get further information.
+
+_NB: It is still under development so use in production at your own risk for now._
+
+
+<hr />
+&copy; 2024 Cyril Dever. All rights reserved.

redacted-py-1.0.4/src/redacted_py.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/redacted/__init__.py
+src/redacted/__main__.py
+src/redacted/dictionary.py
+src/redacted/redactor.py
+src/redacted/tag.py
+src/redacted_py.egg-info/PKG-INFO
+src/redacted_py.egg-info/SOURCES.txt
+src/redacted_py.egg-info/dependency_links.txt
+src/redacted_py.egg-info/entry_points.txt
+src/redacted_py.egg-info/requires.txt
+src/redacted_py.egg-info/top_level.txt
+tests/test_dictionary.py
+tests/test_redactor.py

redacted-py-1.0.4/src/redacted_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

redacted-py-1.0.4/src/redacted_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+redacted-py = redacted.__main__:main

redacted-py-1.0.4/src/redacted_py.egg-info/requires.txt

@@ -0,0 +1 @@
+feistel-py>=0.2.0

redacted-py-1.0.4/src/redacted_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+redacted

redacted-py-1.0.4/tests/test_dictionary.py

@@ -0,0 +1,23 @@
+from unittest import TestCase
+
+from redacted import Dictionary, file2Dictionary, string2Dictionary
+
+
+class TestDictionary(TestCase):
+    def test_string2Dictionary(self):
+        string = "Cyril Antoine Laurent,Dever"
+        dic = string2Dictionary(string)
+        self.assertEqual(dic.length(), 3)
+        self.assertFalse(dic.contains("Dever"))
+        dic = string2Dictionary(string, " ", ",")
+        self.assertEqual(dic.length(), 4)
+        self.assertTrue(dic.contains("Dever"))
+        self.assertFalse(dic.is_empty())
+        self.assertEqual(dic.to_string(), "Cyril Antoine Laurent Dever")
+
+        dic2 = Dictionary(["Cyril", "Antoine", "Laurent", "Dever"])
+        self.assertEqual(dic, dic2)
+
+        dic = file2Dictionary("./tests/dictionaryExample.txt")
+        self.assertEqual(dic.length(), 5)
+        self.assertEqual(dic.to_string(), "M. Cyril Antoine Laurent Dever")

redacted-py-1.0.4/tests/test_redactor.py

@@ -0,0 +1,71 @@
+from unittest import TestCase
+from feistel import FPECipher, BLAKE2B, KECCAK, SHA_256
+
+
+from redacted import Dictionary, DefaultRedactor, RedactorWithDictionary
+
+
+class TestRedactor(TestCase):
+    def test_dictionary_redactor(self):
+        dic = Dictionary(["M.", "Cyril", "Antoine", "Laurent", "Dever"])
+        ref = "B6ds. is testing ¼= Du:,l26 library while ¾.=y£|v Izizb is listening to Âvhis*l<"
+
+        txt = "Cyril is testing M. Dever's library while Antoine Dever is listening to Laurent."
+        redactor = RedactorWithDictionary(
+            dic,
+            FPECipher(
+                SHA_256,
+                "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+                10,
+            ),
+        )
+        redacted = redactor.redact(txt)
+        self.assertEqual(redacted, ref)
+        expanded = redactor.expand(redacted)
+        self.assertEqual(expanded, txt)
+
+        blake2 = "¸lk€$ is testing F: B!@x7;1 library while Cs>v0'* ¹'90< is listening to Pz2;ws?o"
+        redacted = RedactorWithDictionary(
+            dic,
+            FPECipher(
+                BLAKE2B,
+                "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+                10,
+            ),
+        ).redact(txt)
+        self.assertEqual(redacted, blake2)
+        self.assertTrue(redacted != ref)
+
+        keccak = "H1i,{ is testing ½5 ¿&bv8f8 library while ¸&7+r$u ¹|6'h is listening to Å€j;$\"4<"
+        redacted = RedactorWithDictionary(
+            dic,
+            FPECipher(
+                KECCAK,
+                "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+                10,
+            ),
+        ).redact(txt)
+        self.assertEqual(redacted, keccak)
+        self.assertTrue(redacted != ref)
+
+    def test_tag_redactor(self):
+        ref = "~B6ds. is testing ~¼= ~Du:,l26 library while ~¾.=y£|v ~Izizb is listening to ~Âvhis*l<"
+
+        txt = "~Cyril is testing ~M. ~Dever's library while ~Antoine ~Dever is listening to ~Laurent."
+        redactor = DefaultRedactor(
+            FPECipher(
+                SHA_256,
+                "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+                10,
+            )
+        )
+        redacted = redactor.redact(txt)
+        self.assertEqual(redacted, ref)
+        expanded = redactor.expand(redacted)
+        self.assertEqual(expanded, txt)
+
+        cleansed = redactor.clean(expanded)
+        self.assertEqual(
+            cleansed,
+            "Cyril is testing M. Dever's library while Antoine Dever is listening to Laurent.",
+        )