Upload 14 files

pages/about.py

@@ -0,0 +1,43 @@
+import streamlit as st
+from PIL import Image
+import io
+
+
+def show_about():
+    st.header(' ')
+    st.header(' ')
+    st.header(' ')
+    #st.header("API")
+    st.write("A deepfake is a type of synthetic media generated using deep learning techniques, particularly deep neural networks. The term ""deepfake"" is a combination of ""deep learning"" and ""fake.""")
+    st.write("In deepfake technology, algorithms are used to create or manipulate audio,\
+             video, or images to depict something that did not actually occur or that alters the appearance or actions of individuals.\
+             This can involve superimposing images or videos of people onto existing footage,\
+             making individuals appear to say or do things they never said or did.")
+    st.header("Deepfake Fraud Statistics")
+    #st.write("")
+    image = Image.open("C:\\Users\\Paras Sharma\\OneDrive\\Pictures\\Saved Pictures\\deepfake-growth.jpg")
+    new_image = image.resize((600, 400))
+    st.image(new_image)
+
+    
+    st.header("Real Cases:")
+    st.markdown("**Kerala Man Loses Rs 40,000 to AI-Based Deepfake WhatsApp Fraud**")
+    st.write("According to India Today, a man in Kerala lost Rs 40,000 in an online scam on WhatsApp involving\
+             AI-based deepfake technology. The scammer impersonated the victim's former\
+             colleague via video call, fabricating a medical emergency and requesting\
+             money. This incident underscores the danger of sophisticated online fraud\
+             using deepfake technology and emphasizes the importance of verifying\
+             unexpected financial requests to avoid falling victim to such scams.")
+    
+
+
+
+    '''st.header("The Dangers of Deepfakes")
+    st.write("Organizations and individuals are at risk regarding deepfakes as it’s a source that leverages social engineering attempts to manufacture fraudulent texts, voice messages, and fake videos to spread misinformation. \
+    According to the US Department of Defense, deepfakes are AI-generated, highly realistic content that can be used to: \
+    Threaten an organization’s brand. \
+    Impersonate leaders and financial officers. \
+    Enable access to networks, communications, and other sensitive information. \
+    In this sense, all companies that are housing business and customer data could be at risk to these attacks.")
+'''
+    

pages/community.py

@@ -0,0 +1,38 @@
+import streamlit as st
+
+
+def show_community():
+    st.header("Community")
+    st.write(
+        """
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut scelerisque 
+        ultrices felis at ornare. In quis elementum diam. Phasellus facilisis laoreet 
+        eros, sed blandit neque sollicitudin at. Vivamus aliquet vehicula nunc, eget 
+        tempus tortor gravida quis. Ut rutrum orci velit, sit amet egestas sem 
+        elementum id. Nam dignissim sem lectus, in tristique nisl dignissim et. 
+        Vestibulum eleifend commodo purus non vestibulum. Pellentesque est lectus, 
+        tempus blandit ipsum eleifend, pulvinar sodales lacus. Praesent finibus lectus 
+        quis libero feugiat pharetra. Donec et eleifend magna.
+
+        Nam eu erat eget est viverra mollis eu eget dolor. Morbi ac tellus sit amet 
+        nisl tempor tempus vitae consectetur elit. Aenean neque nisl, placerat eget 
+        tempus vel, dictum in erat. Nullam tristique eros in feugiat auctor. Vivamus ac 
+        mi non lacus euismod consectetur. Quisque vel tempus orci. Pellentesque 
+        habitant morbi tristique senectus et netus et malesuada fames ac turpis 
+        egestas. Cras lacinia purus ut tempor scelerisque. Etiam placerat erat nibh. 
+        Cras lectus justo, convallis quis commodo in, aliquet non lectus. Vestibulum 
+        ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Ut 
+        sodales magna tellus, non interdum ex semper eget. Quisque porttitor augue nec 
+        ante gravida finibus sed eget quam.
+
+        ### Proin at fermentum nisi
+        Aenean tortor justo, tincidunt non nibh in, iaculis viverra neque. Cras ut mi 
+        eu tellus blandit interdum at vitae eros. Fusce vitae condimentum lacus, a 
+        viverra arcu. Class aptent taciti sociosqu ad litora torquent per conubia 
+        nostra, per inceptos himenaeos:
+        * Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+        * Aenean fermentum nibh sit amet malesuada placerat.
+        * Cras sit amet diam ut risus cursus hendrerit.
+        * Duis tempor turpis malesuada ex porta, et viverra tellus fermentum.
+        """
+    )

