def test_case_clarify_write_inverts_read_example(self): """Tests the write then read workflow of keyring.clarify.""" theResult = False someMessageText = str("This is a test Message") try: from piaplib.keyring import clarify as clarify if clarify.__name__ is None: raise ImportError("Failed to import clarify") elif (clarify.hasBackendCommand() is not True): raise unittest.SkipTest("Requires backend tool") from piaplib.keyring import rand as rand if rand.__name__ is None: raise ImportError("Failed to import rand") sometestfile = str("/tmp/the_test_file.enc") theteststore = clarify.makeKeystoreFile( str("testkeyneedstobelong"), str("/tmp/.weak_test_key_{}").format(rand.randInt(1, 10, 99))) self.assertIsNotNone(theteststore, "Bad Test Env: No Test Keystore") test_write = clarify.packToFile(sometestfile, str(someMessageText), theteststore) self.assertTrue(test_write) if (test_write is True): test_read = clarify.unpackFromFile(sometestfile, theteststore) clean_temp_file(theteststore) try: if isinstance(test_read, bytes): test_read = test_read.decode( """utf-8""", errors=clarify.getCTLModeForPY()) except UnicodeDecodeError: test_read = str(repr(bytes(test_read, """utf-8"""))) self.assertIsNotNone(test_read) self.assertIsInstance(test_read, str, "Test output is Not a string") self.assertIsInstance(someMessageText, str, "Test input is Not a string") if (str(someMessageText) in str(test_read)): theResult = True else: if sys.platform.startswith( "linux") or sys.platform.startswith("darwin"): print(str(repr(bytes(test_read, """utf-8""")))) theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") except Exception as err: print(str("")) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err if sys.platform.startswith("linux"): theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") self.assertTrue(theResult, """the write then read workflow failed""")
def test_case_clarify_main_keyring(self): """Tests the helper function main unpack of keyring.main(clarify)""" theResult = False try: from piaplib.pku import utils as utils if utils.__name__ is None: raise ImportError("Failed to import utils") import piaplib.keyring.__main__ temp_msg = None test_args = [] if sys.platform.startswith("linux") or True: temp_msg = str( """U2FsdGVkX1/MMOdV6OYwAURQQg9b9K1AoVA0OCcanG9FjHk7gHk=""") test_args = [ str("clarify"), str("--unpack"), str("--msg='{}'").format(temp_msg), str("-K=testkeyneedstobelong") ] else: temp_msg = str( """U2FsdGVkX1/beHoH2ziXWcMFpb3fzzPxQqdeU1tO5UVoBUEnow8T9g==""" ) test_args = [ str("clarify"), str("--unpack"), str("--msg={}").format(str(temp_msg)), str("-K=testkeyneedstobelong") ] print( str("... test: piaplib.keyring.__main__({})").format( str(test_args))) test_out = piaplib.keyring.__main__.main(test_args) print(str("... checking")) self.assertIsNotNone(test_out) self.assertIsNotNone(str(test_out)) print(str("... is not none: PASS")) if (int(0) == int(test_out)): theResult = True else: if sys.platform.startswith("darwin"): print(str(test_out)) theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") except Exception as err: print(str("")) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err if sys.platform.startswith("darwin"): theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") assert theResult
def test_case_utils_read_url_file(self): """Tests the fetch url and clean functions""" theResult = False try: from piaplib import pku as pku if pku.__name__ is None: raise ImportError("Failed to import pku") from pku import utils as utils if utils.__name__ is None: raise ImportError("Failed to import utils") someURL = str( "https://raw.githubusercontent.com/reactive-firewall" + "/PiAP-python-tools/master/requirements.txt") somefile = str("the_test_url_file.txt") if (utils.getFileResource(someURL, somefile) is True): utils.cleanFileResource(somefile) theResult = True else: theResult = False if (theResult is False): if sys.platform.startswith("linux"): print(str("fetch failed")) print(str("")) else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") except unittest.SkipTest as skiper: skiper = None del skiper raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") except Exception as err: print(str("")) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err theResult = False self.assertTrue(theResult)
def test_case_clarify_main_a(self): """Tests the helper function main pack of keyring.clarify""" theResult = False try: from piaplib.keyring import clarify as clarify if clarify.__name__ is None: raise ImportError("Failed to import clarify") test_out = clarify.main([ str("--pack"), str("--msg=\"This is a test Message\""), str("-K=testkeyneedstobelong") ]) self.assertIsNotNone(test_out) try: if isinstance(test_out, bytes): test_out = test_out.decode("""utf-8""") except UnicodeDecodeError: test_out = str( repr( bytes(test_out).decode( """utf-8""", errors=clarify.getCTLModeForPY()))) if (str("U2FsdGVkX") in str(test_out)): theResult = True else: theResult = False except Exception as err: print(str("")) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err if sys.platform.startswith("linux"): theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") assert theResult
def test_case_clarify_write_inverts_read(self, someInput): # noqa C901 """Tests the write then read workflow of keyring.clarify with fuzzing.""" theResult = False someInput = str(someInput) assume(isinstance(someInput, str)) assume(len(str(someInput)) > 3) assume("""\"""" not in str(someInput)) assume("""'""" not in str(someInput)) assume(repr(str(someInput)) not in repr(str(repr(someInput)))) from piaplib.pku import utils as utils if utils.__name__ is None: raise ImportError("Failed to import utils") assume(str(someInput) in utils.literal_str(someInput)) assume(utils.literal_str(someInput) in str(someInput)) assume( utils.literal_str(someInput) in utils.literal_code(str(someInput))) assume( utils.literal_code(str(someInput)) in utils.literal_str(someInput)) assume(someInput in str(someInput)) someMessageText = str(repr(someInput)) try: from piaplib.keyring import clarify as clarify if clarify.__name__ is None: raise ImportError("Failed to import clarify") elif (clarify.hasBackendCommand() is not True): raise unittest.SkipTest("Requires backend tool") from piaplib.keyring import rand as rand if rand.__name__ is None: raise ImportError("Failed to import rand") sometestfile = str("./the_test_file.enc") theteststore = clarify.makeKeystoreFile( str("testkeyneedstobelong"), str("./.weak_test_key_{}").format(rand.randInt(1, 10, 99))) assume((theteststore is not None)) self.assertIsNotNone(theteststore) test_write = clarify.packToFile(sometestfile, str(someMessageText), theteststore) assume(test_write is True) self.assertTrue(test_write) check_wrap = clarify.packForRest(str(someMessageText), theteststore) assume((check_wrap is not None)) try: note( str("encoded: \"{}\"").format( utils.literal_str(someMessageText))) note(str("as str: \"{}\"").format(str(someMessageText))) note( str("as data: \"{}\"").format( utils.literal_str(check_wrap))) except Exception as noteErr: raise unittest.SkipTest(noteErr) noteErr = None del noteErr if (test_write is True): test_read = clarify.unpackFromFile(sometestfile, theteststore) try: if isinstance(test_read, bytes): test_read = test_read.decode( """utf-8""", errors=clarify.getCTLModeForPY()) except UnicodeDecodeError: test_read = str(repr(bytes(test_read, """utf-8"""))) assume(False) self.assertIsNotNone(test_read) if (str(someMessageText) in str(test_read)): theResult = True else: note( str("failed test: \"{}\" is not in \"{}\"").format( str(someMessageText), str(test_read))) note( str("decoded: \"{}\"").format( utils.literal_str(test_read))) note( str("should decoded: \"{}\"").format( utils.literal_code(str(someMessageText)))) note( str("from undecoded: \"{}\"").format( utils.literal_str(utils.readFile(sometestfile)))) note( str("with keystore: \"{}\"").format( utils.literal_str(theteststore))) theResult = False clean_temp_file(theteststore) except Exception as err: print(str("")) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err if sys.platform.startswith("linux"): theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") self.assertTrue(theResult, """fuzzing the write then read workflow failed""")
def test_case_clarify_main_b(self): """Tests the helper function main unpack of keyring.clarify""" theResult = False try: from piaplib.pku import utils as utils if utils.__name__ is None: raise ImportError("Failed to import utils") from piaplib.keyring import clarify as clarify if clarify.__name__ is None: raise ImportError("Failed to import clarify") elif (clarify.hasBackendCommand() is not True): raise unittest.SkipTest("Requires backend tool") temp_msg = None test_args = [] # temp_msg = str("""U2FsdGVkX1+dD6bFlND+Xa0bzNttrZfB5zYCp0mSEYfhMTpaM7U=""") if sys.platform.startswith("linux"): # temp_msg = str("""U2FsdGVkX1+dD6bFlND+Xa0bzNttrZfB5zYCp0mSEYfhMTpaM7U=""") temp_msg = str( """U2FsdGVkX1/MMOdV6OYwAURQQg9b9K1AoVA0OCcanG9FjHk7gHk=""") test_args = [ str("--unpack"), str("--msg=\"{}\"").format(temp_msg), str("-K=testkeyneedstobelong") ] else: temp_msg = str( """U2FsdGVkX1/beHoH2ziXWcMFpb3fzzPxQqdeU1tO5UVoBUEnow8T9g==""" ) test_args = [ str("--unpack"), str("--msg={}").format(str(temp_msg)), str("-K=testkeyneedstobelong") ] print(str("... args {}").format(str(test_args))) print(str("... test")) test_out = clarify.main(test_args) print(str("... checking")) try: if isinstance(test_out, bytes): test_out = test_out.decode( """utf-8""", errors=clarify.getCTLModeForPY()) except UnicodeDecodeError as unierr: print(str(type(unierr))) print(str(unierr)) test_out = str( repr( bytes(test_out, encoding="""utf-8""").decode( """utf-8""", errors=clarify.getCTLModeForPY()))) print(str("... assert not none or junk")) self.assertIsNotNone(test_out) self.assertIsNotNone(str(test_out)) print(str("... assert not junk")) if (str("""This is a test Message""") in str(test_out)): theResult = True else: if sys.platform.startswith("linux") or sys.platform.startswith( "darwin"): print( str( repr( bytes(test_out, encoding="""utf-8""").decode( """utf-8""", errors=clarify.getCTLModeForPY())))) theResult = False print(str("")) print(str("... DECODE BUG CONFIRMED ...")) print(str("")) print(str(test_out)) print(str("vs")) print(str("""This is a test Message""")) else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") except Exception as err: print(str("")) print(str(sys.getdefaultencoding())) print(str(type(err))) print(str(err)) print(str((err.args))) print(str("")) err = None del err if sys.platform.startswith("linux") or sys.platform.startswith( "darwin"): theResult = False else: raise unittest.SkipTest( "BETA. Experemental feature not ready yet.") assert theResult
def test_keyring_salt_test_entropy(self): """Test deversity of saltify hashes.""" theResult = True try: from piaplib import keyring as keyring from keyring import saltify as saltify from keyring import rand as rand for depends in [keyring, saltify, rand]: if depends.__name__ is None: theResult = False randomSalt = str(rand.randStr(10)) space = str(""" """) randomSalt_shift1 = randomSalt + space randomSalt_shift2 = randomSalt_shift1 + space randomSalt_shift3 = randomSalt_shift2 + space randomSalt_shift4 = randomSalt_shift3 + space randomSalt_shift5 = randomSalt_shift4 + space randomSalt_shift6 = randomSalt_shift5 + space randomSalt_shift7 = randomSalt_shift6 + space randomSalt_shift8 = randomSalt_shift7 + space randomSalt_shift9 = randomSalt_shift8 + space randomSalt_shiftX = randomSalt_shift9 + space salt_list = [ randomSalt, randomSalt_shift1, randomSalt_shift2, randomSalt_shift3, randomSalt_shift4, randomSalt_shift5, randomSalt_shift6, randomSalt_shift7, randomSalt_shift8, randomSalt_shift9, randomSalt_shiftX ] if theResult is not True: self.assertTrue(theResult) for someRandomTest in range(10000): this_test = str(rand.randStr(10)) that_test = str(rand.randStr(10)) try: with self.subTest(i=someRandomTest, this_test=that_test, that_test=that_test): self.assertIsNotNone(that_test) self.assertIsNotNone(this_test) self.assertNotEqual(this_test, that_test) for test_salt in salt_list: a = saltify.saltify(str(this_test), str(randomSalt)) b = saltify.saltify(str(that_test), str(test_salt)) self.assertIsNotNone(a) self.assertIsInstance(a, str) self.assertIsNotNone(b) self.assertIsInstance(b, str) self.assertNotEqual(a, b) except Exception: raise unittest.SkipTest() except unittest.SkipTest: raise unittest.SkipTest( "Testing Framework does not allow subTest()") except Exception as testErr: print(str("Entropy - Fuzzing Crash Found new test")) print(str("")) print(str(type(testErr))) print(str(testErr)) print(str((testErr.args))) print(str("")) testErr = None del (testErr) theResult = False assert theResult