Upload 2 files

app1.py

@@ -0,0 +1,26 @@
+import sys
+sys.path.append('G:\Project\phishing-detection')
+from phishingdetection import FeatureExtraction
+import numpy as np
+from phishingdetection import gbc
+import streamlit as st
+
+st.title("Phishing Website Detection")
+#
+# User input for URL
+url = st.text_input("Enter the Url:", key="url_input")
+#can provide any URL. this URL was taken from PhishTank
+
+# Predict and display the result
+if st.button("Check"):
+    if url:
+        obj = FeatureExtraction(url)
+        x = np.array(obj.getFeaturesList()).reshape(1, 30)
+        y_pred = gbc.predict(x)[0]
+        if y_pred == 1:
+            st.write("We guess it is a safe website")
+        else:
+            st.write("Caution! Suspicious website detected")
+        st.write(y_pred)
+    else:
+        st.write("Please enter a URL.")

phishingdetection.py

@@ -0,0 +1,722 @@
+import os 
+os.system("pip install seaborn")
+os.system("pip install scikit-learn")
+os.system("pip install whois")
+os.system("pip install googlesearch-python")
+import numpy as np # linear algebra
+import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
+
+import matplotlib.pyplot as plt
+#%matplotlib inline
+import seaborn as sns
+from sklearn import metrics 
+import warnings
+warnings.filterwarnings('ignore')
+
+data = pd.read_csv('phishing.csv')
+data.head(20)
+
+data.columns
+len(data.columns)
+data.isnull().sum()
+X = data.drop(["class","Index"],axis =1)
+y = data["class"]
+
+fig, ax = plt.subplots(1, 1, figsize=(15, 9))
+sns.heatmap(data.corr(), annot=True,cmap='viridis')
+plt.title('Correlation between different features', fontsize = 15, c='black')
+plt.show()
+
+corr=data.corr()
+corr.head()
+
+corr['class']=abs(corr['class'])
+corr.head()
+
+incCorr=corr.sort_values(by='class',ascending=False)
+incCorr.head()
+
+incCorr['class']
+
+tenfeatures=incCorr[1:11].index
+twenfeatures=incCorr[1:21].index
+
+#Structutre to Store metrics
+ML_Model = []
+accuracy = []
+f1_score = []
+precision = []
+
+def storeResults(model, a,b,c):
+  ML_Model.append(model)
+  accuracy.append(round(a, 3))
+  f1_score.append(round(b, 3))
+  precision.append(round(c, 3))
+
+def KNN(X):
+  x=[a for a in range(1,10,2)]
+  knntrain=[]
+  knntest=[]
+  from sklearn.model_selection import train_test_split
+  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
+  X_train.shape, y_train.shape, X_test.shape, y_test.shape
+  for i in range(1,10,2):
+    from sklearn.neighbors import KNeighborsClassifier
+    knn = KNeighborsClassifier(n_neighbors=i)
+    knn.fit(X_train,y_train)
+    y_train_knn = knn.predict(X_train)
+    y_test_knn = knn.predict(X_test)
+    acc_train_knn = metrics.accuracy_score(y_train,y_train_knn)
+    acc_test_knn = metrics.accuracy_score(y_test,y_test_knn)
+    print("K-Nearest Neighbors with k={}: Accuracy on training Data: {:.3f}".format(i,acc_train_knn))
+    print("K-Nearest Neighbors with k={}: Accuracy on test Data: {:.3f}".format(i,acc_test_knn))
+    knntrain.append(acc_train_knn)
+    knntest.append(acc_test_knn)
+    print()
+  import matplotlib.pyplot as plt
+  plt.plot(x,knntrain,label="Train accuracy")
+  plt.plot(x,knntest,label="Test accuracy")
+  plt.legend()
+  plt.show()
+
+Xmain=X
+Xten=X[tenfeatures]
+Xtwen=X[twenfeatures]
+
+KNN(Xmain)
+
+KNN(Xten)
+
+KNN(Xtwen)
+
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
+X_train.shape, y_train.shape, X_test.shape, y_test.shape
+
+knn = KNeighborsClassifier(n_neighbors=5)
+knn.fit(X_train,y_train)
+
+y_train_knn = knn.predict(X_train)
+y_test_knn = knn.predict(X_test)
+
+acc_train_knn = metrics.accuracy_score(y_train,y_train_knn)
+acc_test_knn = metrics.accuracy_score(y_test,y_test_knn)
+
+f1_score_train_knn = metrics.f1_score(y_train,y_train_knn)
+f1_score_test_knn = metrics.f1_score(y_test,y_test_knn)
+
+precision_score_train_knn = metrics.precision_score(y_train,y_train_knn)
+precision_score_test_knn = metrics.precision_score(y_test,y_test_knn)
+
+storeResults('K-Nearest Neighbors',acc_test_knn,f1_score_test_knn,precision_score_train_knn)
+
+def SVM(X, y):
+    x=[a for a in range(1,10,2)]
+    svmtrain=[]
+    svmtest=[]
+    from sklearn.model_selection import train_test_split
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
+    X_train.shape, y_train.shape, X_test.shape, y_test.shape
+    from sklearn.svm import SVC
+    for i in range(1,10,2):
+        svm = SVC(kernel='linear', C=i)
+        svm.fit(X_train, y_train)
+        y_train_svm = svm.predict(X_train)
+        y_test_svm = svm.predict(X_test)
+        acc_train_svm = metrics.accuracy_score(y_train, y_train_svm)
+        acc_test_svm = metrics.accuracy_score(y_test, y_test_svm)
+        print("SVM with C={}: Accuracy on training Data: {:.3f}".format(i,acc_train_svm))
+        print("SVM with C={}: Accuracy on test Data: {:.3f}".format(i,acc_test_svm))
+        svmtrain.append(acc_train_svm)
+        svmtest.append(acc_test_svm)
+        print()
+    import matplotlib.pyplot as plt
+    plt.plot(x,svmtrain,label="Train accuracy")
+    plt.plot(x,svmtest,label="Test accuracy")
+    plt.legend()
+    plt.show()
+
+
+Xmain=X
+Xten=X[tenfeatures]
+Xtwen=X[twenfeatures]
+
+SVM(Xmain,y)
+SVM(Xten,y)
+SVM(Xtwen,y)
+
+from sklearn.model_selection import train_test_split
+from sklearn.svm import SVC
+from sklearn import metrics
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+svm = SVC(kernel='linear', C=1, random_state=42)
+svm.fit(X_train, y_train)
+
+
+y_train_svm = svm.predict(X_train)
+y_test_svm = svm.predict(X_test)
+
+
+acc_train_svm = metrics.accuracy_score(y_train, y_train_svm)
+acc_test_svm = metrics.accuracy_score(y_test, y_test_svm)
+
+f1_score_train_svm = metrics.f1_score(y_train, y_train_svm)
+f1_score_test_svm = metrics.f1_score(y_test, y_test_svm)
+
+precision_score_train_svm = metrics.precision_score(y_train, y_train_svm)
+precision_score_test_svm = metrics.precision_score(y_test, y_test_svm)
+
+print("SVM with C={}: Accuracy on training data: {:.3f}".format(1, acc_train_svm))
+print("SVM with C={}: Accuracy on test data: {:.3f}".format(1, acc_test_svm))
+print("SVM with C={}: F1 score on training data: {:.3f}".format(1, f1_score_train_svm))
+print("SVM with C={}: F1 score on test data: {:.3f}".format(1, f1_score_test_svm))
+print("SVM with C={}: Precision on training data: {:.3f}".format(1, precision_score_train_svm))
+print("SVM with C={}: Precision on test data: {:.3f}".format(1, precision_score_test_svm))
+
+storeResults('Support Vector Machines',acc_test_svm,f1_score_test_svm,precision_score_train_svm)
+
+from sklearn.model_selection import train_test_split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
+X_train.shape, y_train.shape, X_test.shape, y_test.shape
+
+from sklearn.ensemble import GradientBoostingClassifier
+gbc = GradientBoostingClassifier(max_depth=4,learning_rate=0.7)
+gbc.fit(X_train,y_train)
+
+y_train_gbc = gbc.predict(X_train)
+y_test_gbc = gbc.predict(X_test)
+
+acc_train_gbc = metrics.accuracy_score(y_train,y_train_gbc)
+acc_test_gbc = metrics.accuracy_score(y_test,y_test_gbc)
+print("Gradient Boosting Classifier : Accuracy on training Data: {:.3f}".format(acc_train_gbc))
+print("Gradient Boosting Classifier : Accuracy on test Data: {:.3f}".format(acc_test_gbc))
+print()
+
+f1_score_train_gbc = metrics.f1_score(y_train,y_train_gbc)
+f1_score_test_gbc = metrics.f1_score(y_test,y_test_gbc)
+
+precision_score_train_gbc = metrics.precision_score(y_train,y_train_gbc)
+precision_score_test_gbc = metrics.precision_score(y_test,y_test_gbc)
+
+storeResults('Gradient Boosting Classifier',acc_test_gbc,f1_score_test_gbc,precision_score_train_gbc)
+
+df = pd.DataFrame({
+    'Modelname': ML_Model,
+    'Accuracy Score': accuracy,
+    'F1 Score': f1_score,
+    'Precision Score': precision
+})
+df.set_index('Modelname', inplace=True)
+
+# plot the scores for each model
+
+fig, ax = plt.subplots(figsize=(10,10))
+df.plot(kind='bar', ax=ax)
+ax.set_xticklabels(df.index, rotation=0)
+ax.set_ylim([0.9, 1])
+ax.set_yticks([0.9,0.91,0.92,0.93,0.94,0.95,0.96,0.97,0.98,0.99,1])
+ax.set_xlabel('Model')
+ax.set_ylabel('Score')
+ax.set_title('Model Scores')
+plt.show()
+
+import whois
+
+import googlesearch
+
+import ipaddress
+import re
+import urllib.request
+from bs4 import BeautifulSoup
+import socket
+import requests
+import google
+import whois
+from datetime import date, datetime
+import time
+from dateutil.parser import parse as date_parse
+from urllib.parse import urlparse
+
+class FeatureExtraction:
+    features = []
+    def __init__(self,url):
+        self.features = []
+        self.url = url
+        self.domain = ""
+        self.whois_response = ""
+        self.urlparse = ""
+        self.response = ""
+        self.soup = ""
+
+        try:
+            self.response = requests.get(url)
+            self.soup = BeautifulSoup(response.text, 'html.parser')
+        except:
+            pass
+
+        try:
+            self.urlparse = urlparse(url)
+            self.domain = self.urlparse.netloc
+        except:
+            pass
+
+        try:
+            self.whois_response = whois.whois(self.domain)
+        except:
+            pass
+
+
+        
+
+        self.features.append(self.UsingIp())
+        self.features.append(self.longUrl())
+        self.features.append(self.shortUrl())
+        self.features.append(self.symbol())
+        self.features.append(self.redirecting())
+        self.features.append(self.prefixSuffix())
+        self.features.append(self.SubDomains())
+        self.features.append(self.Hppts())
+        self.features.append(self.DomainRegLen())
+        self.features.append(self.Favicon())
+        
+
+        self.features.append(self.NonStdPort())
+        self.features.append(self.HTTPSDomainURL())
+        self.features.append(self.RequestURL())
+        self.features.append(self.AnchorURL())
+        self.features.append(self.LinksInScriptTags())
+        self.features.append(self.ServerFormHandler())
+        self.features.append(self.InfoEmail())
+        self.features.append(self.AbnormalURL())
+        self.features.append(self.WebsiteForwarding())
+        self.features.append(self.StatusBarCust())
+
+        self.features.append(self.DisableRightClick())
+        self.features.append(self.UsingPopupWindow())
+        self.features.append(self.IframeRedirection())
+        self.features.append(self.AgeofDomain())
+        self.features.append(self.DNSRecording())
+        self.features.append(self.WebsiteTraffic())
+        self.features.append(self.PageRank())
+        self.features.append(self.GoogleIndex())
+        self.features.append(self.LinksPointingToPage())
+        self.features.append(self.StatsReport())
+
+
+     # 1.UsingIp
+    def UsingIp(self):
+        try:
+            ipaddress.ip_address(self.url)
+            return -1
+        except:
+            return 1
+
+    # 2.longUrl
+    def longUrl(self):
+        if len(self.url) < 54:
+            return 1
+        if len(self.url) >= 54 and len(self.url) <= 75:
+            return 0
+        return -1
+
+    # 3.shortUrl
+    def shortUrl(self):
+        match = re.search('bit\.ly|goo\.gl|shorte\.st|go2l\.ink|x\.co|ow\.ly|t\.co|tinyurl|tr\.im|is\.gd|cli\.gs|'
+                    'yfrog\.com|migre\.me|ff\.im|tiny\.cc|url4\.eu|twit\.ac|su\.pr|twurl\.nl|snipurl\.com|'
+                    'short\.to|BudURL\.com|ping\.fm|post\.ly|Just\.as|bkite\.com|snipr\.com|fic\.kr|loopt\.us|'
+                    'doiop\.com|short\.ie|kl\.am|wp\.me|rubyurl\.com|om\.ly|to\.ly|bit\.do|t\.co|lnkd\.in|'
+                    'db\.tt|qr\.ae|adf\.ly|goo\.gl|bitly\.com|cur\.lv|tinyurl\.com|ow\.ly|bit\.ly|ity\.im|'
+                    'q\.gs|is\.gd|po\.st|bc\.vc|twitthis\.com|u\.to|j\.mp|buzurl\.com|cutt\.us|u\.bb|yourls\.org|'
+                    'x\.co|prettylinkpro\.com|scrnch\.me|filoops\.info|vzturl\.com|qr\.net|1url\.com|tweez\.me|v\.gd|tr\.im|link\.zip\.net', self.url)
+        if match:
+            return -1
+        return 1
+
+    # 4.Symbol@
+    def symbol(self):
+        if re.findall("@",self.url):
+            return -1
+        return 1
+    
+    # 5.Redirecting//
+    def redirecting(self):
+        if self.url.rfind('//')>6:
+            return -1
+        return 1
+    
+    # 6.prefixSuffix
+    def prefixSuffix(self):
+        try:
+            match = re.findall('\-', self.domain)
+            if match:
+                return -1
+            return 1
+        except:
+            return -1
+    
+    # 7.SubDomains
+    def SubDomains(self):
+        dot_count = len(re.findall("\.", self.url))
+        if dot_count == 1:
+            return 1
+        elif dot_count == 2:
+            return 0
+        return -1
+
+    # 8.HTTPS
+    def Hppts(self):
+        try:
+            https = self.urlparse.scheme
+            if 'https' in https:
+                return 1
+            return -1
+        except:
+            return 1
+
+    # 9.DomainRegLen
+    def DomainRegLen(self):
+        try:
+            expiration_date = self.whois_response.expiration_date
+            creation_date = self.whois_response.creation_date
+            try:
+                if(len(expiration_date)):
+                    expiration_date = expiration_date[0]
+            except:
+                pass
+            try:
+                if(len(creation_date)):
+                    creation_date = creation_date[0]
+            except:
+                pass
+
+            age = (expiration_date.year-creation_date.year)*12+ (expiration_date.month-creation_date.month)
+            if age >=12:
+                return 1
+            return -1
+        except:
+            return -1
+
+    # 10. Favicon
+    def Favicon(self):
+        try:
+            for head in self.soup.find_all('head'):
+                for head.link in self.soup.find_all('link', href=True):
+                    dots = [x.start(0) for x in re.finditer('\.', head.link['href'])]
+                    if self.url in head.link['href'] or len(dots) == 1 or domain in head.link['href']:
+                        return 1
+            return -1
+        except:
+            return -1
+
+    # 11. NonStdPort
+    def NonStdPort(self):
+        try:
+            port = self.domain.split(":")
+            if len(port)>1:
+                return -1
+            return 1
+        except:
+            return -1
+
+    # 12. HTTPSDomainURL
+    def HTTPSDomainURL(self):
+        try:
+            if 'https' in self.domain:
+                return -1
+            return 1
+        except:
+            return -1
+    
+    # 13. RequestURL
+    def RequestURL(self):
+        try:
+            for img in self.soup.find_all('img', src=True):
+                dots = [x.start(0) for x in re.finditer('\.', img['src'])]
+                if self.url in img['src'] or self.domain in img['src'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            for audio in self.soup.find_all('audio', src=True):
+                dots = [x.start(0) for x in re.finditer('\.', audio['src'])]
+                if self.url in audio['src'] or self.domain in audio['src'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            for embed in self.soup.find_all('embed', src=True):
+                dots = [x.start(0) for x in re.finditer('\.', embed['src'])]
+                if self.url in embed['src'] or self.domain in embed['src'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            for iframe in self.soup.find_all('iframe', src=True):
+                dots = [x.start(0) for x in re.finditer('\.', iframe['src'])]
+                if self.url in iframe['src'] or self.domain in iframe['src'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            try:
+                percentage = success/float(i) * 100
+                if percentage < 22.0:
+                    return 1
+                elif((percentage >= 22.0) and (percentage < 61.0)):
+                    return 0
+                else:
+                    return -1
+            except:
+                return 0
+        except:
+            return -1
+    
+    # 14. AnchorURL
+    def AnchorURL(self):
+        try:
+            i,unsafe = 0,0
+            for a in self.soup.find_all('a', href=True):
+                if "#" in a['href'] or "javascript" in a['href'].lower() or "mailto" in a['href'].lower() or not (url in a['href'] or self.domain in a['href']):
+                    unsafe = unsafe + 1
+                i = i + 1
+
+            try:
+                percentage = unsafe / float(i) * 100
+                if percentage < 31.0:
+                    return 1
+                elif ((percentage >= 31.0) and (percentage < 67.0)):
+                    return 0
+                else:
+                    return -1
+            except:
+                return -1
+
+        except:
+            return -1
+
+    # 15. LinksInScriptTags
+    def LinksInScriptTags(self):
+        try:
+            i,success = 0,0
+        
+            for link in self.soup.find_all('link', href=True):
+                dots = [x.start(0) for x in re.finditer('\.', link['href'])]
+                if self.url in link['href'] or self.domain in link['href'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            for script in self.soup.find_all('script', src=True):
+                dots = [x.start(0) for x in re.finditer('\.', script['src'])]
+                if self.url in script['src'] or self.domain in script['src'] or len(dots) == 1:
+                    success = success + 1
+                i = i+1
+
+            try:
+                percentage = success / float(i) * 100
+                if percentage < 17.0:
+                    return 1
+                elif((percentage >= 17.0) and (percentage < 81.0)):
+                    return 0
+                else:
+                    return -1
+            except:
+                return 0
+        except:
+            return -1
+
+    # 16. ServerFormHandler
+    def ServerFormHandler(self):
+        try:
+            if len(self.soup.find_all('form', action=True))==0:
+                return 1
+            else :
+                for form in self.soup.find_all('form', action=True):
+                    if form['action'] == "" or form['action'] == "about:blank":
+                        return -1
+                    elif self.url not in form['action'] and self.domain not in form['action']:
+                        return 0
+                    else:
+                        return 1
+        except:
+            return -1
+
+    # 17. InfoEmail
+    def InfoEmail(self):
+        try:
+            if re.findall(r"[mail\(\)|mailto:?]", self.soap):
+                return -1
+            else:
+                return 1
+        except:
+            return -1
+
+    # 18. AbnormalURL
+    def AbnormalURL(self):
+        try:
+            if self.response.text == self.whois_response:
+                return 1
+            else:
+                return -1
+        except:
+            return -1
+
+    # 19. WebsiteForwarding
+    def WebsiteForwarding(self):
+        try:
+            if len(self.response.history) <= 1:
+                return 1
+            elif len(self.response.history) <= 4:
+                return 0
+            else:
+                return -1
+        except:
+             return -1
+
+    # 20. StatusBarCust
+    def StatusBarCust(self):
+        try:
+            if re.findall("<script>.+onmouseover.+</script>", self.response.text):
+                return 1
+            else:
+                return -1
+        except:
+             return -1
+
+    # 21. DisableRightClick
+    def DisableRightClick(self):
+        try:
+            if re.findall(r"event.button ?== ?2", self.response.text):
+                return 1
+            else:
+                return -1
+        except:
+             return -1
+
+    # 22. UsingPopupWindow
+    def UsingPopupWindow(self):
+        try:
+            if re.findall(r"alert\(", self.response.text):
+                return 1
+            else:
+                return -1
+        except:
+             return -1
+
+    # 23. IframeRedirection
+    def IframeRedirection(self):
+        try:
+            if re.findall(r"[<iframe>|<frameBorder>]", self.response.text):
+                return 1
+            else:
+                return -1
+        except:
+             return -1
+
+    # 24. AgeofDomain
+    def AgeofDomain(self):
+        try:
+            creation_date = self.whois_response.creation_date
+            try:
+                if(len(creation_date)):
+                    creation_date = creation_date[0]
+            except:
+                pass
+
+            today  = date.today()
+            age = (today.year-creation_date.year)*12+(today.month-creation_date.month)
+            if age >=6:
+                return 1
+            return -1
+        except:
+            return -1
+
+    # 25. DNSRecording    
+    def DNSRecording(self):
+        try:
+            creation_date = self.whois_response.creation_date
+            try:
+                if(len(creation_date)):
+                    creation_date = creation_date[0]
+            except:
+                pass
+
+            today  = date.today()
+            age = (today.year-creation_date.year)*12+(today.month-creation_date.month)
+            if age >=6:
+                return 1
+            return -1
+        except:
+            return -1
+
+    # 26. WebsiteTraffic   
+    def WebsiteTraffic(self):
+        try:
+            rank = BeautifulSoup(urllib.request.urlopen("http://data.alexa.com/data?cli=10&dat=s&url=" + url).read(), "xml").find("REACH")['RANK']
+            if (int(rank) < 100000):
+                return 1
+            return 0
+        except :
+            return -1
+
+    # 27. PageRank
+    def PageRank(self):
+        try:
+            prank_checker_response = requests.post("https://www.checkpagerank.net/index.php", {"name": self.domain})
+
+            global_rank = int(re.findall(r"Global Rank: ([0-9]+)", rank_checker_response.text)[0])
+            if global_rank > 0 and global_rank < 100000:
+                return 1
+            return -1
+        except:
+            return -1
+            
+
+    # 28. GoogleIndex
+    def GoogleIndex(self):
+        try:
+            site = search(self.url, 5)
+            if site:
+                return 1
+            else:
+                return -1
+        except:
+            return 1
+
+    # 29. LinksPointingToPage
+    def LinksPointingToPage(self):
+        try:
+            number_of_links = len(re.findall(r"<a href=", self.response.text))
+            if number_of_links == 0:
+                return 1
+            elif number_of_links <= 2:
+                return 0
+            else:
+                return -1
+        except:
+            return -1
+
+    # 30. StatsReport
+    def StatsReport(self):
+        try:
+            url_match = re.search(
+        'at\.ua|usa\.cc|baltazarpresentes\.com\.br|pe\.hu|esy\.es|hol\.es|sweddy\.com|myjino\.ru|96\.lt|ow\.ly', url)
+            ip_address = socket.gethostbyname(self.domain)
+            ip_match = re.search('146\.112\.61\.108|213\.174\.157\.151|121\.50\.168\.88|192\.185\.217\.116|78\.46\.211\.158|181\.174\.165\.13|46\.242\.145\.103|121\.50\.168\.40|83\.125\.22\.219|46\.242\.145\.98|'
+                                '107\.151\.148\.44|107\.151\.148\.107|64\.70\.19\.203|199\.184\.144\.27|107\.151\.148\.108|107\.151\.148\.109|119\.28\.52\.61|54\.83\.43\.69|52\.69\.166\.231|216\.58\.192\.225|'
+                                '118\.184\.25\.86|67\.208\.74\.71|23\.253\.126\.58|104\.239\.157\.210|175\.126\.123\.219|141\.8\.224\.221|10\.10\.10\.10|43\.229\.108\.32|103\.232\.215\.140|69\.172\.201\.153|'
+                                '216\.218\.185\.162|54\.225\.104\.146|103\.243\.24\.98|199\.59\.243\.120|31\.170\.160\.61|213\.19\.128\.77|62\.113\.226\.131|208\.100\.26\.234|195\.16\.127\.102|195\.16\.127\.157|'
+                                '34\.196\.13\.28|103\.224\.212\.222|172\.217\.4\.225|54\.72\.9\.51|192\.64\.147\.141|198\.200\.56\.183|23\.253\.164\.103|52\.48\.191\.26|52\.214\.197\.72|87\.98\.255\.18|209\.99\.17\.27|'
+                                '216\.38\.62\.18|104\.130\.124\.96|47\.89\.58\.141|78\.46\.211\.158|54\.86\.225\.156|54\.82\.156\.19|37\.157\.192\.102|204\.11\.56\.48|110\.34\.231\.42', ip_address)
+            if url_match:
+                return -1
+            elif ip_match:
+                return -1
+            return 1
+        except:
+            return 1
+    
+    def getFeaturesList(self):
+        return self.features
+    
+gbc = GradientBoostingClassifier(max_depth=4,learning_rate=0.7)
+gbc.fit(X_train,y_train)