pages/dashboard.py

@@ -0,0 +1,124 @@
+import gradio as gr
+import sqlite3
+import re
+import bcrypt
+import numpy as np
+import cv2
+from PIL import Image
+import tensorflow as tf
+import os
+import warnings
+
+# Suppress all warnings
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+warnings.filterwarnings("ignore")
+np.seterr(all='ignore')
+
+# Load model
+deepfake_model = tf.keras.models.load_model("model_15_64.h5")
+
+
+# Setup SQLite instead of MySQL
+conn = sqlite3.connect("users.db", check_same_thread=False)
+cursor = conn.cursor()
+
+# Create user_details table in SQLite
+cursor.execute('''
+CREATE TABLE IF NOT EXISTS user_details (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    NAME TEXT,
+    PHONE TEXT,
+    EMAIL TEXT UNIQUE,
+    GENDER TEXT,
+    PASSWORD TEXT
+)
+''')
+conn.commit()
+
+# Validation utilities
+def is_valid_email(email):
+    return re.match(r"[^@]+@[^@]+\.[^@]+", email)
+
+def is_valid_phone(phone):
+    return re.match(r"^[0-9]{10}$", phone)
+
+def preprocess_image(image):
+    image = np.array(image)
+    image = cv2.resize(image, (128, 128))
+    image = image.astype(np.float32) / 255.0
+    return np.expand_dims(image, axis=0)
+
+def predict_image(image):
+    preprocessed = preprocess_image(image)
+    prediction = deepfake_model.predict(preprocessed)[0][0]
+    return "✅ Real Image" if prediction >= 0.5 else "⚠️ Fake Image"
+
+# Register user
+def register_user(name, phone, email, password):
+    if not is_valid_email(email):
+        return "❌ Invalid email", False
+    if not is_valid_phone(phone):
+        return "❌ Phone must be 10 digits", False
+
+    cursor.execute("SELECT * FROM user_details WHERE EMAIL = ?", (email,))
+    if cursor.fetchone():
+        return "⚠️ Email already registered", False
+
+    hashed_pw = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
+    cursor.execute("INSERT INTO user_details (NAME, PHONE, EMAIL, GENDER, PASSWORD) VALUES (?, ?, ?, ?, ?)",
+                   (name, phone, email, "U", hashed_pw))
+    conn.commit()
+    return "✅ Registration successful! Please log in.", True
+
+# Login user
+def login_user(email, password):
+    cursor.execute("SELECT PASSWORD FROM user_details WHERE EMAIL = ?", (email,))
+    result = cursor.fetchone()
+    if result and bcrypt.checkpw(password.encode(), result[0].encode() if isinstance(result[0], str) else result[0]):
+        return "✅ Login successful!", True
+    return "❌ Invalid credentials", False
+
+# App layout
+with gr.Blocks() as demo:
+    session = gr.State({})
+    show_login = gr.State(True)
+
+    status = gr.Textbox(label="", interactive=False)
+
+    with gr.Column(visible=True) as login_panel:
+        gr.Markdown("### Login or Sign Up")
+        name = gr.Textbox(label="Name (Sign Up Only)")
+        phone = gr.Textbox(label="Phone (Sign Up Only)")
+        email = gr.Textbox(label="Email")
+        password = gr.Textbox(label="Password", type="password")
+
+        login_btn = gr.Button("Login")
+        signup_btn = gr.Button("Sign Up")
+
+    with gr.Column(visible=False) as prediction_panel:
+        gr.Markdown("## Upload Image for Deepfake Detection")
+        image_input = gr.Image(type="pil")
+        result = gr.Textbox(label="Result")
+        predict_btn = gr.Button("Predict")
+        logout_btn = gr.Button("Logout")
+
+    # Logic
+    def handle_login(e, p):
+        msg, ok = login_user(e, p)
+        return msg, gr.update(visible=not ok), gr.update(visible=ok)
+
+    def handle_signup(n, ph, e, p):
+        msg, ok = register_user(n, ph, e, p)
+        return msg
+
+    def handle_logout():
+        return {}, gr.update(visible=True), gr.update(visible=False)
+
+    login_btn.click(handle_login, [email, password], [status, login_panel, prediction_panel])
+    signup_btn.click(handle_signup, [name, phone, email, password], status)
+    predict_btn.click(predict_image, inputs=image_input, outputs=result)
+    logout_btn.click(handle_logout, outputs=[session, login_panel, prediction_panel])
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()

