def __init__(self,
ginp_q=None,
gout_q=None,
host='127.0.0.1',
port=8878,
logF="DefaultServerLog.txt",
inP=sys.stdin,
outP=sys.stdout,
pfile='Password.txt'):
super(CClient, self).__init__()
self.addr = (host, port)
self.pfile = pfile
self.currentLoginInfo = ("", "")
self.loginInfos = {}
self.loadFile(pfile)
self.encryption = Encryption(self.currentLoginInfo[1])
self.logFile = logF
self.socket = socket(AF_INET, SOCK_STREAM)
self.socketConnected = False
self.stoped = False
self.outStream = outP
self.inStream = inP
self.inputThread = threading.Thread(target=self.winput)
self.inputThread.start()
#self.listenningSocket=socket(AF_INET,SOCK_STREAM)
#self.listenningSocket.bind((host,port))
#self.listenningSocket.listen(10)
self.ginp_q = ginp_q
self.gout_q = gout_q
def default_data_admin(self): # Method for creating default data
encryption = encryp.Encryption()
secure_admin_pass = encryption.encrypt_data(
'password') # encrypt default password
self.c.execute(
"INSERT OR IGNORE INTO admininfo(adminid, adminname, password) VALUES (?, ?, ?)",
('admin', 'defaultname', secure_admin_pass))
self.conn.commit()
def enter_newadmin(self, adminid, name,
password): # Method adds new admin to database
encryption = encryp.Encryption()
secure_pass = encryption.encrypt_data(password)
if not secure_pass: # if invalid password given to new admin
tk.messagebox.showerror('Invalid password',
"Please ensure correct data was entered")
else: # add data
self.c.execute(
"INSERT INTO admininfo (adminid, adminname, password)"
" VALUES (?, ?, ?)", (adminid, name, secure_pass))
tk.messagebox.showinfo('Added', 'New admin has been added')
self.conn.commit()
def enter_newuser(self, username, password,
adminid): # Method to allow user to register
encryption = encryp.Encryption()
secure_pass = encryption.encrypt_data(
password) # encrypting user entered password
if not secure_pass: # if unable to encrypt (invalid data)
tk.messagebox.showerror('Invalid password',
"Please ensure correct data was entered")
else:
self.c.execute(
"INSERT INTO userinfo (userid, password, adminid, numlogin)"
" VALUES (?, ?, ?, ?)", (username, secure_pass, adminid, 0))
tk.messagebox.showinfo('Added', 'New user has been added')
self.conn.commit()
def CreateNewClient(self, connectionSocket, addr):
usename = connectionSocket.recv(2048).decode('utf-8')
en = Encryption(usename)
pwd = connectionSocket.recv(2048)
pwd = en.DecryptString(pwd)
en.LoadKey(pwd)
if self.validation.LoginCheck(usename, pwd) != 1:
connectionSocket.close()
return
# print(usename,pwd)
connectionSocket.send('OK'.encode('utf-8'))
newThread = threading.Thread(target=self.commandLine,
args=(connectionSocket, addr))
self.clients[addr] = [newThread, connectionSocket, None, None, en]
newThread.start()
def check_admin_login(self, username,
password): # Method to validate admin login inputs
self.c.execute("SELECT password FROM admininfo WHERE adminid = ?",
(username, ))
check_admin_pass = self.c.fetchone()
if check_admin_pass is None: # no password (no valid adminid so password would be none)
return False
else:
encryption = encryp.Encryption()
check_admin_pass = encryption.decrypt_data(check_admin_pass)
if password == check_admin_pass: # if decrypted password matches entered password
return True
else:
return False
def get_toutiao(self, driver, url):
self.driver = driver
self.base_url = url
self.ennum = Encryption.Encryption()
driver.get(self.base_url + "/")
driver.maximize_window()
title = u"#今日头条#"
event = ""
event += title
driver.find_element_by_xpath("//a[@ga_event='feed_refresh']").click()
time.sleep(2)
menulink = driver.find_elements_by_xpath("//ul[@data-node='listBox']/li[position()<7]//a[@ga_event='feed_title']")
for i in menulink:
event += i.text + "|"
print event
return event
def get_huati(self, driver, url):
self.driver = driver
self.base_url = url
self.ennum = Encryption.Encryption()
driver.get(self.base_url + "/")
driver.maximize_window()
title = u"#今日话题#"
event = ""
event += title
div_src = driver.find_element_by_id("today")
toptitle = driver.find_element_by_id("todaytop")
event += toptitle.text
menulink = div_src.find_elements_by_xpath("//div[@id='today']//li/a[1]")
for i in menulink:
event += i.text+" "
print event
def submitRecordTransaction(self, from_, to_, diseaseId, docLink, hash_):
hashOfDoc = Util.get_hash(
docLink) #update this to get hash of original doc
type_ = 0
e = Encryption(docLink.encode())
token, key = e.encrypt()
#print(e.decrypt(token, key))
tokenKeyMap[token.decode()] = key.decode()
encryptLinkToLinkMap[key.decode()] = docLink
info = {
'diseaseId': diseaseId,
'docLink': token.decode(),
'permmissions': from_,
'hash': hash_
}
return self.newTransaction(from_, to_, type_, info)
def __init__(self,
host='127.0.0.1',
port=8878,
logF="DefaultServerLog.txt",
inP=sys.stdin,
outP=sys.stdout,
pfile='Password.txt'):
self.addr = (host, port)
self.pfile = pfile
self.currentLoginInfo = ("", "")
self.loginInfos = {}
self.loadFile(pfile)
self.encryption = Encryption(self.currentLoginInfo[1])
self.logFile = logF
self.socket = socket(AF_INET, SOCK_STREAM)
self.socketConnected = False
self.stoped = False
self.outStream = outP
self.inStream = inP
self.inputThread = threading.Thread(target=self.winput)
self.inputThread.start()
def check_login(self, username, password): # Method to validate login type
check_admin = self.check_admin_login(
username, password) # check if valid admin loggin in
if check_admin: # if admin
return 'admin'
else:
# is now either user or invalid
encryption = encryp.Encryption()
self.c.execute("SELECT password FROM userinfo WHERE userid = ?",
(username, ))
stored_pass = self.c.fetchone()
if stored_pass is None: # no userid exists (no password)
return 'False'
else:
stored_pass = encryption.decrypt_data(
stored_pass) # decrypt password for userid
if password == stored_pass: # if valid password
self.update_logincounter(
username) # update user log in counter
return "user"
else:
return 'False'
def __init__(self, username=None, password=None):
try:
self.encryption = Encryption.Encryption()
except Encryption.EncryptionException as error:
self.__notify_message('notification',
'Encryption error ' + str(error))
self.encryption = Encryption.Encryption()
self.__notify_message(
'notification', 'Encryption is ' +
('enabled' if self.encryption.isEnabled() else 'disabled'))
self.portal_url = 'https://choozze.me'
self.online_pages = {
'login': '******',
'account': '',
'voicemail': 'voicemail.php',
'callforward': 'forward.php'
}
self.login_cookie = None
self.login_ok = False
self.reset_settings(False)
# Login regexes
self.login_detect_regex = re.compile(
'<input type=("|\')?hidden("|\')? name=("|\')?action("|\')? value=("|\')?login("|\')? />'
)
self.valid_email_regex = re.compile(
"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
)
self.regex_logged_in = re.compile('Welkom Choozzer!')
# Account regexes
self.regex_phonenumber = re.compile(
'<p>.*nummer:\s(?P<phonenumber>\+\d{11})\s*<\/p>')
self.regex_mobile_plan = re.compile(
'<p>.*gekozen voor\s*(?P<mobileplan>[^</]+)<\/p>')
self.regex_extra_costs = re.compile(
'<p>Buitenbundelkosten:\s(?P<currentcy>.*)(?P<extra_costs>\d+,\d+)\s*<\/p>'
)
self.regex_sms_usage = re.compile(
'(?P<totalsms>\d+) SMSjes[^)]+ \((?P<usedsms>\d+)%')
self.regex_call_usage = re.compile(
'(?P<totalcall>\d+) belminuten[^)]+ \((?P<usedcall>\d+)%')
self.regex_data_usage = re.compile(
'(?P<totaldata>\d+)(?P<dataunit>[(M|G)B]+) mobiel internet[^)]+\((?P<useddata>\d+)%'
)
self.internetdata_unit = 1000
# Voicemail regexes
self.regex_voicemail_active = re.compile(
'Jouw voicemail is\s?(?P<active>[^\s]+)? actief')
self.regex_voicemail_pin = re.compile(
'placeholder=("|\')?Pincode("|\')?.*value=("|\')?(?P<pincode>\d{4})("|\')?'
)
self.regex_voicemail_email = re.compile(
'type=("|\')?email("|\')?.*value=("|\')?(?P<voicemailemail>[^("|\')?]+)("|\')?'
)
# Callforward regexes
self.regex_callforward_direct = re.compile(
'type=("|\')?text("|\')?.*((name|id)=("|\')?cfim("|\')?){1,2}.*value=("|\')?(?P<direct>[^("|\')?]+)("|\')?'
)
self.regex_callforward_busy = re.compile(
'type=("|\')?text("|\')?.*((name|id)=("|\')?cfbs("|\')?){1,2}.*value=("|\')?(?P<busy>[^("|\')?]+)("|\')?'
)
self.__load_application_data()
self.__history_fields = {
'data_update_timeout', 'mobile_plan', 'extra_costs', 'sms_usage',
'call_usage', 'data_usage', 'days_usage', 'voicemail_active',
'callforward_active'
}
self.__load_application_history()
if username is not None:
self.set_username(username)
if password is not None:
self.set_password(password)
if self.login():
self.__get_online_data()
self.updater = threading.Thread(target=self.__auto_update)
self.updater.daemon = True
self.updater.start()
#!C:/python/python.exe
import sys
sys.path.insert(0, r'D:\Lib')
import cgi
import time
import Encryption
from Cheetah.Template import Template
from com.finnean.database.connection import SQLiteConnection
from com.finnean.database.cursor import SQLiteDictionaryCursor
from com.finnean.database.query import SQLiteQuery
from objects import Login
# encryption key
pass_key = 'rcCE3qqHyD3LSNH73vKzPhW3aURH4nSH'
enc = Encryption.Encryption(passkey=pass_key)
# database
database = SQLiteConnection.SQLiteConnection()
connection = database.connect(r'D:\wamp\apps\sqlitemanager1.2.0\Butters.db')
cursor = SQLiteDictionaryCursor.SQLiteDictionaryCursor(connection).get()
query = SQLiteQuery.SQLiteQuery()
query.setCursor(cursor)
query.setExceptionHandler(database.getExceptionHandler())
# cgi
form = cgi.FieldStorage()
username = form.getvalue('username')
passwd = form.getvalue('passwd')
def getEncryption(self, proxy):
if self.client_keypair_generate == TRUE and self.server_keypair_generate == TRUE:
raise ValueError, 'client_keypair_generate and server_keypair_generate are both enabled. '\
'Key generation cannot work on both sides at the same time.'
if not self.isEncryptionUsed():
return Encryption(client_security=SSL_NONE,
server_security=SSL_NONE)
if not hasattr(self, "client_connection_security"):
self.client_connection_security = SSL_NONE
if not hasattr(self, "server_connection_security"):
self.server_connection_security = SSL_NONE
client_method = ENCRYPTION_METHOD_SSLV23
server_method = ENCRYPTION_METHOD_SSLV23
if hasattr(self, "client_ssl_method"):
if self.client_ssl_method == SSL_METHOD_SSLV23:
client_method = ENCRYPTION_METHOD_SSLV23
elif self.client_ssl_method == SSL_METHOD_SSLV3:
client_method = ENCRYPTION_METHOD_SSLV3
elif self.client_ssl_method == SSL_METHOD_TLSV1:
client_method = ENCRYPTION_METHOD_TLSV1
elif self.client_ssl_method == SSL_METHOD_ALL:
client_method = ENCRYPTION_METHOD_SSLV23
else:
client_method = 5 #Bad method
if hasattr(self, "server_ssl_method"):
if self.server_ssl_method == SSL_METHOD_SSLV23:
server_method = ENCRYPTION_METHOD_SSLV23
elif self.server_ssl_method == SSL_METHOD_SSLV3:
server_method = ENCRYPTION_METHOD_SSLV3
elif self.server_ssl_method == SSL_METHOD_TLSV1:
server_method = ENCRYPTION_METHOD_TLSV1
elif self.server_ssl_method == SSL_METHOD_ALL:
server_method = ENCRYPTION_METHOD_SSLV23
else:
server_method = 5 #Bad method
encryption = Encryption(
client_security=self.client_connection_security,
server_security=self.server_connection_security,
client_method=client_method,
server_method=server_method)
encryption.settings.client_handshake[
"verify_cert_ext"] = self.client_handshake["verify_cert_ext"]
encryption.settings.server_handshake[
"verify_cert_ext"] = self.server_handshake["verify_cert_ext"]
if self.client_connection_security > SSL_NONE:
if hasattr(self, "client_cert") and type(
self.client_cert) == types.StringType:
self.client_cert_file = self.client_cert
if hasattr(self, "client_key") and type(
self.client_key) == types.StringType:
self.client_key_file = self.client_key
if hasattr(self, "client_keypair_files"):
self.client_cert_file = self.client_keypair_files[0]
self.client_key_file = self.client_keypair_files[1]
if hasattr(self, "client_cagroup_directories"):
self.client_ca_directory = self.client_cagroup_directories[0]
self.client_crl_directory = self.client_cagroup_directories[1]
if hasattr(self, "client_verify_cagroup_directories"):
self.client_verify_ca_directory = self.client_verify_cagroup_directories[
0]
self.client_verify_crl_directory = self.client_verify_cagroup_directories[
1]
if hasattr(self, "client_cert_file"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing client_cert_file; value='%s'"
% self.client_cert_file)
proxy.tls.client_local_certificate = self.readPEM(
self.client_cert_file)
if hasattr(self, "client_key_file"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing client_key_file; value='%s'"
% self.client_key_file)
proxy.tls.client_local_privatekey = self.readPEM(
self.client_key_file)
if hasattr(self, "client_ca_directory"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing client_ca_directory; value='%s'"
% self.client_ca_directory)
#self.readHashDir(self.client_local_ca_list, self.client_ca_directory)
self.readHashDir(encryption.settings.client_local_ca_list,
self.client_ca_directory)
if hasattr(self, "client_crl_directory"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing client_crl_directory; value='%s'"
% self.client_crl_directory)
#self.readHashDir(self.client_local_crl_list, self.client_crl_directory)
self.readHashDir(encryption.settings.client_local_crl_list,
self.client_crl_directory)
if self.client_keypair_generate:
if self.handshake_seq != SSL_HSO_SERVER_CLIENT:
raise ValueError, "For client-side keypair generation, the handshake order"\
" must be SSL_HSO_SERVER_CLIENT."
else:
encryption.settings.client_handshake["setup_key"] = (
SSL_HS_POLICY, self.generateKeyClient)
if self.server_connection_security > SSL_NONE:
if hasattr(self, "server_cert") and type(
self.server_cert) == types.StringType:
self.server_cert_file = self.server_cert
if hasattr(self, "server_key") and type(
self.server_key) == types.StringType:
self.server_key_file = self.server_key
if hasattr(self, "server_keypair_files"):
self.server_cert_file = self.server_keypair_files[0]
self.server_key_file = self.server_keypair_files[1]
if hasattr(self, "server_cagroup_directories"):
self.server_ca_directory = self.server_cagroup_directories[0]
self.server_crl_directory = self.server_cagroup_directories[1]
if hasattr(self, "server_verify_cagroup_directories"):
self.server_verify_ca_directory = self.server_verify_cagroup_directories[
0]
self.server_verify_crl_directory = self.server_verify_cagroup_directories[
1]
if hasattr(self, "server_cert_file"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing server_cert_file; value='%s'"
% self.server_cert_file)
proxy.tls.server_local_certificate = self.readPEM(
self.server_cert_file)
if hasattr(self, "server_key_file"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing server_key_file; value='%s'"
% self.server_key_file)
proxy.tls.server_local_privatekey = self.readPEM(
self.server_key_file)
if hasattr(self, "server_ca_directory"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing server_ca_directory; value='%s'"
% self.server_ca_directory)
#self.readHashDir(self.server_local_ca_list, self.server_ca_directory)
self.readHashDir(encryption.settings.server_local_ca_list,
self.server_ca_directory)
if hasattr(self, "server_crl_directory"):
log(
proxy.session.session_id, SSL_DEBUG, 6,
"Compatibility feature, processing server_crl_directory; value='%s'"
% self.server_crl_directory)
#self.readHashDir(self.server_local_crl_list, self.server_crl_directory)
self.readHashDir(encryption.settings.server_local_crl_list,
self.server_crl_directory)
if self.server_keypair_generate:
if self.handshake_seq != SSL_HSO_CLIENT_SERVER:
raise ValueError, "For server-side keypair generation, the handshake order"\
" must be SSL_HSO_CLIENT_SERVER."
else:
encryption.settings.server_handshake["setup_key"] = (
SSL_HS_POLICY, self.generateKeyServer)
if hasattr(self, "handshake_seq"):
encryption.settings.handshake_seq = self.handshake_seq
if hasattr(self, "handshake_timeout"):
encryption.settings.handshake_timeout = self.handshake_timeout
if hasattr(self, "permit_invalid_certificates"):
encryption.settings.client_permit_invalid_certificates = self.permit_invalid_certificates
encryption.settings.server_permit_invalid_certificates = self.permit_invalid_certificates
if hasattr(self, "permit_missing_crl"):
encryption.settings.client_permit_missing_crl = self.permit_missing_crl
encryption.settings.server_permit_missing_crl = self.permit_missing_crl
if hasattr(self, "client_verify_type"):
encryption.settings.client_verify_type = self.client_verify_type
if hasattr(self, "client_disable_proto_sslv3"):
encryption.settings.client_disable_proto_sslv3 = self.client_disable_proto_sslv3
if hasattr(self, "client_disable_proto_tlsv1"):
encryption.settings.client_disable_proto_tlsv1 = self.client_disable_proto_tlsv1
if hasattr(self, "client_ssl_cipher"):
encryption.settings.client_ssl_cipher = self.client_ssl_cipher
if hasattr(self, "client_verify_ca_directory"):
encryption.settings.client_verify_ca_directory = self.client_verify_ca_directory
if hasattr(self, "client_verify_crl_directory"):
encryption.settings.client_verify_crl_directory = self.client_verify_crl_directory
if hasattr(self, "client_verify_depth"):
encryption.settings.client_verify_depth = self.client_verify_depth
if hasattr(self, "server_verify_type"):
encryption.settings.server_verify_type = self.server_verify_type
if hasattr(self, "server_check_subject"):
encryption.settings.server_check_subject = self.server_check_subject
if hasattr(self, "server_disable_proto_sslv3"):
encryption.settings.server_disable_proto_sslv3 = self.server_disable_proto_sslv3
if hasattr(self, "server_disable_proto_tlsv1"):
encryption.settings.server_disable_proto_tlsv1 = self.server_disable_proto_tlsv1
if hasattr(self, "server_ssl_cipher"):
encryption.settings.server_ssl_cipher = self.server_ssl_cipher
if hasattr(self, "server_verify_ca_directory"):
encryption.settings.server_verify_ca_directory = self.server_verify_ca_directory
if hasattr(self, "server_verify_crl_directory"):
encryption.settings.server_verify_crl_directory = self.server_verify_crl_directory
if hasattr(self, "server_verify_depth"):
encryption.settings.server_verify_depth = self.server_verify_depth
if not encryption.setup():
raise Exception, "Encryption.setup() returned error;"
return encryption
def setUp(self):
print "staring"
self.driver = webdriver.PhantomJS()
self.driver.implicitly_wait(30)
self.ennum = Encryption.Encryption()
self.news = Getnews.News()
