diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..73f69e0 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/Ciphey.iml b/.idea/Ciphey.iml new file mode 100644 index 0000000..b02dcb0 --- /dev/null +++ b/.idea/Ciphey.iml @@ -0,0 +1,14 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..f3c49ac --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..bb282bc --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/other.xml b/.idea/other.xml new file mode 100644 index 0000000..a708ec7 --- /dev/null +++ b/.idea/other.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..8d44290 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,2 @@ +include /appp/languageCheckerMod/* +include README.MD \ No newline at end of file diff --git a/README.MD b/README.MD index eb4b906..27c1812 100644 --- a/README.MD +++ b/README.MD @@ -1,3 +1,7 @@ +![Ciphey][logo.png] +made with python +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) +![Ciphey's Tests](https://github.com/brandonskerritt/Ciphey/workflows/Python%20application/badge.svg?branch=master) # What is this? Ciphey is an automated decryption tool. You put in encrypted text, and it outputs the decrypted text. diff --git a/app/Decryptor/Encoding/__init__.py b/app/Decryptor/Encoding/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/Decryptor/Encoding/encodingParent.py b/app/Decryptor/Encoding/encodingParent.py index ba703b7..f632e25 100644 --- a/app/Decryptor/Encoding/encodingParent.py +++ b/app/Decryptor/Encoding/encodingParent.py @@ -1,8 +1,8 @@ -from Decryptor.Encoding.base64 import Base64 -from Decryptor.Encoding.binary import Binary -from Decryptor.Encoding.hexadecimal import Hexadecimal -from Decryptor.Encoding.ascii import Ascii -from Decryptor.Encoding.morsecode import MorseCode +from app.Decryptor.Encoding.base64 import Base64 +from app.Decryptor.Encoding.binary import Binary +from app.Decryptor.Encoding.hexadecimal import Hexadecimal +from app.Decryptor.Encoding.ascii import Ascii +from app.Decryptor.Encoding.morsecode import MorseCode class EncodingParent: def __init__(self, lc): diff --git a/app/Decryptor/__init__.py b/app/Decryptor/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/Decryptor/basicEncryption/basic_parent.py b/app/Decryptor/basicEncryption/basic_parent.py index 1dbff1a..3542938 100644 --- a/app/Decryptor/basicEncryption/basic_parent.py +++ b/app/Decryptor/basicEncryption/basic_parent.py @@ -1,8 +1,8 @@ -from Decryptor.basicEncryption.caesar import Caesar -from Decryptor.basicEncryption.reverse import Reverse -from Decryptor.basicEncryption.viginere import Viginere -from Decryptor.basicEncryption.pigLatin import PigLatin -from Decryptor.basicEncryption.transposition import Transposition +import app.Decryptor.basicEncryption.caesar +import app.Decryptor.basicEncryption.reverse +import app.Decryptor.basicEncryption.viginere +import app.Decryptor.basicEncryption.pigLatin + """ So I want to assign the prob distribution to objects so it makes sense to do this? @@ -32,23 +32,22 @@ for key, val in self.prob: list_objs.insert(counter, list_objs.pop(listCounter)) counter = counter + 1 -Eventually we get a sorted list of objs - - +Eventually we get a sorted list of obj """ + class BasicParent: def __init__(self, lc): self.lc = lc - self.caesar = Caesar(self.lc) - self.reverse = Reverse(self.lc) - self.viginere = Viginere(self.lc) - self.pig = PigLatin(self.lc) + self.caesar = app.Decryptor.basicEncryption.caesar.Caesar(self.lc) + self.reverse = app.Decryptor.basicEncryption.reverse.Reverse(self.lc) + self.viginere = app.Decryptor.basicEncryption.viginere.Viginere(self.lc) + self.pig = app.Decryptor.basicEncryption.pigLatin.PigLatin(self.lc) # self.trans = Transposition(self.lc) self.list_of_objects = [self.caesar, self.reverse, self.pig] + def decrypt(self, text): self.text = text - from multiprocessing.dummy import Pool as ThreadPool pool = ThreadPool(4) answers = pool.map(self.callDecrypt, self.list_of_objects) @@ -69,11 +68,13 @@ class BasicParent: if result["IsPlaintext?"]: return result return {"lc": self.lc, "IsPlaintext?": False, "Plaintext": None, "Cipher": None, "Extra Information": None} + def callDecrypt(self, obj): # i only exist to call decrypt return obj.decrypt(self.text) def setProbTable(self, prob): + """I'm still writing this""" self.probabilityDistribution = prob # we get a sorted list of objects :) counter = 0 diff --git a/app/Decryptor/basicEncryption/caesar.py b/app/Decryptor/basicEncryption/caesar.py index d23b1ce..b48bd2a 100644 --- a/app/Decryptor/basicEncryption/caesar.py +++ b/app/Decryptor/basicEncryption/caesar.py @@ -8,16 +8,15 @@ Github: brandonskerritt """ -class Caesar(): +class Caesar: def __init__(self, lc): self.lc = lc + def getName(self): return "Caesar" + def decrypt(self, message): - ''' Simple python program to bruteforce a caesar cipher''' - - ''' Simple python program for the caesar cipher''' - + """ Simple python program to bruteforce a caesar cipher""" # Example string message = message.lower() @@ -49,5 +48,3 @@ class Caesar(): return {"lc": self.lc, "IsPlaintext?": True, "Plaintext": translated, "Cipher": "Caesar", "Extra Information": f"The rotation used is {counter}"} # if none of them match English, return false! return {"lc": self.lc, "IsPlaintext?": False, "Plaintext": None, "Cipher": "Caesar", "Extra Information": None} - - diff --git a/app/Decryptor/basicEncryption/reverse.py b/app/Decryptor/basicEncryption/reverse.py index a3dfeec..434a4ac 100644 --- a/app/Decryptor/basicEncryption/reverse.py +++ b/app/Decryptor/basicEncryption/reverse.py @@ -1,8 +1,11 @@ -import mathsHelper +import app.mathsHelper + + class Reverse: def __init__(self, lc): self.lc = lc - self.mh = mathsHelper.mathsHelper() + self.mh = app.mathsHelper.mathsHelper() + def decrypt(self, message): message = self.mh.stripPuncuation(message) @@ -12,5 +15,6 @@ class Reverse: return {"lc": self.lc, "IsPlaintext?": True, "Plaintext": message, "Cipher": "Reverse", "Extra Information": None} else: return {"lc": self.lc, "IsPlaintext?": False, "Plaintext": None, "Cipher": "Reverse", "Extra Information": None} + def getName(self): - return "Reverse" \ No newline at end of file + return "Reverse" diff --git a/app/Decryptor/basicEncryption/viginere.py b/app/Decryptor/basicEncryption/viginere.py index 4914ba6..fc241f9 100644 --- a/app/Decryptor/basicEncryption/viginere.py +++ b/app/Decryptor/basicEncryption/viginere.py @@ -1,5 +1,5 @@ import itertools, re -from Decryptor.basicEncryption import freqAnalysis +import app.Decryptor.basicEncryption.freqAnalysis class Viginere: def __init__(self, lc): self.LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' @@ -173,7 +173,7 @@ class Viginere: freqScores = [] for possibleKey in self.LETTERS: decryptedText = self.decryptMessage(possibleKey, nthLetters) - keyAndFreqMatchTuple = (possibleKey, freqAnalysis.englishFreqMatchScore(decryptedText)) + keyAndFreqMatchTuple = (possibleKey, app.Decryptor.basicEncryption.freqAnalysis.englishFreqMatchScore(decryptedText)) freqScores.append(keyAndFreqMatchTuple) # Sort by match score: freqScores.sort(key=self.getItemAtIndexOne, reverse=True) diff --git a/app/Tests/test_Encoding.py b/app/Tests/test_Encoding.py index af236f0..334a115 100644 --- a/app/Tests/test_Encoding.py +++ b/app/Tests/test_Encoding.py @@ -1,8 +1,13 @@ -import sys -sys.path.append("..") +import sys +# sys.path.append('..') + import unittest -from app.Decryptor.Encoding.encodingParent import EncodingParent -from languageCheckerMod.languageChecker import LanguageChecker +# from app.Decryptor.Encoding.encodingParent import EncodingParent +import app.Decryptor.Encoding.encodingParent +import app.languageCheckerMod.LanguageChecker + +import app.languageCheckerMod.LanguageChecker +#from languageCheckerMod import LanguageChecker # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests # python3 -m unittest discover -s Tests -p test*.py @@ -10,41 +15,41 @@ from languageCheckerMod.languageChecker import LanguageChecker class TestNN(unittest.TestCase): def test_english_yes(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) result = ep.decrypt("eW91ciB0ZXh0") self.assertEqual(result['IsPlaintext?'], True) def test_base64_spaces_yes(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) result = ep.decrypt("SGVsbG8gSSBsaWtlIGRvZ3MgYW5kIGNhdHM=") self.assertEqual(result['IsPlaintext?'], True) def test_binary_spaces_yes(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) result = ep.decrypt("01001000 01100101 01101100 01101100 01101111 00100000 01001001 00100000 01101100 01101001 01101011 01100101 00100000 01100100 01101111 01100111 01110011 00100000 01100001 01101110 01100100 00100000 01100011 01100001 01110100 01110011") self.assertEqual(result['IsPlaintext?'], True) def test_hex_spaces_yes(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) result = ep.decrypt("68 65 6c 6c 6f 20 6f 6c 69 76 69 61 20 69 20 72 65 61 6c 6c 79 20 6c 69 6b 65 20 79 6f 75 72 20 64 6f 67") self.assertEqual(result['IsPlaintext?'], True) def test_hex_spaces_yes(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) a = "68656c6c6f206f 6c 69 76 69 61 20 69 20 72 65 61 6c 6c 79 20 6c 69 6b 65 20 79 6f 75 72 20 64 6f 67" a = a.replace(" ", "") result = ep.decrypt(a) self.assertEqual(result['IsPlaintext?'], True) def test_ascii(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) a = "68 65 6C 6C 6F 20 64 6F 67" result = ep.decrypt(a) self.assertEqual(result['IsPlaintext?'], True) def test_morse(self): - lc = LanguageChecker() - ep = EncodingParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + ep = app.Decryptor.Encoding.encodingParent.EncodingParent(lc) a = ".... . .-.. .-.. --- / -- -.-- / -. .- -- . / .. ... / -... .-. .- -. -.. --- -." result = ep.decrypt(a) self.assertEqual(result['IsPlaintext?'], True) \ No newline at end of file diff --git a/app/Tests/test_basic_parent.py b/app/Tests/test_basic_parent.py index 69e9350..263428f 100644 --- a/app/Tests/test_basic_parent.py +++ b/app/Tests/test_basic_parent.py @@ -1,30 +1,30 @@ -import sys -sys.path.append("..") import unittest -from Decryptor.basicEncryption.basic_parent import BasicParent -from languageCheckerMod.languageChecker import LanguageChecker +import sys +# sys.path.append("..") +import app.Decryptor.basicEncryption.basic_parent +import app.languageCheckerMod.LanguageChecker # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests # python3 -m unittest discover -s Tests -p test*.py class TestBasicParent(unittest.TestCase): def test_basic_parent_caesar_yes(self): - lc = LanguageChecker() - bp = BasicParent(lc) + lc = app.languageCheckerMod.LanguageChecker.languageCheckerMod.LanguageChecker.LanguageChecker() + bp = app.Decryptor.basicEncryption.basic_parent.BasicParent(lc) result = bp.decrypt("uryyb zl sngure uryyb zl zbgure naq v ernyyl qb yvxr n tbbq ratyvfu oernxsnfg") self.assertEqual(result['IsPlaintext?'], True) def test_basic_parent_reverse_yes(self): - lc = LanguageChecker() - bp = BasicParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + bp = app.Decryptor.basicEncryption.basic_parent.BasicParent(lc) result = bp.decrypt("tsafkaerb hsilgne doog a ekil od yllaer i dna rehtom ym olleh rehtaf ym olleh") self.assertEqual(result['IsPlaintext?'], True) def test_basic_parent_reverse_yes_2(self): - lc = LanguageChecker() - bp = BasicParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + bp = app.Decryptor.basicEncryption.basic_parent.BasicParent(lc) result = bp.decrypt("sevom ylpmis rac eht ciffart ruoy lla gnillenut si hcihw redivorp NPV a ekilnU") self.assertEqual(result['IsPlaintext?'], True) def test_viginere_yes(self): - lc = LanguageChecker() - bp = BasicParent(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + bp = app.Decryptor.basicEncryption.basic_parent.BasicParent(lc) result = bp.decrypt("""Adiz Avtzqeci Tmzubb wsa m Pmilqev halpqavtakuoi, lgouqdaf, kdmktsvmztsl, izr xoexghzr kkusitaaf. Vz wsa twbhdg ubalmmzhdad qz hce vmhsgohuqbo ox kaakulmd gxiwvos, krgdurdny i rcmmstugvtawz ca tzm ocicwxfg jf "stscmilpy" oid "uwydptsbuci" wabt hce Lcdwig eiovdnw. Bgfdny qe kddwtk qjnkqpsmev ba pz tzm roohwz at xoexghzr kkusicw izr vrlqrwxist uboedtuuznum. Pimifo Icmlv Emf DI, Lcdwig owdyzd xwd hce Ywhsmnemzh Xovm mby Cqxtsm Supacg (GUKE) oo Bdmfqclwg Bomk, Tzuhvif'a ocyetzqofifo ositjm. Rcm a lqys ce oie vzav wr Vpt 8, lpq gzclqab mekxabnittq tjr Ymdavn fihog cjgbhvnstkgds. Zm psqikmp o iuejqf jf lmoviiicqg aoj jdsvkavs Uzreiz qdpzmdg, dnutgrdny bts helpar jf lpq pjmtm, mb zlwkffjmwktoiiuix avczqzs ohsb ocplv nuby swbfwigk naf ohw Mzwbms umqcifm. Mtoej bts raj pq kjrcmp oo tzm Zooigvmz Khqauqvl Dincmalwdm, rhwzq vz cjmmhzd gvq ca tzm rwmsl lqgdgfa rcm a kbafzd-hzaumae kaakulmd, hce SKQ. Wi 1948 Tmzubb jgqzsy Msf Zsrmsv'e Qjmhcfwig Dincmalwdm vt Eizqcekbqf Pnadqfnilg, ivzrw pq onsaafsy if bts yenmxckmwvf ca tzm Yoiczmehzr uwydptwze oid tmoohe avfsmekbqr dn eifvzmsbuqvl tqazjgq. Pq kmolm m dvpwz ab ohw ktshiuix pvsaa at hojxtcbefmewn, afl bfzdakfsy okkuzgalqzu xhwuuqvl jmmqoigve gpcz ie hce Tmxcpsgd-Lvvbgbubnkq zqoxtawz, kciup isme xqdgo otaqfqev qz hce 1960k. Bgfdny'a tchokmjivlabk fzsmtfsy if i ofdmavmz krgaqqptawz wi 1952, wzmz vjmgaqlpad iohn wwzq goidt uzgeyix wi tzm Gbdtwl Wwigvwy. Vz aukqdoev bdsvtemzh rilp rshadm tcmmgvqg (xhwuuqvl uiehmalqab) vs sv mzoejvmhdvw ba dmikwz. Hpravs rdev qz 1954, xpsl whsm tow iszkk jqtjrw pug 42id tqdhcdsg, rfjm ugmbddw xawnofqzu. Vn avcizsl lqhzreqzsy tzif vds vmmhc wsa eidcalq; vds ewfvzr svp gjmw wfvzrk jqzdenmp vds vmmhc wsa mqxivmzhvl. Gv 10 Esktwunsm 2009, fgtxcrifo mb Dnlmdbzt uiydviyv, Nfdtaat Dmiem Ywiikbqf Bojlab Wrgez avdw iz cafakuog pmjxwx ahwxcby gv nscadn at ohw Jdwoikp scqejvysit xwd "hce sxboglavs kvy zm ion tjmmhzd." Sa at Haq 2012 i bfdvsbq azmtmd'g widt ion bwnafz tzm Tcpsw wr Zjrva ivdcz eaigd yzmbo Tmzubb a kbmhptgzk dvrvwz wa efiohzd.""") self.assertEqual(result['IsPlaintext?'], True) \ No newline at end of file diff --git a/app/Tests/test_caesarcipher_basic.py b/app/Tests/test_caesarcipher_basic.py index 14fc632..6f00e7f 100644 --- a/app/Tests/test_caesarcipher_basic.py +++ b/app/Tests/test_caesarcipher_basic.py @@ -1,50 +1,58 @@ import sys -sys.path.append("..") +# sys.path.append("..") + import unittest + from app.Decryptor.basicEncryption.caesar import Caesar -from languageCheckerMod.languageChecker import LanguageChecker +import app.languageCheckerMod.LanguageChecker # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests # python3 -m unittest discover -s Tests -p test*.py # {"lc": self.lc, "IsPlaintext?": True, "Plaintext": translated, "Cipher": "Caesar"} + class TestChi(unittest.TestCase): def test_caesar_yes(self): """Checks to see if it returns True (it should)""" - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("uryyb zl sngure uryyb zl zbgure naq v ernyyl qb yvxr n tbbq ratyvfu oernxsnfg") self.assertEqual(result['IsPlaintext?'], True) + def test_caesar_no(self): """Checks to see if it returns True (it should)""" - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("o iozad iikwas") self.assertEqual(result['IsPlaintext?'], False) + def test_caesar_plaintext_yes(self): """Checks to see if it returns True (it should) Ok so this returns false becaues caesar only does up to 25, not 26 so plaintext returns false!""" - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("What about plaintext?") self.assertEqual(result['IsPlaintext?'], True) + def test_caesar_english_comparison(self): - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("Pm ol ohk hufaopun jvumpkluaphs av zhf, ol dyval pa pu jpwoly, aoha pz, if zv johunpun aol vykly vm aol slaalyz vm aol hswohila, aoha uva h dvyk jvbsk il thkl vba.") self.assertEqual(result['IsPlaintext?'], True) + def test_caesar_english_comparison_yeet(self): - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("Onrs hr mnv knbjdc enq fnnc. Sgzmj xnt zkk enq ozqshbhozshmf, zmc okdzrd bnmshmtd sn unsd enq sgd itcfdldms xnt zfqdd vhsg. Zr nsgdq trdqr gzud onhmsdc nts, sgdqd hr zcchshnmzk hmenqlzshnm sgzs NO gzr kdes nts ne sgdhq nqhfhmzk onrs sgzs sgdx gzud zccdc hm sgdhq bnlldmsr, rn okdzrd qdzc etqsgdq sn fds sgd etkk rbnod ne sgd rhstzshnm.") self.assertEqual(result['Plaintext'], "Post is now locked for good. Thank you all for participating, and please continue to vote for the judgement you agree with. As other users have pointed out, there is additional information that OP has left out of their original post that they have added in their comments, so please read further to get the full scope of the situation.".lower()) + def test_caesar_what_is_this(self): """Checks to see if it returns True (it should) Ok so this returns false becaues caesar only does up to 25, not 26 so plaintext returns false!""" - lc = LanguageChecker() - c = Caesar(lc) + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() + c = Caesar.Caesar(lc) result = c.decrypt("?") self.assertEqual(result['IsPlaintext?'], False) \ No newline at end of file diff --git a/app/Tests/test_chi_squared.py b/app/Tests/test_chi_squared.py index cf42fc0..6f67ed5 100644 --- a/app/Tests/test_chi_squared.py +++ b/app/Tests/test_chi_squared.py @@ -1,7 +1,7 @@ +import unittest import sys sys.path.append("..") -import unittest -from app.languageCheckerMod import chisquared +import app.languageCheckerMod.chisquared # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests # python3 -m unittest discover -s Tests -p test*.py @@ -9,28 +9,28 @@ from app.languageCheckerMod import chisquared class TestChi(unittest.TestCase): def test_chi_english_yes(self): """Checks to see if it returns True (it should)""" - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not """ result = self.chi.checkChi("Hello my name is Brandon and I'm a top secret message") self.assertEqual(result, True) def test_chi_english_caps(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not """ result = self.chi.checkChi("Hello My NaME IS BraNdOnnn And I LOVE You!") self.assertEqual(result, True) def tests_english_no_words(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not """ result = self.chi.checkChi("!!!!!!!!!!!!!!!!!!!") self.assertEqual(result, True) def tests_english_overflow(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not """ @@ -48,7 +48,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("cguakdbwnmfqknm ") self.assertEqual(result, False) def test_english_quckbrown(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not """ @@ -66,7 +66,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("The quick brown fox jumped over the lazy dog") self.assertEqual(result, False) def test_english_puncuation(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not Returns False because exclamation marks aren't english @@ -85,7 +85,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("!!!!!!!!!!!!!!!!!!!!!!") self.assertEqual(result, True) def test_english_one_letter(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not Returns False because exclamation marks aren't english @@ -104,7 +104,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("a") self.assertEqual(result, False) def test_english_same_letter(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not Returns False because exclamation marks aren't english @@ -123,7 +123,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz") self.assertEqual(result, False) def test_english_same_letter(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() """ Tests to see whether a sentene is classified as English or not Returns False because exclamation marks aren't english @@ -142,7 +142,7 @@ class TestChi(unittest.TestCase): result = self.chi.checkChi("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz") self.assertEqual(result, False) def test_my_chi(self): - self.chi = chisquared.chiSquared() + self.chi = app.languageCheckerMod.chisquared.chiSquared() result = self.chi.myChi(self.chi.getLetterFreq("hello this is my test"), [0.0812, 0.0271, 0.0149, 0.1202, 0.0432, 0.0203, 0.023, 0.0731, 0.0592, 0.0069, 0.001, 0.026099999999999998, 0.0398, 0.0768, 0.0695, 0.0011, 0.0182, 0.06280000000000001, 0.0602, 0.0288, 0.091, 0.0209, 0.0111, 0.021099999999999997, 0.0017000000000000001, 0.0007000000000000001]) self.assertEqual(result, 1424.8873999810571) diff --git a/app/Tests/test_integration_languagechecker.py b/app/Tests/test_integration_languagechecker.py index 9653235..17d20d1 100644 --- a/app/Tests/test_integration_languagechecker.py +++ b/app/Tests/test_integration_languagechecker.py @@ -1,24 +1,24 @@ import sys sys.path.append("..") import unittest -from languageCheckerMod.languageChecker import LanguageChecker +import app.languageCheckerMod.LanguageChecker # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests # python3 -m unittest discover -s Tests -p test*.py class TestLanguageChecker(unittest.TestCase): def test_basics(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("Hello my name is new and this is an example of some english text") self.assertEqual(result, True) def test_basics_german(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("hallo keine lieben leute nach") self.assertEqual(result, True) def test_basics_quickbrownfox(self): """ This returns true becaue by default chi squared returns true so long as it's less than 10 items it's processed """ - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") self.assertEqual(result, True) def test_basics_quickbrownfox(self): @@ -29,7 +29,7 @@ class TestLanguageChecker(unittest.TestCase): result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") self.assertEqual(result, True) def test_chi_maxima(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") @@ -46,7 +46,7 @@ class TestLanguageChecker(unittest.TestCase): result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") self.assertEqual(result, False) def test_chi_maxima_false(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") @@ -66,7 +66,7 @@ class TestLanguageChecker(unittest.TestCase): """ This returns false because s.d is not over 1 as all inputs are English """ - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("The quick brown fox jumped over the lazy dog") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") result = lc.checkLanguage("Hypertext Transfer Protocol (HTTP) parameters, including HTTP headers, allow the client and the server to pass additional information with the request or the response.") @@ -86,7 +86,7 @@ class TestLanguageChecker(unittest.TestCase): """ This returns false because s.d is not over 1 as all inputs are English """ - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("sa dew fea dxza dcsa da fsa d") result = lc.checkLanguage("df grtsf a sgrds fgserwqd") result = lc.checkLanguage("fd sa fe safsda srmad sadsa d") @@ -103,49 +103,49 @@ class TestLanguageChecker(unittest.TestCase): result = lc.checkLanguage("My friend is a really nice people who really enjoys swimming, dancing, kicking, English.") self.assertEqual(result, True) def test_integration_unusual_one(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("HELLO MY NAME IS BRANDON AND I LIKE DOLLAR") self.assertEqual(result, True) def test_integration_unusual_two(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") self.assertEqual(result, False) def test_integration_unusual_three(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("password") self.assertEqual(result, True) def test_integration_unusual_three(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("") self.assertEqual(result, False) def test_integration_unusual_four(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage(".") self.assertEqual(result, False) def test_integration_unusual_five(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("#") self.assertEqual(result, False) def test_integration_unusual_6(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("\"") self.assertEqual(result, False) def test_integration_unusual_7(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999") self.assertEqual(result, False) def test_integration_unusual_7(self): - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("") self.assertEqual(result, False) def test_integration_addition(self): """ Makes sure you can add 2 lanuggae objecs together """ - lc = LanguageChecker() + lc = app.languageCheckerMod.LanguageChecker.LanguageChecker() result = lc.checkLanguage("hello my darling") - lc2 = LanguageChecker() + lc2 = app.LanguageChecker() result = lc.checkLanguage("sad as dasr as s") temp = lc.getChiScore() diff --git a/app/Tests/test_neural_network.py b/app/Tests/test_neural_network.py index 7492251..45c38a4 100644 --- a/app/Tests/test_neural_network.py +++ b/app/Tests/test_neural_network.py @@ -1,7 +1,7 @@ import sys sys.path.append("..") import unittest -from neuralNetworkMod.nn import NeuralNetwork +import app.neuralNetworkMod.nn import numpy # python3 -m unittest Tests.testchi_squared # python -m unittest discover -s tests @@ -11,31 +11,31 @@ import numpy class TestNN(unittest.TestCase): def test_english_yes(self): """Checks to see if it returns True (it should)""" - model = NeuralNetwork() + model = app.neuralNetworkMod.nn.NeuralNetwork() result = model.predictnn("bcpvu up qvu ifs cpplt bxbz, cvu jotufbe tif qvmmfe") numpy.set_printoptions(suppress=True) result = numpy.argmax(result) self.assertEqual(result, 4) def test_sha1_yes(self): - model = NeuralNetwork() + model = app.neuralNetworkMod.nn.NeuralNetwork() result = model.predictnn("6D32263A85C7846D70439026B75758C9FC31A9B7") numpy.set_printoptions(suppress=True) result = numpy.argmax(result) self.assertEqual(result, 0) def test_md5_yes(self): - model = NeuralNetwork() + model = app.neuralNetworkMod.nn.NeuralNetwork() result = model.predictnn("5d41402abc4b2a76b9719d911017c592") numpy.set_printoptions(suppress=True) result = numpy.argmax(result) self.assertEqual(result, 1) def test_sha512_yes(self): - model = NeuralNetwork() + model = app.neuralNetworkMod.nn.NeuralNetwork() result = model.predictnn("9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043") numpy.set_printoptions(suppress=True) result = numpy.argmax(result) self.assertEqual(result, 3) def test_caesar_yes(self): - model = NeuralNetwork() + model = app.neuralNetworkMod.nn.NeuralNetwork() result = model.predictnn("bcpvu up qvu ifs cpplt bxbz, cvu jotufbe tif qvmmfe") numpy.set_printoptions(suppress=True) result = numpy.argmax(result) diff --git a/app/__main__.py b/app/__main__.py index 9b7993a..1bfc27b 100644 --- a/app/__main__.py +++ b/app/__main__.py @@ -210,7 +210,7 @@ if __name__ == "__main__": #parser.add_argument('-g','--greppable', help='Are you grepping this output?', required=False) parser.add_argument('-t','--text', help='Text to decrypt', required=False) #parser.add_argument('-s','--sicko-mode', help='If it is encrypted Ciphey WILL find it', required=False) - #parser.add_argument('-c','--cipher', help='What is the cipher used?', required=False) + parser.add_argument('-c','--cipher', help='What is the cipher used?', required=False) args = vars(parser.parse_args()) if args['cipher'] != None: diff --git a/app/languageCheckerMod/LanguageChecker.py b/app/languageCheckerMod/LanguageChecker.py index 256b873..723b1cd 100644 --- a/app/languageCheckerMod/LanguageChecker.py +++ b/app/languageCheckerMod/LanguageChecker.py @@ -46,19 +46,22 @@ In alphabetical order And you're.... Done! Make sure the name of the two match up """ from string import punctuation -#import mathsHelper -import languageCheckerMod.dictionaryChecker -import languageCheckerMod.chisquared +import app.languageCheckerMod.dictionaryChecker +import app.languageCheckerMod.chisquared +from app import languageCheckerMod + class LanguageChecker: def __init__(self): self.dictionary = languageCheckerMod.dictionaryChecker.dictionaryChecker() self.chi = languageCheckerMod.chisquared.chiSquared() + def __add__(self, otherLanguageObject): # sets the added chi squared to be of this one new = otherLanguageObject.getChiSquaredObj() + self.getChiSquaredObj() self.chi = new return self + def checkLanguage(self, text): if text == "": return False @@ -71,7 +74,9 @@ class LanguageChecker: return False else: return False + def getChiSquaredObj(self): return self.chi + def getChiScore(self): return self.chi.totalChi diff --git a/app/languageCheckerMod/chisquared.py b/app/languageCheckerMod/chisquared.py index ed73aa6..52d5376 100644 --- a/app/languageCheckerMod/chisquared.py +++ b/app/languageCheckerMod/chisquared.py @@ -10,7 +10,7 @@ Github: brandonskerritt Class calculates the Chi squared score """ -import mathsHelper +import app.mathsHelper from string import punctuation from numpy import std # I had a bug where empty string was being added to letter freq dictionary @@ -32,7 +32,7 @@ class chiSquared: self.average = 0.0 self.totalDone = 0.0 self.oldAverage = 0.0 - self.mh = mathsHelper.mathsHelper() + self.mh = app.mathsHelper.mathsHelper() self.highestLanguage = "" self.totalChi = 0.0 self.totalEqual = False diff --git a/app/languageCheckerMod/dictionaryChecker.py b/app/languageCheckerMod/dictionaryChecker.py index 9d865ad..7794817 100644 --- a/app/languageCheckerMod/dictionaryChecker.py +++ b/app/languageCheckerMod/dictionaryChecker.py @@ -1,4 +1,4 @@ -import mathsHelper +import app.mathsHelper import string class dictionaryChecker: """ @@ -12,10 +12,11 @@ class dictionaryChecker: if a string is 45% **language** words, then it's confirmed to be english """ def __init__(self): - self.mh = mathsHelper.mathsHelper() + self.mh = app.mathsHelper.mathsHelper() self.languagePercentage = 0.0 self.languageWordsCounter = 0.0 self.languageThreshold = 55 + def checkDictionary(self, text, language): """Compares a word with The dictionary is sorted and the text is sorted""" @@ -49,7 +50,7 @@ class dictionaryChecker: so we only loop once, we can do this in O(n log n) time """ counter = 0 - counterPercent = 0 + counter_percent = 0 for dictLengthCounter, word in enumerate(f): # if there is more words counted than there is text @@ -61,10 +62,10 @@ class dictionaryChecker: # counter + 1 if word in text: counter = counter + 1 - counterPercent = counterPercent + 1 + counter_percent = counter_percent + 1 self.languageWordsCounter = counter self.languagePercentage = self.mh.percentage(float(self.languageWordsCounter), float(len(text))) - return(counter) + return counter def confirmlanguage(self, text, language): self.checkDictionary(text, language) @@ -72,4 +73,3 @@ class dictionaryChecker: return True else: return False - \ No newline at end of file diff --git a/license b/license new file mode 100644 index 0000000..d9fd5e3 --- /dev/null +++ b/license @@ -0,0 +1,7 @@ +Copyright 2020 Brandon Skerritt + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/logo.png b/logo.png new file mode 100644 index 0000000..1674ded Binary files /dev/null and b/logo.png differ diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..ce30c4c --- /dev/null +++ b/setup.py @@ -0,0 +1,42 @@ +import pathlib +from setuptools import setup, find_packages +import io +import os + +# The directory containing this file +HERE = pathlib.Path(__file__).parent + +# The text of the README file +README = (HERE / "README.MD").read_text() +long_description = "An automated decryption tool using machine learning" +DESCRIPTION = "An automated decryption tool using machine learning" + +# get list of required installs +with open('requirements.txt') as f: + required = f.read().splitlines() + +# This call to setup() does all the work +setup( + name="ciphey", + version="2.0.0", + description="Automated decryption tool using machine learning & common sense", + long_description=README, + long_description_content_type="text/markdown", + url="https://github.com/brandonskerritt/ciphey", + author="Brandon Skerritt", + author_email="brandon@skerritt.blog", + license="MIT", + classifiers=[ + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.8", + ], + packages=find_packages(exclude=("tests",)), + include_package_data=True, + install_requires=required, + entry_points={ + "console_scripts": [ + "ciphey=app.__main__:main", + ] + }, +) \ No newline at end of file