pages/examples.py

@@ -0,0 +1,34 @@
+import streamlit as st
+
+
+def show_examples():
+    st.header("Examples")
+    col_1, col_2 = st.columns(2, gap="medium")
+    col_1.write(
+        """
+        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum vel augue 
+        nec tellus pulvinar blandit at nec lacus. Fusce eu libero quis nisi vehicula 
+        ornare. Integer cursus quam suscipit tempor iaculis. Mauris vitae accumsan 
+        felis, at elementum urna. Aenean in urna ante. Etiam ac dignissim dolor. 
+        Aliquam convallis pretium mauris, vel imperdiet quam fringilla vitae. Donec ac 
+        nisi eget nulla cursus consectetur a vitae purus. Quisque vitae aliquet ipsum, 
+        quis venenatis odio. Quisque mauris elit, elementum et eros et, varius 
+        efficitur magna. Proin dictum tristique tellus, quis viverra lorem tempor 
+        vitae. Nulla quis bibendum libero, quis malesuada nisi. Mauris vel aliquam 
+        odio. Maecenas nec tortor consectetur, posuere elit vel, sodales ante. Sed ut 
+        pretium massa, ut dictum nibh.
+        """
+    )
+    col_2.write(
+        """
+        Etiam dolor sem, bibendum id lacus eget, porta hendrerit mauris. Fusce varius 
+        consequat erat, sit amet rhoncus lectus vestibulum vel. Cras vitae lacinia 
+        nibh. Aenean varius facilisis tellus, vitae egestas magna pharetra ut. Maecenas 
+        condimentum metus diam, facilisis rhoncus lorem lacinia eu. Maecenas eleifend 
+        mauris velit, vitae placerat elit commodo ut. Ut ut purus elit. Suspendisse 
+        condimentum quam sit amet vulputate vehicula. Nulla et quam at mauris cursus 
+        euismod. Curabitur nec massa non tortor commodo condimentum eu at metus. Fusce 
+        aliquet dolor nulla, quis feugiat sem bibendum vel. Donec tempus placerat leo 
+        vitae blandit.
+        """
+    )

pages/home.py

