opensourcemirror
/
Ciphey
mirror of https://github.com/Ciphey/Ciphey.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed some Pytest stuff

This commit is contained in:
Brandon 2020-04-29 00:41:48 +01:00
parent 0ff379b475
commit 6009f35c14
29 changed files with 253 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.idea/.gitignore vendored Normal file
View File

@ -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/

14
.idea/Ciphey.iml Normal file
View File

@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
<component name="NewModuleRootManager">
<content url="file://$MODULE_DIR$">
<excludeFolder url="file://$MODULE_DIR$/env" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
<component name="PyDocumentationSettings">
<option name="format" value="PLAIN" />
<option name="myDocStringFormat" value="Plain" />
</component>
</module>

6
.idea/inspectionProfiles/profiles_settings.xml Normal file
View File

@ -0,0 +1,6 @@
<component name="InspectionProjectProfileManager">
<settings>
<option name="USE_PROJECT_PROFILE" value="false" />
<version value="1.0" />
</settings>
</component>

7
.idea/misc.xml Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="JavaScriptSettings">
<option name="languageLevel" value="ES6" />
</component>
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8 (Ciphey)" project-jdk-type="Python SDK" />
</project>

8
.idea/modules.xml Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/Ciphey.iml" filepath="$PROJECT_DIR$/.idea/Ciphey.iml" />
</modules>
</component>
</project>

6
.idea/other.xml Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="PySciProjectComponent">
<option name="PY_SCI_VIEW_SUGGESTED" value="true" />
</component>
</project>

6
.idea/vcs.xml Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>

2
MANIFEST.in Normal file
View File

@ -0,0 +1,2 @@
include /appp/languageCheckerMod/*
include README.MD

4
README.MD
View File

@ -1,3 +1,7 @@
![Ciphey][logo.png]
<img src="https://img.shields.io/badge/made%20with-python-blue.svg" alt="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.

0
app/Decryptor/Encoding/__init__.py Normal file
View File

10
app/Decryptor/Encoding/encodingParent.py
View File

@ -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):

0
app/Decryptor/__init__.py Normal file
View File

27
app/Decryptor/basicEncryption/basic_parent.py
View File

@ -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

11
app/Decryptor/basicEncryption/caesar.py
View File

@ -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}

10
app/Decryptor/basicEncryption/reverse.py
View File

@ -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"
return "Reverse"

4
app/Decryptor/basicEncryption/viginere.py
View File

@ -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)

41
app/Tests/test_Encoding.py
View File

@ -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)

24
app/Tests/test_basic_parent.py
View File

@ -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)

36
app/Tests/test_caesarcipher_basic.py
View File

@ -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)

24
app/Tests/test_chi_squared.py
View File

@ -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)

38
app/Tests/test_integration_languagechecker.py
View File

@ -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()

12
app/Tests/test_neural_network.py
View File

@ -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)

2
app/__main__.py
View File

@ -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:

11
app/languageCheckerMod/LanguageChecker.py
View File

@ -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

4
app/languageCheckerMod/chisquared.py
View File

@ -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

12
app/languageCheckerMod/dictionaryChecker.py
View File

@ -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

7
license Normal file
View File

@ -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.

BIN
logo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 60 KiB

42
setup.py Normal file
View File

@ -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",
]
},
)