@@ -0,0 +1,123 @@
+import streamlit as st
+import mysql.connector
+import re
+import tensorflow as tf
+from PIL import Image
+import numpy as np
+import cv2
+
+# Initialize database connection
+try:
+    mydb = mysql.connector.connect(
+        host="localhost",
+        user="root",
+        password="12345",
+        database="user_info"
+    )
+    mycursor = mydb.cursor()
+    print("Connection Established")
+except mysql.connector.Error as err:
+    print(f"Error: {err}")
+    st.error("Database connection failed.")
+
+# Load the deepfake detection model
+deepfake_model_path = "C:\\Users\\Paras Sharma\\OneDrive\\Documents\\Deepfake\\model_15_64 (1).h5"
+deepfake_model = tf.keras.models.load_model(deepfake_model_path)
+
+def validate_name(name):
+    if re.match(r"^[a-zA-Z]+\s[a-zA-Z]+$", name):
+        return True
+    else:
+        st.warning("Please enter a valid name (e.g., Firstname Lastname).")
+        return False
+
+def validate_phone(phone):
+    if re.match(r"^[0-9]{10}$", phone):
+        return True
+    else:
+        st.warning("Please enter a valid 10-digit phone number.")
+        return False
+
+def validate_email(email):
+    email_pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
+    if re.match(email_pattern, email):
+        return True
+    else:
+        st.warning("Please enter a valid email.")
+        return False
+
+def preprocess_image(image):
+    try:
+        image = np.array(image)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB
+        image = cv2.resize(image, (128, 128))  # Resize to match model input size
+        image = image.astype(np.float32) / 255.0  # Normalize pixel values
+        return np.expand_dims(image, axis=0)  # Add batch dimension
+    except Exception as e:
+        print(f"Error preprocessing image: {e}")
+        return None
+
+def predict_deepfake(image):
+    preprocessed_image = preprocess_image(image)
+    if preprocessed_image is not None:
+        prediction = deepfake_model.predict(preprocessed_image)
+        return prediction[0][0]  # Assuming the model outputs a single value between 0 and 1
+    else:
+        return None
+
+def show_home():
+    st.header(' ')
+    st.markdown("<h1 style='text-align: center; color: black;'>AuthentiTech: Leveraging Machine Learning to Combat Deepfake Detection</h1>", unsafe_allow_html=True)
+    st.header(' ', divider="rainbow")
+    st.header(' ')
+
+    st.markdown("<p style='font-size: medium;'>Enter Your Details</p>", unsafe_allow_html=True)
+
+    NAME = st.text_input('Name: ', st.session_state.get('name', ''))
+    if not validate_name(NAME):
+        return
+
+    PHONE = st.text_input('Contact Number(+91): ', max_chars=10)
+    PHONE = PHONE.strip()  # Remove any leading/trailing spaces
+    if not validate_phone(PHONE):
+        return
+
+    GENDER = st.selectbox('Enter gender', ('F', 'M', 'other'))
+
+    EMAIL = st.text_input('Email: ', st.session_state.get('EMAIL', ''))
+    if not validate_email(EMAIL):
+        return
+
+    if st.button("Submit"):
+        try:
+            sql = "INSERT INTO user_details (NAME, PHONE, EMAIL, GENDER) VALUES (%s, %s, %s, %s)"
+            val = (NAME, PHONE, EMAIL, GENDER)
+            mycursor.execute(sql, val)
+            mydb.commit()
+            st.session_state['name'] = NAME
+            st.session_state['EMAIL'] = EMAIL
+            st.success("Details submitted successfully!")
+        except mysql.connector.Error as err:
+            st.error(f"Error: {err}")
+            print(f"Error executing SQL: {err}")
+
+    st.write("Upload your image (JPEG, JPG, PNG) here (max size: 15 KB):")
+    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"], accept_multiple_files=False, key="file_uploader")
+
+    if uploaded_file is not None:
+        file_details = {"FileName": uploaded_file.name, "FileType": uploaded_file.type, "FileSize": uploaded_file.size}
+        st.write(file_details)
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+
+        if st.button("Detect Now"):
+            prediction = predict_deepfake(image)
+            if prediction < 0.5:
+                st.write("Fake Image")
+            else:
+                st.write("Real Image")
+    else:
+        st.warning("Please upload an image.")
+
+if __name__ == "__main__":
+    show_home()

pages/install.py

@@ -0,0 +1,17 @@
+import streamlit as st
+
+
+def show_install():
+    st.header("What are the dangers of Deepfakes?")
+    st.header(' ');
+    st.subheader("Misinformation and Fake News:")
+    st.write(
+        """
+        Deepfakes can be used to create highly convincing yet completely
+        fabricated content. This poses a significant threat in the realm of
+        information dissemination, as fake videos or audio clips can be
+        circulated to deceive people into believing events that never occurred
+        or statements that were never made. This can lead to the spread of
+        false narratives, misinformation, and confusion among the public.
+        """
+    )

pages/user_guide.py

@@ -0,0 +1,43 @@
+import streamlit as st
+
+
+def show_user_guide():
+    st.header(' ')
+    st.header(' ')
+    st.header("User guide")
+    st.header(' ')
+
+    container = st.container(border=True)
+    container.markdown(''':blue[**Step 1:**]''')
+    container.write("Create an account to get access")
+
+    container2 = st.container(border=True)
+    container2.markdown(''':blue[**Step 2:**]''')
+    container2.write("Upload your Images")
+
+    container3 = st.container(border=True)
+    container3.markdown(''':blue[**Step 3:**]''')
+    container3.write("Get the results")
+
+    #row1 = st.columns(1)
+    #row2 = st.columns(1)
+    #row3 = st.columns(1)
+
+
+    #for col in row1:
+    #with st.container():
+            #tile = col.container(height=120)
+    #st.title(":balloon:")
+
+    #st.subheader("Step 1: ")
+    #for col in row1:
+        #tile = col.container(height=120)
+        #st.markdown(":user: **Step 1:**")
+        #st.write("Create an account and subscribe to get access")
+    
+    #tile.title(":balloon:")
+    #st.write("This is outside the container")
+
+    #Now insert some more in the container
+    #container.write("This is inside too")
+