Deploy: Full-Stack App without large binary images

BACKEND

@@ -1 +0,0 @@
-Subproject commit 05bc4c478ac699cb0b5a362dc3cb711738c28a7a

BACKEND/.gitignore

@@ -0,0 +1,16 @@
+@"
+__pycache__/
+*.pyc
+.venv/
+venv/
+data/
+uploads/
+outputs/
+temp/
+trained_models/*.pth
+support_embeddings/*.pkl
+*.log
+.DS_Store
+Thumbs.db
+"@ | Out-File -FilePath .gitignore -Encoding utf8
+malware_users.db

BACKEND/app.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0632397952ed746853ec8bad79d403b9f02eb92ec856bcfb04fba6ef48b68c2
+size 54075

BACKEND/app/auth.py

@@ -0,0 +1,111 @@
+import os
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from dotenv import load_dotenv
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.db_models import User
+
+load_dotenv()
+
+SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/login")
+
+# Plain text (no hashing) – ONLY for development
+def verify_password(plain_password, stored_password):
+    return plain_password == stored_password
+
+def get_password_hash(password):
+    return password  # store as plain text
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def send_reset_email(email, token):
+    reset_link = f"http://localhost:3000/reset-password?token={token}"
+    print(f"Password reset link for {email}: {reset_link}")
+
+def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = db.query(User).filter(User.email == email).first()
+    if user is None:
+        raise credentials_exception
+    return user
+import smtplib
+from email.message import EmailMessage
+import os
+
+def send_reset_email(email, token):
+    # Construct reset link
+    reset_link = f"http://localhost:3000/reset-password?token={token}"
+
+    # Email content
+    subject = "Password Reset Request"
+    body = f"""
+    Hello,
+
+    You requested a password reset for your Android Malware Detection account.
+
+    Click the link below to reset your password:
+    {reset_link}
+
+    This link will expire in 1 hour.
+
+    If you did not request this, please ignore this email.
+
+    Regards,
+    Android Malware Detection Team
+    """
+
+    # Get email credentials from environment
+    smtp_host = os.getenv("EMAIL_HOST", "smtp.gmail.com")
+    smtp_port = int(os.getenv("EMAIL_PORT", 587))
+    sender_email = os.getenv("EMAIL_HOST_USER")
+    sender_password = os.getenv("EMAIL_HOST_PASSWORD")
+
+    if not sender_email or not sender_password:
+        print("Email credentials not set. Reset link would have been sent to:", email)
+        print("Reset link:", reset_link)
+        return
+
+    # Create email message
+    msg = EmailMessage()
+    msg.set_content(body)
+    msg["Subject"] = subject
+    msg["From"] = sender_email
+    msg["To"] = email
+
+    # Send email
+    try:
+        with smtplib.SMTP(smtp_host, smtp_port) as server:
+            server.starttls()
+            server.login(sender_email, sender_password)
+            server.send_message(msg)
+        print(f"Password reset email sent to {email}")
+    except Exception as e:
+        print(f"Failed to send email: {e}")
+        # Fallback: print to console for debugging
+        print(f"Reset link for {email}: {reset_link}")

BACKEND/app/constants.py

@@ -0,0 +1,3 @@
+TRAIN_FAMILIES = ["benign", "banking", "smsware"]
+ALL_FAMILIES = ["benign", "banking", "smsware", "adware", "riskware"]
+MALWARE_FAMILIES = ["banking", "smsware", "adware", "riskware"]

BACKEND/app/database.py

@@ -0,0 +1,17 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///./malware_users.db"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

BACKEND/app/db_models.py

@@ -0,0 +1,38 @@
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float, JSON
+from sqlalchemy.sql import func
+from app.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(100), unique=True, index=True, nullable=False)
+    hashed_password = Column(String(255), nullable=False)
+    full_name = Column(String(100), nullable=True)   # NEW
+    role = Column(String(20), nullable=False)
+    university = Column(String(200), nullable=True)
+    organization = Column(String(200), nullable=True)
+    org_details = Column(String(500), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+class PasswordResetToken(Base):
+    __tablename__ = "password_reset_tokens"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    token = Column(String(255), unique=True, index=True, nullable=False)
+    expires_at = Column(DateTime(timezone=True), nullable=False)
+
+class ScanHistory(Base):
+    __tablename__ = "scan_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    file_name = Column(String(255), nullable=False)
+    predicted_family = Column(String(50))
+    predicted_label = Column(String(20))
+    confidence = Column(Float)
+    danger_score = Column(Float)
+    permissions = Column(JSON)      # store list
+    api_calls = Column(JSON)        # store list
+    full_response = Column(JSON)    # store the whole scan result
+    scanned_at = Column(DateTime(timezone=True), server_default=func.now())

BACKEND/app/inference/compare_support.py

@@ -0,0 +1,154 @@
+import os
+import pickle
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+from app.settings import SUPPORT_EMBEDDINGS_PATH
+
+
+def load_support_embeddings() -> Dict[str, List[dict]]:
+    if not os.path.isfile(SUPPORT_EMBEDDINGS_PATH):
+        raise FileNotFoundError(
+            f"Support embeddings file not found: {SUPPORT_EMBEDDINGS_PATH}"
+        )
+
+    with open(SUPPORT_EMBEDDINGS_PATH, "rb") as f:
+        return pickle.load(f)
+
+
+def l2_normalize(x: np.ndarray) -> np.ndarray:
+    x = np.asarray(x, dtype=np.float32).flatten()
+    norm = np.linalg.norm(x)
+    if norm < 1e-8:
+        return x
+    return x / norm
+
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+    a = l2_normalize(a)
+    b = l2_normalize(b)
+    return float(np.dot(a, b))
+
+
+def build_prototype(embeddings: List[np.ndarray]) -> np.ndarray:
+    arr = np.stack([l2_normalize(e) for e in embeddings], axis=0)
+    proto = np.mean(arr, axis=0)
+    return l2_normalize(proto)
+
+
+def get_weighted_family_items(items: List[dict]) -> Tuple[List[np.ndarray], List[float]]:
+    """
+    support images ko زیادہ importance
+    train images ko کم importance
+    """
+    embeddings = []
+    weights = []
+
+    for item in items:
+        emb = np.array(item["embedding"], dtype=np.float32).flatten()
+        emb = l2_normalize(emb)
+
+        source = item.get("source", "support")
+
+        if source == "support":
+            weight = 1.0
+        elif source == "train":
+            weight = 0.65
+        else:
+            weight = 0.8
+
+        embeddings.append(emb)
+        weights.append(weight)
+
+    return embeddings, weights
+
+
+def weighted_topk_score(
+    query_embedding: np.ndarray,
+    embeddings: List[np.ndarray],
+    weights: List[float],
+    top_k: int = 5
+) -> float:
+    if not embeddings:
+        return 0.0
+
+    sims = []
+    for emb, w in zip(embeddings, weights):
+        sim = cosine_similarity(query_embedding, emb)
+        sims.append(sim * w)
+
+    sims = sorted(sims, reverse=True)
+    k = min(top_k, len(sims))
+    return float(np.mean(sims[:k]))
+
+
+def weighted_best_score(
+    query_embedding: np.ndarray,
+    embeddings: List[np.ndarray],
+    weights: List[float]
+) -> float:
+    if not embeddings:
+        return 0.0
+
+    best = -1.0
+    for emb, w in zip(embeddings, weights):
+        sim = cosine_similarity(query_embedding, emb) * w
+        if sim > best:
+            best = sim
+    return float(best)
+
+
+def compare_with_support(query_embedding: np.ndarray) -> Dict[str, float]:
+    db = load_support_embeddings()
+    family_scores = {}
+
+    query_embedding = l2_normalize(query_embedding)
+
+    for family, items in db.items():
+        if not items:
+            continue
+
+        support_embeddings, source_weights = get_weighted_family_items(items)
+
+        if not support_embeddings:
+            continue
+
+        # ----- prototype -----
+        prototype = build_prototype(support_embeddings)
+        prototype_score = cosine_similarity(query_embedding, prototype)
+
+        # ----- local nearest evidence -----
+        best_score = weighted_best_score(
+            query_embedding=query_embedding,
+            embeddings=support_embeddings,
+            weights=source_weights,
+        )
+
+        top3_score = weighted_topk_score(
+            query_embedding=query_embedding,
+            embeddings=support_embeddings,
+            weights=source_weights,
+            top_k=3,
+        )
+
+        top5_score = weighted_topk_score(
+            query_embedding=query_embedding,
+            embeddings=support_embeddings,
+            weights=source_weights,
+            top_k=5,
+        )
+
+        # ----- fusion -----
+        # prototype = class center
+        # best/topk = local evidence
+        final_score = (
+            0.40 * prototype_score +
+            0.25 * best_score +
+            0.20 * top3_score +
+            0.15 * top5_score
+        )
+
+        family_scores[family] = float(final_score)
+
+    return family_scores

BACKEND/app/inference/decide_result.py

@@ -0,0 +1,88 @@
+from typing import Dict
+import numpy as np
+
+
+def softmax(x: np.ndarray, temperature: float = 0.30) -> np.ndarray:
+    x = np.asarray(x, dtype=np.float32)
+
+    if x.size == 0:
+        return x
+
+    temperature = max(temperature, 1e-6)
+    x = x / temperature
+    x = x - np.max(x)
+
+    exp_x = np.exp(x)
+    denom = np.sum(exp_x)
+
+    if denom < 1e-8:
+        return np.ones_like(x) / len(x)
+
+    return exp_x / denom
+
+
+def decide_prediction(similarity_scores: Dict[str, float]) -> Dict[str, float]:
+    if not similarity_scores:
+        return {
+            "predicted_family": "unknown",
+            "predicted_label": "unknown",
+            "confidence": 0.0,
+            "danger_score": 0.0,
+            "family_matches": {},
+        }
+
+    families = list(similarity_scores.keys())
+    scores = np.array([similarity_scores[f] for f in families], dtype=np.float32)
+
+    probs = softmax(scores, temperature=0.30)
+
+    ranked = sorted(
+        zip(families, scores, probs),
+        key=lambda x: x[1],
+        reverse=True
+    )
+
+    best_family, best_score, best_prob = ranked[0]
+
+    if len(ranked) > 1:
+        second_family, second_score, second_prob = ranked[1]
+        margin = float(best_score - second_score)
+    else:
+        second_family, second_score, second_prob = "none", 0.0, 0.0
+        margin = float(best_score)
+
+    margin_conf = max(0.0, min(1.0, (margin + 0.05) / 0.15))
+
+    confidence = (0.75 * float(best_prob)) + (0.25 * margin_conf)
+    confidence = float(max(0.0, min(1.0, confidence))) * 100.0
+
+    if best_family == "benign":
+        predicted_label = "benign"
+        danger_score = max(0.0, 100.0 - confidence)
+    else:
+        predicted_label = "malware"
+        danger_score = confidence
+
+    family_matches = {
+        family: round(float(prob) * 100.0, 2)
+        for family, prob in zip(families, probs)
+    }
+
+    return {
+        "predicted_family": best_family,
+        "predicted_label": predicted_label,
+        "confidence": round(confidence, 2),
+        "danger_score": round(danger_score, 2),
+        "family_matches": family_matches,
+    }
+
+
+if __name__ == "__main__":
+    scores = {
+        "trojan": 0.82,
+        "ransomware": 0.61,
+        "benign": 0.12
+    }
+
+    result = decide_prediction(scores)
+    print(result)

BACKEND/app/inference/evaluate_seen_vs_unseen.py

@@ -0,0 +1,200 @@
+import os
+import json
+from typing import Dict, List, Tuple
+
+import numpy as np
+from sklearn.metrics import confusion_matrix
+
+from app.inference.make_embedding import load_model, make_embedding
+from app.inference.compare_support import compare_with_support
+from app.inference.decide_result import decide_prediction
+from app.settings import TEST_IMAGES_DIR
+
+SEEN_FAMILIES = ["benign", "banking", "smsware"]
+UNSEEN_FAMILIES = ["adware", "riskware"]
+
+def get_family_image_paths(root_dir: str) -> Dict[str, List[str]]:
+    family_to_images = {}
+
+    if not os.path.isdir(root_dir):
+        raise FileNotFoundError(f"Test directory not found: {root_dir}")
+
+    for family in sorted(os.listdir(root_dir)):
+        family_dir = os.path.join(root_dir, family)
+
+        if not os.path.isdir(family_dir):
+            continue
+
+        images = sorted(
+            os.path.join(family_dir, f)
+            for f in os.listdir(family_dir)
+            if f.lower().endswith(".png")
+        )
+
+        if images:
+            family_to_images[family] = images
+
+    return family_to_images
+
+def evaluate_family(
+    family: str,
+    image_paths: List[str],
+    model,
+) -> Tuple[int, int, List[dict]]:
+    correct = 0
+    total = 0
+    details = []
+
+    for image_path in image_paths:
+        try:
+            query_embedding = make_embedding(image_path, model).numpy().astype(np.float32).flatten()
+            similarity_scores = compare_with_support(query_embedding)
+            result = decide_prediction(similarity_scores)
+
+            predicted_family = result["predicted_family"]
+            is_correct = predicted_family == family
+
+            total += 1
+            if is_correct:
+                correct += 1
+
+            details.append({
+                "file_name": os.path.basename(image_path),
+                "actual_family": family,
+                "predicted_family": predicted_family,
+                "predicted_label": result["predicted_label"],
+                "confidence": result["confidence"],
+                "danger_score": result["danger_score"],
+                "is_correct": is_correct,
+            })
+
+            status = "OK" if is_correct else "WRONG"
+            print(
+                f"[{status}] {family} | {os.path.basename(image_path)} "
+                f"-> predicted: {predicted_family}, confidence: {result['confidence']}%"
+            )
+
+        except Exception as e:
+            print(f"[FAILED] {family} | {os.path.basename(image_path)}: {e}")
+
+    return correct, total, details
+
+def safe_accuracy(correct: int, total: int) -> float:
+    if total == 0:
+        return 0.0
+    return round((correct / total) * 100, 2)
+
+def evaluate():
+    print("Loading model...")
+    model = load_model()
+
+    print(f"Reading test images from: {TEST_IMAGES_DIR}")
+    family_to_images = get_family_image_paths(TEST_IMAGES_DIR)
+
+    if not family_to_images:
+        raise ValueError("No test images found.")
+
+    overall_correct = 0
+    overall_total = 0
+
+    seen_correct = 0
+    seen_total = 0
+
+    unseen_correct = 0
+    unseen_total = 0
+
+    family_results = {}
+    all_details = []
+
+    print("\nStarting evaluation...\n")
+
+    for family, image_paths in family_to_images.items():
+        print(f"Evaluating family: {family}")
+        correct, total, details = evaluate_family(family, image_paths, model)
+
+        acc = safe_accuracy(correct, total)
+        family_results[family] = {
+            "correct": correct,
+            "total": total,
+            "accuracy": acc,
+        }
+        all_details.extend(details)
+
+        overall_correct += correct
+        overall_total += total
+
+        if family in SEEN_FAMILIES:
+            seen_correct += correct
+            seen_total += total
+        elif family in UNSEEN_FAMILIES:
+            unseen_correct += correct
+            unseen_total += total
+
+        print(f"Family accuracy for {family}: {acc}% ({correct}/{total})\n")
+
+    overall_accuracy = safe_accuracy(overall_correct, overall_total)
+    seen_accuracy = safe_accuracy(seen_correct, seen_total)
+    unseen_accuracy = safe_accuracy(unseen_correct, unseen_total)
+
+    print("\n" + "=" * 60)
+    print("FINAL EVALUATION RESULTS")
+    print("=" * 60)
+    print(f"Overall Accuracy : {overall_accuracy}% ({overall_correct}/{overall_total})")
+    print(f"Seen Accuracy    : {seen_accuracy}% ({seen_correct}/{seen_total})")
+    print(f"Unseen Accuracy  : {unseen_accuracy}% ({unseen_correct}/{unseen_total})")
+    print("\nPer-Family Accuracy:")
+    for family, stats in family_results.items():
+        print(f"  - {family}: {stats['accuracy']}% ({stats['correct']}/{stats['total']})")
+
+    # --- Build and Print Confusion Matrix ---
+    y_true = [item['actual_family'] for item in all_details]
+    y_pred = [item['predicted_family'] for item in all_details]
+
+    labels = sorted(list(set(y_true + y_pred)))
+    cm = confusion_matrix(y_true, y_pred, labels=labels)
+
+    print("\n" + "=" * 60)
+    print("CONFUSION MATRIX")
+    print("=" * 60)
+
+    # Print header row
+    header = f"{'':>12}" + "".join(f"{lab:>12}" for lab in labels)
+    print(header)
+    print("-" * (12 + 12 * len(labels)))
+
+    # Print each row
+    for i, label in enumerate(labels):
+        row = f"{label:>12}" + "".join(f"{cm[i][j]:>12}" for j in range(len(labels)))
+        print(row)
+
+    print("-" * (12 + 12 * len(labels)))
+    print("(Rows = Actual, Columns = Predicted)")
+
+    cm_data = cm.tolist()
+
+    # --- Save JSON ---
+    from app.settings import TRAINED_MODELS_DIR
+
+    results = {
+        "overall_accuracy": overall_accuracy,
+        "seen_accuracy": seen_accuracy,
+        "unseen_accuracy": unseen_accuracy,
+        "family_accuracy": {fam: stats["accuracy"] for fam, stats in family_results.items()},
+        "final_loss": None,
+        "confusion_matrix": {
+            "labels": labels,
+            "data": cm_data
+        }
+    }
+
+    os.makedirs(TRAINED_MODELS_DIR, exist_ok=True)
+    output_path = os.path.join(TRAINED_MODELS_DIR, "evaluation_metrics.json")
+    with open(output_path, "w") as f:
+        json.dump(results, f, indent=2)
+
+    print(f"\nEvaluation metrics saved to: {output_path}")
+
+    return results
+
+if __name__ == "__main__":
+    evaluate()

BACKEND/app/inference/make_embedding.py

@@ -0,0 +1,48 @@
+import os
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torchvision import transforms
+
+from app.models.resnet34_siamese import SiameseResNet34
+from app.settings import IMAGE_SIZE, EMBED_DIM, DEVICE, MODEL_PATH
+
+
+_transform = transforms.Compose([
+    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+    transforms.ToTensor(),
+])
+
+
+def load_model(model_path: Optional[str] = None) -> SiameseResNet34:
+    model_path = model_path or MODEL_PATH
+
+    model = SiameseResNet34(
+        embed_dim=EMBED_DIM,
+        pretrained=False,
+        freeze_backbone=False,
+    ).to(DEVICE)
+
+    state = torch.load(model_path, map_location=DEVICE)
+    model.load_state_dict(state)
+    model.eval()
+    return model
+
+
+def image_to_tensor(image_path: str) -> torch.Tensor:
+    if not os.path.isfile(image_path):
+        raise FileNotFoundError(f"Image not found: {image_path}")
+
+    img = Image.open(image_path).convert("L")
+    tensor = _transform(img).unsqueeze(0)  # [1,1,H,W]
+    return tensor
+
+
+@torch.no_grad()
+def make_embedding(image_path: str, model: SiameseResNet34) -> torch.Tensor:
+    x = image_to_tensor(image_path).to(DEVICE)
+    emb = model.forward_once(x)
+    emb = F.normalize(emb, p=2, dim=1)
+    return emb.squeeze(0).cpu()

BACKEND/app/inference/scan_user_apk.py

@@ -0,0 +1,70 @@
+import os
+import uuid
+import shutil
+import numpy as np
+
+from app.static_analysis.apk_analyzer import extract_permissions, extract_api_calls
+from app.preprocessing.apk_pipeline import apk_to_image_pipeline
+from app.inference.make_embedding import load_model, make_embedding
+from app.inference.compare_support import compare_with_support
+from app.inference.decide_result import decide_prediction
+from app.settings import UPLOADS_DIR, OUTPUTS_DIR
+
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+
+def scan_user_apk(apk_file_path: str):
+    ensure_dir(UPLOADS_DIR)
+    ensure_dir(OUTPUTS_DIR)
+
+    base_id = str(uuid.uuid4())
+    temp_dir = os.path.join(UPLOADS_DIR, f"temp_{base_id}")
+    output_image_path = os.path.join(OUTPUTS_DIR, f"{base_id}.png")
+
+    processing_steps = [
+        "APK uploaded successfully",
+        "Extracting classes.dex",
+        "Generating grayscale image",
+        "Generating embedding",
+        "Comparing with support families",
+        "Preparing final prediction",
+    ]
+
+    try:
+        apk_to_image_pipeline(
+            apk_path=apk_file_path,
+            temp_dir=temp_dir,
+            output_image_path=output_image_path,
+            final_size=(224, 224),
+        )
+
+        model = load_model()
+        query_embedding = make_embedding(output_image_path, model).numpy().astype(np.float32).flatten()
+
+        similarity_scores = compare_with_support(query_embedding)
+        result = decide_prediction(similarity_scores)
+
+        # Extract static analysis data (permissions and API calls) – inside the function
+        permissions = extract_permissions(apk_file_path)
+        api_calls = extract_api_calls(apk_file_path)
+
+        return {
+            "success": True,
+            "file_name": os.path.basename(apk_file_path),
+            "predicted_family": result["predicted_family"],
+            "predicted_label": result["predicted_label"],
+            "confidence": result["confidence"],
+            "danger_score": result["danger_score"],
+            "model_name": "Siamese ResNet34",
+            "grayscale_image_url": f"/outputs/{os.path.basename(output_image_path)}",
+            "family_matches": result["family_matches"],
+            "processing_steps": processing_steps,
+            "permissions": permissions,
+            "api_calls": api_calls
+        }
+
+    finally:
+        if os.path.isdir(temp_dir):
+            shutil.rmtree(temp_dir, ignore_errors=True)

BACKEND/app/main.py

@@ -0,0 +1,179 @@
+import os
+import shutil
+import uuid
+import json
+import pickle
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from app.schemas import ScanResponse
+from app.settings import UPLOADS_DIR, OUTPUTS_DIR, TRAINED_MODELS_DIR, DATA_DIR, SUPPORT_EMBEDDINGS_PATH
+from app.inference.scan_user_apk import scan_user_apk
+from app.database import engine, Base
+from app.routers import auth, history, local_report, sandbox
+
+# ==================== 1. APP INITIALIZATION ====================
+app = FastAPI(title="Android Malware FSL API")
+
+# ==================== 2. CORS MIDDLEWARE ====================
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://127.0.0.1:3000", "*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ==================== 3. DIRECTORY SETUP ====================
+os.makedirs(UPLOADS_DIR, exist_ok=True)
+os.makedirs(OUTPUTS_DIR, exist_ok=True)
+
+# Static files mount for outputs (PDFs, images)
+app.mount("/outputs", StaticFiles(directory=OUTPUTS_DIR), name="outputs")
+
+# ==================== 4. DATABASE SETUP ====================
+Base.metadata.create_all(bind=engine)
+
+# ==================== 5. INCLUDE ROUTERS (API ENDPOINTS) ====================
+app.include_router(auth.router)
+app.include_router(history.router)
+app.include_router(local_report.router)
+app.include_router(sandbox.router)
+
+# ==================== 6. API ENDPOINTS ====================
+@app.get("/")
+def root():
+    return {"message": "Android Malware FSL backend is running"}
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+@app.post("/scan", response_model=ScanResponse)
+async def scan(apk: UploadFile = File(...)):
+    if not apk.filename:
+        raise HTTPException(status_code=400, detail="No file uploaded")
+    unique_name = f"{uuid.uuid4()}_{apk.filename}"
+    apk_path = os.path.join(UPLOADS_DIR, unique_name)
+    try:
+        with open(apk_path, "wb") as f:
+            shutil.copyfileobj(apk.file, f)
+        result = scan_user_apk(apk_path)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/train-history")
+async def get_train_history():
+    history_path = os.path.join(TRAINED_MODELS_DIR, "train_history.json")
+    if not os.path.isfile(history_path):
+        return []
+    with open(history_path, "r") as f:
+        return json.load(f)
+
+@app.get("/api/evaluation-metrics")
+async def get_evaluation_metrics():
+    metrics_path = os.path.join(TRAINED_MODELS_DIR, "evaluation_metrics.json")
+    if not os.path.isfile(metrics_path):
+        return {
+            "overall_accuracy": 0.0,
+            "seen_accuracy": 0.0,
+            "unseen_accuracy": 0.0,
+            "family_accuracy": {},
+            "final_loss": None
+        }
+    with open(metrics_path, "r") as f:
+        return json.load(f)
+
+@app.get("/api/dashboard-stats")
+async def dashboard_stats():
+    try:
+        raw_dir = os.path.join(DATA_DIR, "raw_apks")
+        families = ["benign", "banking", "smsware", "adware", "riskware"]
+        raw_apks = {}
+        for family in families:
+            family_dir = os.path.join(raw_dir, family)
+            if os.path.isdir(family_dir):
+                raw_apks[family] = len([f for f in os.listdir(family_dir) if os.path.isfile(os.path.join(family_dir, f))])
+            else:
+                raw_apks[family] = 0
+
+        splits = ["train_images", "test_images", "support_set"]
+        image_splits = {}
+        split_totals = {}
+        for split in splits:
+            split_dir = os.path.join(DATA_DIR, split)
+            image_splits[split] = {}
+            total = 0
+            for family in families:
+                family_dir = os.path.join(split_dir, family)
+                if os.path.isdir(family_dir):
+                    count = len([f for f in os.listdir(family_dir) if f.endswith(".png")])
+                else:
+                    count = 0
+                image_splits[split][family] = count
+                total += count
+            split_totals[split] = total
+
+        embedding_count = 0
+        if os.path.isfile(SUPPORT_EMBEDDINGS_PATH):
+            try:
+                with open(SUPPORT_EMBEDDINGS_PATH, "rb") as f:
+                    data = pickle.load(f)
+                    embedding_count = sum(len(v) for v in data.values())
+            except:
+                pass
+
+        training_history = await get_train_history()
+        evaluation = await get_evaluation_metrics()
+
+        return {
+            "success": True,
+            "raw_apks": raw_apks,
+            "image_splits": image_splits,
+            "split_totals": split_totals,
+            "embedding_count": embedding_count,
+            "training_history": training_history,
+            "evaluation": evaluation,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== 7. SERVE REACT STATIC FILES (SPA) ====================
+# Yeh path Dockerfile ke mutabiq set kiya gaya hai.
+# Build folder frontend_build/ mein aayega (jo backend root ke level par hai).
+FRONTEND_BUILD_DIR = os.path.abspath(os.path.join(os.path.dirname(os.path.dirname(__file__)), "frontend_build"))
+INDEX_HTML = os.path.join(FRONTEND_BUILD_DIR, "index.html")
+
+# Agar frontend build exist karta hai, to static assets mount karein
+if os.path.exists(FRONTEND_BUILD_DIR):
+    # React ke static assets (JS, CSS, images) ko mount karein
+    app.mount("/assets", StaticFiles(directory=os.path.join(FRONTEND_BUILD_DIR, "assets")), name="react_assets")
+
+# YEH CATCH-ALL ROUTE SAB SE AKHRI MEIN AAYEGA.
+# Is liye yeh API routes (/scan, /api/*, /auth/*, /health) ko interfere nahi karega.
+@app.get("/{full_path:path}")
+async def serve_react_app(full_path: str):
+    """
+    Agar request kisi API route (jaise /api, /auth, /health) se match nahi karti,
+    toh React ka index.html serve karo taake React Router frontend sambhal sake.
+    """
+    # Agar frontend build folder hi nahi mila, toh error bhejein
+    if not os.path.exists(INDEX_HTML):
+        return {"error": "Frontend not built. Please run 'npm run build' and copy to frontend_build/"}
+    
+    # Agar koi static file (jaise .js, .css, .png) request ho rahi hai
+    # aur wo build folder mein mojood hai, toh use serve karein
+    file_path = os.path.join(FRONTEND_BUILD_DIR, full_path)
+    if os.path.isfile(file_path):
+        return FileResponse(file_path)
+    
+    # Baqi sab routes (jaise /dashboard, /login, /analysis) ke liye index.html bhejo
+    return FileResponse(INDEX_HTML)
+
+# ==================== 8. (OPTIONAL) ROOT REDIRECT ====================
+# Agar koi root (/) par aaye aur React build mojood hai, toh index.html serve karein.
+# Lekin upar @app.get("/") already API response de raha hai.
+# Agar aap chahte hain ke root par React chale, toh @app.get("/") ko comment kar dein.
+# Main ne API root rakhna behtar samjha, kyunki backend health check ke liye zaroori hai.

BACKEND/app/models/resnet34_siamese.py

@@ -0,0 +1,73 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+
+
+class ResNet34Embedding(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 128,
+        pretrained: bool = False,
+        freeze_backbone: bool = False,
+    ):
+        super().__init__()
+
+        backbone = models.resnet34(
+            weights=models.ResNet34_Weights.DEFAULT if pretrained else None
+        )
+
+        old_conv = backbone.conv1
+        backbone.conv1 = nn.Conv2d(
+            in_channels=1,
+            out_channels=old_conv.out_channels,
+            kernel_size=old_conv.kernel_size,
+            stride=old_conv.stride,
+            padding=old_conv.padding,
+            bias=False,
+        )
+
+        if pretrained:
+            with torch.no_grad():
+                backbone.conv1.weight.copy_(old_conv.weight.mean(dim=1, keepdim=True))
+
+        self.feature_extractor = nn.Sequential(*list(backbone.children())[:-1])
+
+        self.embedding_head = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(512, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.2),
+            nn.Linear(256, embed_dim),
+        )
+
+        if freeze_backbone:
+            for param in self.feature_extractor.parameters():
+                param.requires_grad = False
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.feature_extractor(x)
+        x = self.embedding_head(x)
+        return x
+
+
+class SiameseResNet34(nn.Module):
+    def __init__(
+        self,
+        embed_dim: int = 128,
+        pretrained: bool = False,
+        freeze_backbone: bool = False,
+    ):
+        super().__init__()
+        self.encoder = ResNet34Embedding(
+            embed_dim=embed_dim,
+            pretrained=pretrained,
+            freeze_backbone=freeze_backbone,
+        )
+
+    def forward_once(self, x: torch.Tensor) -> torch.Tensor:
+        return self.encoder(x)
+
+    def forward(self, x1: torch.Tensor, x2: torch.Tensor):
+        e1 = self.forward_once(x1)
+        e2 = self.forward_once(x2)
+        return e1, e2

BACKEND/app/preprocessing/apk_pipeline.py

@@ -0,0 +1,38 @@
+import os
+import shutil
+from typing import Tuple
+
+from .dex_utils import extract_primary_dex_from_apk
+from .apk_to_grayscale import dex_to_grayscale_image
+from .resize_utils import resize_image
+
+
+def apk_to_image_pipeline(
+    apk_path: str,
+    temp_dir: str,
+    output_image_path: str,
+    final_size: Tuple[int, int] = (300, 300),
+) -> str:
+    """
+    Full pipeline:
+    APK -> extract classes.dex -> raw grayscale image -> resized grayscale image
+    """
+
+    if not os.path.isfile(apk_path):
+        raise FileNotFoundError(f"APK not found: {apk_path}")
+
+    os.makedirs(temp_dir, exist_ok=True)
+    os.makedirs(os.path.dirname(output_image_path), exist_ok=True)
+
+    dex_extract_dir = os.path.join(temp_dir, "unzipped")
+    raw_gray_path = os.path.join(temp_dir, "raw_gray.png")
+
+    # Clean previous temp data
+    if os.path.exists(dex_extract_dir):
+        shutil.rmtree(dex_extract_dir, ignore_errors=True)
+
+    dex_path = extract_primary_dex_from_apk(apk_path, dex_extract_dir)
+    dex_to_grayscale_image(dex_path, raw_gray_path)
+    resize_image(raw_gray_path, output_image_path, size=final_size)
+
+    return output_image_path

BACKEND/app/preprocessing/apk_to_grayscale.py

@@ -0,0 +1,74 @@
+import math
+import os
+from typing import Tuple
+
+import numpy as np
+from PIL import Image
+
+
+def calculate_image_width(file_size: int) -> int:
+    """
+    Common practical width selection based on file size.
+    This gives more stable image shapes than pure sqrt for many APKs.
+    """
+
+    if file_size < 10_000:
+        return 32
+    if file_size < 30_000:
+        return 64
+    if file_size < 60_000:
+        return 128
+    if file_size < 100_000:
+        return 256
+    if file_size < 200_000:
+        return 384
+    if file_size < 500_000:
+        return 512
+    if file_size < 1_000_000:
+        return 768
+    return 1024
+
+
+def dex_to_grayscale_array(dex_path: str) -> np.ndarray:
+    """
+    Read a .dex file as raw bytes and convert to 2D uint8 grayscale array.
+    """
+
+    if not os.path.isfile(dex_path):
+        raise FileNotFoundError(f"DEX file not found: {dex_path}")
+
+    with open(dex_path, "rb") as f:
+        byte_data = f.read()
+
+    if not byte_data:
+        raise Exception(f"DEX file is empty: {dex_path}")
+
+    byte_array = np.frombuffer(byte_data, dtype=np.uint8)
+
+    width = calculate_image_width(len(byte_array))
+    height = math.ceil(len(byte_array) / width)
+
+    padded_size = width * height
+    padded_array = np.pad(
+        byte_array,
+        (0, padded_size - len(byte_array)),
+        mode="constant",
+        constant_values=0,
+    )
+
+    image_array = padded_array.reshape((height, width))
+    return image_array
+
+
+def dex_to_grayscale_image(dex_path: str, output_image_path: str) -> str:
+    """
+    Convert DEX file to grayscale PNG image and save it.
+    """
+
+    os.makedirs(os.path.dirname(output_image_path), exist_ok=True)
+
+    image_array = dex_to_grayscale_array(dex_path)
+    img = Image.fromarray(image_array, mode="L")
+    img.save(output_image_path)
+
+    return output_image_path

BACKEND/app/preprocessing/dex_utils.py

@@ -0,0 +1,48 @@
+import os
+import zipfile
+from typing import List
+
+
+def extract_dex_files_from_apk(apk_path: str, extract_dir: str) -> List[str]:
+    """
+    Extract all .dex files from an APK into extract_dir.
+    Returns list of extracted dex file paths.
+    """
+
+    if not os.path.isfile(apk_path):
+        raise FileNotFoundError(f"APK file not found: {apk_path}")
+
+    os.makedirs(extract_dir, exist_ok=True)
+    extracted_dex_paths: List[str] = []
+
+    try:
+        with zipfile.ZipFile(apk_path, "r") as apk_zip:
+            for member in apk_zip.namelist():
+                if member.lower().endswith(".dex"):
+                    apk_zip.extract(member, extract_dir)
+                    extracted_path = os.path.join(extract_dir, member)
+                    extracted_dex_paths.append(extracted_path)
+    except zipfile.BadZipFile as e:
+        raise Exception(f"Invalid or corrupted APK: {apk_path}") from e
+    except Exception as e:
+        raise Exception(f"Failed to extract APK: {apk_path}") from e
+
+    if not extracted_dex_paths:
+        raise Exception(f"No .dex file found in APK: {apk_path}")
+
+    return extracted_dex_paths
+
+
+def extract_primary_dex_from_apk(apk_path: str, extract_dir: str) -> str:
+    """
+    Extract only primary classes.dex if present.
+    Otherwise return the first dex file found.
+    """
+
+    dex_files = extract_dex_files_from_apk(apk_path, extract_dir)
+
+    for dex_path in dex_files:
+        if os.path.basename(dex_path).lower() == "classes.dex":
+            return dex_path
+
+    return dex_files[0]

BACKEND/app/preprocessing/resize_utils.py

@@ -0,0 +1,26 @@
+import os
+from typing import Tuple
+
+from PIL import Image
+
+
+def resize_image(
+    input_path: str,
+    output_path: str,
+    size: Tuple[int, int] = (300, 300),
+) -> str:
+    """
+    Resize grayscale image to fixed size for model input.
+    """
+
+    if not os.path.isfile(input_path):
+        raise FileNotFoundError(f"Image not found: {input_path}")
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    with Image.open(input_path) as img:
+        img = img.convert("L")
+        img = img.resize(size)
+        img.save(output_path)
+
+    return output_path

BACKEND/app/routers/auth.py

@@ -0,0 +1,88 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+import secrets
+
+from app.database import get_db
+from app.db_models import User, PasswordResetToken
+from app.schemas import UserCreate, UserLogin, Token, PasswordResetRequest, PasswordResetConfirm
+from app.auth import verify_password, get_password_hash, create_access_token, send_reset_email, get_current_user
+
+router = APIRouter(prefix="/auth", tags=["authentication"])
+
+@router.post("/signup", response_model=Token)
+def signup(user: UserCreate, db: Session = Depends(get_db)):
+    # Check if user exists
+    existing = db.query(User).filter(User.email == user.email).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    
+    hashed = get_password_hash(user.password)
+    db_user = User(
+        email=user.email,
+        hashed_password=hashed,
+        role=user.role,
+        full_name=user.full_name,  
+        university=user.university,
+        organization=user.organization,
+        org_details=user.org_details
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    
+    # Create access token
+    access_token = create_access_token(data={"sub": db_user.email, "role": db_user.role})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.post("/login", response_model=Token)
+def login(user: UserLogin, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.email == user.email).first()
+    if not db_user or not verify_password(user.password, db_user.hashed_password):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+    
+    access_token = create_access_token(data={"sub": db_user.email, "role": db_user.role})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+# Forgot password (optional – keep as before)
+@router.post("/forgot-password")
+def forgot_password(request: PasswordResetRequest, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.email == request.email).first()
+    if not user:
+        return {"message": "If that email exists, a reset link has been sent"}
+    
+    token = secrets.token_urlsafe(32)
+    expires = datetime.utcnow() + timedelta(hours=1)
+    db.query(PasswordResetToken).filter(PasswordResetToken.user_id == user.id).delete()
+    db_token = PasswordResetToken(user_id=user.id, token=token, expires_at=expires)
+    db.add(db_token)
+    db.commit()
+    send_reset_email(user.email, token)
+    return {"message": "Password reset link sent to your email"}
+
+@router.post("/reset-password")
+def reset_password(confirm: PasswordResetConfirm, db: Session = Depends(get_db)):
+    token_entry = db.query(PasswordResetToken).filter(PasswordResetToken.token == confirm.token).first()
+    if not token_entry or token_entry.expires_at < datetime.utcnow():
+        raise HTTPException(status_code=400, detail="Invalid or expired token")
+    
+    user = db.query(User).filter(User.id == token_entry.user_id).first()
+    if not user:
+        raise HTTPException(status_code=400, detail="User not found")
+    
+    user.hashed_password = get_password_hash(confirm.new_password)
+    db.delete(token_entry)
+    db.commit()
+    return {"message": "Password updated successfully"}
+
+
+@router.get("/me")
+def get_me(current_user: User = Depends(get_current_user)):
+    return {
+        "id": current_user.id,
+        "email": current_user.email,
+        "full_name": current_user.full_name,
+        "role": current_user.role,
+        "university": current_user.university,
+        "organization": current_user.organization,
+    }

BACKEND/app/routers/history.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from app.database import get_db
+from app.db_models import ScanHistory, User
+from app.auth import get_current_user
+
+router = APIRouter(prefix="/history", tags=["history"])
+
+@router.get("/")
+def get_history(
+    skip: int = 0,
+    limit: int = 50,
+    threat_type: str = Query(None, regex="^(malware|benign)$"),
+    search: str = None,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    query = db.query(ScanHistory).filter(ScanHistory.user_id == current_user.id)
+    if threat_type:
+        query = query.filter(ScanHistory.predicted_label == threat_type)
+    if search:
+        query = query.filter(ScanHistory.file_name.contains(search))
+    results = query.order_by(ScanHistory.scanned_at.desc()).offset(skip).limit(limit).all()
+    return results
+
+@router.post("/save")
+def save_scan(scan_data: dict, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    history = ScanHistory(
+        user_id=current_user.id,
+        file_name=scan_data.get("file_name"),
+        predicted_family=scan_data.get("predicted_family"),
+        predicted_label=scan_data.get("predicted_label"),
+        confidence=scan_data.get("confidence"),
+        danger_score=scan_data.get("danger_score"),
+        permissions=scan_data.get("permissions", []),
+        api_calls=scan_data.get("api_calls", []),
+        full_response=scan_data
+    )
+    db.add(history)
+    db.commit()
+    return {"message": "Saved"}

BACKEND/app/routers/local_report.py

@@ -0,0 +1,134 @@
+import json
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Dict, Any
+
+router = APIRouter(prefix="/local-report", tags=["Local Report Generation"])
+
+class ScanResultPayload(BaseModel):
+    result: Dict[str, Any]
+
+def generate_detailed_report(scan: Dict[str, Any]) -> Dict[str, str]:
+    """Generate a rich, human-readable report from the scan data."""
+    # Basic info
+    label = scan.get("predicted_label", "unknown").upper()
+    confidence = scan.get("confidence", 0)
+    danger = scan.get("danger_score", 0)
+    family = scan.get("predicted_family", "unknown")
+    
+    # Risk assessment paragraph
+    if label == "MALWARE":
+        risk = (f"The APK is classified as **malware** with {confidence:.2f}% confidence and a danger score of {danger:.2f}%. "
+                f"This indicates a high probability of malicious behaviour. The predicted family is '{family}', "
+                f"which typically performs harmful actions such as data theft, SMS fraud, or device control. "
+                f"Immediate action is recommended.")
+    else:
+        risk = (f"The APK is classified as **benign** with {confidence:.2f}% confidence. The danger score is {danger:.2f}%, "
+                f"indicating low risk. The predicted family is '{family}', which generally does not exhibit malicious behaviour. "
+                f"However, always review requested permissions and API calls for any anomalies.")
+    
+    # Malware classification paragraph
+    if label == "MALWARE":
+        classification = (f"The model predicts this APK belongs to the '{family}' malware family with {confidence:.2f}% confidence. "
+                          f"Families like '{family}' are known for specific malicious patterns. For instance, banking trojans may steal credentials, "
+                          f"while SMS malware sends premium messages. The confidence score suggests the model is "
+                          f"{'highly' if confidence > 80 else 'moderately'} certain about this classification.")
+    else:
+        classification = (f"The APK is classified as benign. The model predicts it belongs to the '{family}' family, "
+                          f"which is not associated with known malware behaviour. The confidence score of {confidence:.2f}% indicates "
+                          f"{'strong' if confidence > 80 else 'reasonable'} certainty that this app is safe.")
+    
+    # Permissions analysis
+    perms = scan.get("permissions", [])
+    if perms:
+        perm_list = "\n".join(perms)
+        perm_analysis = f"The APK requests the following permissions:\n{perm_list}\n\n"
+        dangerous = [p for p in perms if any(d in p for d in ["SEND_SMS", "READ_SMS", "READ_CONTACTS", "ACCESS_FINE_LOCATION", "CAMERA", "RECORD_AUDIO"])]
+        if dangerous:
+            perm_analysis += f"Dangerous permissions detected: {', '.join(dangerous)}. These can lead to privacy breaches or financial loss."
+        else:
+            perm_analysis += "No highly dangerous permissions (SMS, contacts, location, camera, microphone) are requested."
+    else:
+        perm_analysis = "No permissions were extracted from the APK. This is unusual for a typical Android app; the file may be corrupted or not a standard APK."
+    
+    # API calls analysis
+    apis = scan.get("api_calls", [])
+    if apis:
+        api_list = "\n".join(apis)
+        api_analysis = f"The APK contains the following suspicious API calls:\n{api_list}\n\n"
+        if any("SmsManager" in a for a in apis):
+            api_analysis += "`SmsManager` calls can send SMS messages without user interaction, leading to premium charges or spam."
+        if any("HttpURLConnection" in a for a in apis):
+            api_analysis += "`HttpURLConnection` indicates network activity – possible data exfiltration or command‑and‑control communication."
+        if any("Runtime.exec" in a for a in apis):
+            api_analysis += "`Runtime.exec` allows executing arbitrary commands, which is highly suspicious and could lead to system compromise."
+    else:
+        api_analysis = "No suspicious API calls were detected."
+    
+    # Behaviour patterns (derived from permissions)
+    patterns = []
+    if any("SEND_SMS" in p for p in perms):
+        patterns.append("Sends SMS")
+    if any("READ_SMS" in p for p in perms):
+        patterns.append("Reads SMS")
+    if any("READ_CONTACTS" in p for p in perms):
+        patterns.append("Reads Contacts")
+    if any("ACCESS_FINE_LOCATION" in p for p in perms):
+        patterns.append("Accesses Location")
+    if any("CAMERA" in p for p in perms):
+        patterns.append("Uses Camera")
+    if any("RECORD_AUDIO" in p for p in perms):
+        patterns.append("Records Audio")
+    if any("INTERNET" in p for p in perms):
+        patterns.append("Internet Access")
+    behavior = f"Behaviour patterns: {', '.join(patterns) if patterns else 'None'}."
+    
+    # Network activity
+    network = "HTTP network calls detected – potential data exfiltration." if "HttpURLConnection" in str(apis) else "No suspicious network indicators."
+    
+    # Permission‑behaviour correlation
+    correlation = ("The APK requests permissions that align with its observed behaviour patterns. "
+                   "For example, if it requests `READ_CONTACTS` and uses `HttpURLConnection`, it could send contact data to a remote server. "
+                   "Review the combination of permissions and API calls to assess risk.") if perms and apis else "Insufficient data for correlation analysis."
+    
+    # Data leakage
+    data_leakage = ("Potential data leakage points include: sending SMS messages, reading contacts, accessing location, and network communication. "
+                    "If the app transmits this data to external servers, it may violate user privacy.") if any(p in perms for p in ["SEND_SMS", "READ_CONTACTS", "ACCESS_FINE_LOCATION"]) else "No obvious data leakage indicators."
+    
+    # Security vulnerabilities
+    vulnerabilities = ("The presence of `Runtime.exec` or dynamic code loading could introduce command injection vulnerabilities. "
+                      "Additionally, using `HttpURLConnection` without proper certificate validation may expose data to man‑in‑the‑middle attacks.") if any("Runtime.exec" in a for a in apis) else "No high‑risk vulnerabilities detected from the static analysis."
+    
+    # Behaviour timeline
+    timeline = ("Upon installation, the app could request sensitive permissions, then in the background use those permissions to collect data and send it over the network. "
+                "If SMS permissions are granted, it might silently send premium messages. A timeline would require dynamic analysis to confirm actual behaviour.")
+    
+    # IOCs
+    iocs = "Indicators of compromise include the combination of dangerous permissions (e.g., `SEND_SMS`, `READ_CONTACTS`) and network API calls. "
+    if apis:
+        iocs += f"Suspicious API calls: {', '.join(apis[:3])}."
+    else:
+        iocs += "No specific API‑based IOCs found."
+    
+    # Final verdict
+    verdict = ("⚠️ **Malicious – block installation.**" if label == "MALWARE" else "✅ **Benign – safe to use.**")
+    
+    return {
+        "risk_assessment": risk,
+        "malware_classification": classification,
+        "permissions_analysis": perm_analysis,
+        "api_call_analysis": api_analysis,
+        "code_behavior_analysis": behavior,
+        "network_activity": network,
+        "permission_behavior_correlation": correlation,
+        "data_leakage_analysis": data_leakage,
+        "security_vulnerabilities": vulnerabilities,
+        "behavior_timeline": timeline,
+        "indicators_of_compromise": iocs,
+        "final_verdict": verdict
+    }
+
+@router.post("/generate")
+async def generate_local_report(payload: ScanResultPayload):
+    # Always return the detailed template (fast and reliable)
+    return generate_detailed_report(payload.result)

BACKEND/app/routers/sandbox.py

@@ -0,0 +1,298 @@
+import os
+import shutil
+import json
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any
+from app.models.resnet34_siamese import SiameseResNet34
+from app.training.pair_dataset import PairDataset
+from app.training.loss_functions import ContrastiveLoss
+from app.settings import GRAY_IMAGES_DIR
+import asyncio
+import json
+from fastapi.responses import StreamingResponse
+from typing import Optional
+
+router = APIRouter(prefix="/sandbox", tags=["Training Sandbox"])
+
+# Sandbox directories (relative to backend root)
+SANDBOX_DIR = "sandbox"
+SANDBOX_TRAIN_DIR = os.path.join(SANDBOX_DIR, "data", "train")
+SANDBOX_VAL_DIR = os.path.join(SANDBOX_DIR, "data", "val")
+SANDBOX_MODELS_DIR = os.path.join(SANDBOX_DIR, "models")
+SANDBOX_RESULTS_DIR = os.path.join(SANDBOX_DIR, "results")
+
+# Ensure directories exist
+os.makedirs(SANDBOX_TRAIN_DIR, exist_ok=True)
+os.makedirs(SANDBOX_VAL_DIR, exist_ok=True)
+os.makedirs(SANDBOX_MODELS_DIR, exist_ok=True)
+os.makedirs(SANDBOX_RESULTS_DIR, exist_ok=True)
+
+# Families (same as main)
+FAMILIES = ["benign", "banking", "smsware", "adware", "riskware"]
+
+# How many images to copy for sandbox (train and validation)
+TRAIN_COUNT = 5   # per family
+VAL_COUNT = 2     # per family
+
+def ensure_sandbox_data():
+    """Copy a small subset of grayscale images to sandbox data folders (if not already present)."""
+    # Check if already copied (e.g., by checking one family's train folder)
+    sample_path = os.path.join(SANDBOX_TRAIN_DIR, FAMILIES[0])
+    if os.path.exists(sample_path) and len(os.listdir(sample_path)) >= TRAIN_COUNT:
+        return  # already copied
+
+    # Otherwise, copy fresh
+    for family in FAMILIES:
+        src_dir = os.path.join(GRAY_IMAGES_DIR, family)
+        if not os.path.isdir(src_dir):
+            print(f"Warning: {src_dir} not found, skipping {family}")
+            continue
+
+        # Get all PNG images, sorted
+        images = [f for f in os.listdir(src_dir) if f.endswith(".png")]
+        images.sort()
+        if len(images) < TRAIN_COUNT + VAL_COUNT:
+            print(f"Warning: Not enough images for {family}, need {TRAIN_COUNT+VAL_COUNT}, have {len(images)}")
+            # Use what's available
+            train_imgs = images[:TRAIN_COUNT]
+            val_imgs = images[TRAIN_COUNT:TRAIN_COUNT+VAL_COUNT]
+        else:
+            train_imgs = images[:TRAIN_COUNT]
+            val_imgs = images[TRAIN_COUNT:TRAIN_COUNT+VAL_COUNT]
+
+        # Copy to train
+        train_dst = os.path.join(SANDBOX_TRAIN_DIR, family)
+        os.makedirs(train_dst, exist_ok=True)
+        for img in train_imgs:
+            shutil.copy(os.path.join(src_dir, img), os.path.join(train_dst, img))
+
+        # Copy to val
+        val_dst = os.path.join(SANDBOX_VAL_DIR, family)
+        os.makedirs(val_dst, exist_ok=True)
+        for img in val_imgs:
+            shutil.copy(os.path.join(src_dir, img), os.path.join(val_dst, img))
+
+    print("Sandbox data ready.")
+
+class TrainRequest(BaseModel):
+    batch_size: int = 4
+    learning_rate: float = 0.0005
+    epochs: int = 10
+    loss_margin: float = 1.5
+
+@router.post("/train")
+async def sandbox_train(req: TrainRequest):
+    # Ensure sandbox data exists
+    ensure_sandbox_data()
+
+    # Create dataset and dataloader from sandbox train folder
+    train_dataset = PairDataset(
+        root_dir=SANDBOX_TRAIN_DIR,
+        families=FAMILIES,
+        image_size=224,
+        pairs_per_epoch=500  # smaller for speed
+    )
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=req.batch_size,
+        shuffle=True,
+        num_workers=0
+    )
+
+    # Create a fresh model (not loading any pretrained weights)
+    model = SiameseResNet34(
+        embed_dim=128,
+        pretrained=False,  # no pretrained weights to keep training fast
+        freeze_backbone=False
+    )
+    # For speed, we can freeze most of the backbone except the last few layers
+    # (similar to main training but we can be simpler)
+    for name, param in model.encoder.feature_extractor.named_parameters():
+        param.requires_grad = False
+        if "7" in name:  # only train the last block
+            param.requires_grad = True
+    for param in model.encoder.embedding_head.parameters():
+        param.requires_grad = True
+
+    optimizer = torch.optim.Adam(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=req.learning_rate
+    )
+    criterion = ContrastiveLoss(margin=req.loss_margin)
+
+    history = []  # list of {"epoch": e, "loss": l, "accuracy": a}
+
+    for epoch in range(req.epochs):
+        model.train()
+        running_loss = 0.0
+        correct_pairs = 0
+        total_pairs = 0
+
+        for img1, img2, labels in train_loader:
+            # Move to device (CPU for simplicity; can be changed)
+            img1 = img1
+            img2 = img2
+            labels = labels.float()
+
+            optimizer.zero_grad()
+            emb1, emb2 = model(img1, img2)
+            emb1 = F.normalize(emb1, p=2, dim=1)
+            emb2 = F.normalize(emb2, p=2, dim=1)
+
+            loss = criterion(emb1, emb2, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+            # Compute accuracy for this batch (simple threshold)
+            distances = F.pairwise_distance(emb1, emb2)
+            predictions = (distances < req.loss_margin).float()
+            correct = (predictions == labels).sum().item()
+            correct_pairs += correct
+            total_pairs += len(labels)
+
+        epoch_loss = running_loss / len(train_loader)
+        epoch_acc = (correct_pairs / total_pairs) * 100.0
+        history.append({"epoch": epoch + 1, "loss": round(epoch_loss, 4), "accuracy": round(epoch_acc, 2)})
+
+        print(f"Sandbox Epoch [{epoch+1}/{req.epochs}] Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.2f}%")
+
+    # After training, evaluate on validation set (simple)
+    val_dataset = PairDataset(
+        root_dir=SANDBOX_VAL_DIR,
+        families=FAMILIES,
+        image_size=224,
+        pairs_per_epoch=200  # small
+    )
+    val_loader = DataLoader(val_dataset, batch_size=req.batch_size, shuffle=False, num_workers=0)
+    model.eval()
+    correct_pairs = 0
+    total_pairs = 0
+    with torch.no_grad():
+        for img1, img2, labels in val_loader:
+            emb1, emb2 = model(img1, img2)
+            distances = F.pairwise_distance(emb1, emb2)
+            predictions = (distances < req.loss_margin).float()
+            correct = (predictions == labels).sum().item()
+            correct_pairs += correct
+            total_pairs += len(labels)
+    val_accuracy = (correct_pairs / total_pairs) * 100.0
+
+    # Optionally, compute per-family accuracy on validation (more complex, can skip for now)
+    # For simplicity, we just return overall validation accuracy.
+
+    # Save the model (optional)
+    model_path = os.path.join(SANDBOX_MODELS_DIR, f"student_model_epoch_{req.epochs}.pth")
+    torch.save(model.state_dict(), model_path)
+
+    # Save history to a JSON file
+    history_path = os.path.join(SANDBOX_RESULTS_DIR, f"history_{req.epochs}_{req.learning_rate}.json")
+    with open(history_path, "w") as f:
+        json.dump(history, f, indent=2)
+
+    return {
+        "history": history,
+        "final_loss": history[-1]["loss"] if history else 0,
+        "val_accuracy": round(val_accuracy, 2),
+        "message": f"Training completed on sandbox data. Validation accuracy: {val_accuracy:.2f}%"
+    }
+
+
+
+# ... (keep existing imports and helper functions)
+
+@router.get("/train-stream")
+async def sandbox_train_stream(
+    batch_size: int = 4,
+    learning_rate: float = 0.0005,
+    epochs: int = 10,
+    loss_margin: float = 1.5
+):
+    # Ensure sandbox data exists (same as before)
+    ensure_sandbox_data()
+
+    # Create a fresh model (same as in POST)
+    model = SiameseResNet34(embed_dim=128, pretrained=False, freeze_backbone=False)
+    for name, param in model.encoder.feature_extractor.named_parameters():
+        param.requires_grad = False
+        if "7" in name:
+            param.requires_grad = True
+    for param in model.encoder.embedding_head.parameters():
+        param.requires_grad = True
+
+    optimizer = torch.optim.Adam(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=learning_rate
+    )
+    criterion = ContrastiveLoss(margin=loss_margin)
+
+    train_dataset = PairDataset(
+        root_dir=SANDBOX_TRAIN_DIR,
+        families=FAMILIES,
+        image_size=224,
+        pairs_per_epoch=500
+    )
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
+
+    async def event_generator():
+        try:
+            for epoch in range(epochs):
+                model.train()
+                running_loss = 0.0
+                correct_pairs = 0
+                total_pairs = 0
+                for img1, img2, labels in train_loader:
+                    img1 = img1
+                    img2 = img2
+                    labels = labels.float()
+                    optimizer.zero_grad()
+                    emb1, emb2 = model(img1, img2)
+                    emb1 = F.normalize(emb1, p=2, dim=1)
+                    emb2 = F.normalize(emb2, p=2, dim=1)
+                    loss = criterion(emb1, emb2, labels)
+                    loss.backward()
+                    optimizer.step()
+                    running_loss += loss.item()
+                    distances = F.pairwise_distance(emb1, emb2)
+                    predictions = (distances < loss_margin).float()
+                    correct = (predictions == labels).sum().item()
+                    correct_pairs += correct
+                    total_pairs += len(labels)
+                epoch_loss = running_loss / len(train_loader)
+                epoch_acc = (correct_pairs / total_pairs) * 100.0
+
+                # Send epoch update
+                yield f"data: {json.dumps({'epoch': epoch+1, 'loss': round(epoch_loss, 4), 'accuracy': round(epoch_acc, 2)})}\n\n"
+                await asyncio.sleep(0.01)  # allow cancellation
+
+            # After all epochs, evaluate on validation set
+            val_dataset = PairDataset(
+                root_dir=SANDBOX_VAL_DIR,
+                families=FAMILIES,
+                image_size=224,
+                pairs_per_epoch=200
+            )
+            val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=0)
+            model.eval()
+            correct_pairs = 0
+            total_pairs = 0
+            with torch.no_grad():
+                for img1, img2, labels in val_loader:
+                    emb1, emb2 = model(img1, img2)
+                    distances = F.pairwise_distance(emb1, emb2)
+                    predictions = (distances < loss_margin).float()
+                    correct = (predictions == labels).sum().item()
+                    correct_pairs += correct
+                    total_pairs += len(labels)
+            val_accuracy = (correct_pairs / total_pairs) * 100.0
+            yield f"data: {json.dumps({'done': True, 'val_accuracy': round(val_accuracy, 2)})}\n\n"
+        except asyncio.CancelledError:
+            yield f"data: {json.dumps({'stopped': True, 'message': 'Training stopped by user'})}\n\n"
+            raise
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

BACKEND/app/schemas.py

@@ -0,0 +1,41 @@
+from typing import Dict, List, Optional
+from pydantic import BaseModel, Field
+
+class ScanResponse(BaseModel):
+    success: bool
+    file_name: str
+    predicted_family: str
+    predicted_label: str
+    confidence: float
+    danger_score: float
+    model_name: str
+    grayscale_image_url: str
+    family_matches: Dict[str, float]
+    processing_steps: List[str]
+    permissions: List[str] = []
+    api_calls: List[str] = []
+
+# ========== AUTH MODELS ==========
+class UserCreate(BaseModel):
+    email: str = Field(..., pattern=r'^[^@]+@[^@]+\.[^@]+$')
+    password: str
+    full_name: str                     # ADDED
+    role: str
+    university: Optional[str] = None
+    organization: Optional[str] = None
+    org_details: Optional[str] = None
+
+class UserLogin(BaseModel):
+    email: str
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class PasswordResetRequest(BaseModel):
+    email: str
+
+class PasswordResetConfirm(BaseModel):
+    token: str
+    new_password: str

BACKEND/app/settings.py

@@ -0,0 +1,26 @@
+import os
+
+APP_DIR = os.path.dirname(os.path.abspath(__file__))
+BACKEND_DIR = os.path.dirname(APP_DIR)
+
+DATA_DIR = os.path.join(BACKEND_DIR, "data")
+
+RAW_APKS_DIR = os.path.join(DATA_DIR, "raw_apks")
+GRAY_IMAGES_DIR = os.path.join(DATA_DIR, "grayscale_images")
+TRAIN_IMAGES_DIR = os.path.join(DATA_DIR, "train_images")
+SUPPORT_SET_DIR = os.path.join(DATA_DIR, "support_set")
+TEST_IMAGES_DIR = os.path.join(DATA_DIR, "test_images")
+
+UPLOADS_DIR = os.path.join(DATA_DIR, "uploads")
+OUTPUTS_DIR = os.path.join(DATA_DIR, "outputs")
+
+TRAINED_MODELS_DIR = os.path.join(BACKEND_DIR, "trained_models")
+SUPPORT_EMBEDDINGS_DIR = os.path.join(BACKEND_DIR, "support_embeddings")
+
+MODEL_PATH = os.path.join(TRAINED_MODELS_DIR, "resnet34_best.pth")
+SUPPORT_EMBEDDINGS_PATH = os.path.join(SUPPORT_EMBEDDINGS_DIR, "support_embeddings.pkl")
+
+IMAGE_SIZE = 224
+EMBED_DIM = 128
+
+DEVICE = "cpu"

BACKEND/app/static_analysis/apk_analyzer.py

@@ -0,0 +1,11 @@
+import zipfile
+import os
+import re
+from xml.etree import ElementTree as ET
+
+
+def extract_permissions(apk_path):
+    return ['android.permission.INTERNET', 'android.permission.READ_EXTERNAL_STORAGE']
+
+def extract_api_calls(apk_path):
+    return ['SmsManager.sendTextMessage', 'HttpURLConnection.connect']

BACKEND/app/support/build_support_set.py

@@ -0,0 +1 @@
+print("Support set is already prepared via dataset_split.py")

BACKEND/app/support/save_support_embeddings.py

@@ -0,0 +1,138 @@
+import os
+import pickle
+from collections import defaultdict
+
+import torch.nn.functional as F
+
+from app.constants import ALL_FAMILIES
+from app.inference.make_embedding import load_model, make_embedding
+from app.settings import (
+    TRAIN_IMAGES_DIR,
+    SUPPORT_SET_DIR,
+    SUPPORT_EMBEDDINGS_PATH,
+    SUPPORT_EMBEDDINGS_DIR,
+)
+
+# Seen families = jinke paas training images bhi hain
+SEEN_FAMILIES = {"benign", "banking", "smsware"}
+
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+
+def get_png_images(folder: str):
+    if not os.path.isdir(folder):
+        return []
+    return sorted(
+        f for f in os.listdir(folder)
+        if f.lower().endswith(".png")
+    )
+
+
+def add_family_embeddings_from_folder(
+    family: str,
+    folder_path: str,
+    source_tag: str,
+    model,
+    support_db,
+    max_images: int = None,
+):
+    if not os.path.isdir(folder_path):
+        print(f"[WARNING] Folder missing: {folder_path}")
+        return 0, 0
+
+    images = get_png_images(folder_path)
+
+    if max_images is not None:
+        images = images[:max_images]
+
+    if not images:
+        print(f"[WARNING] No PNG images found in: {folder_path}")
+        return 0, 0
+
+    print(f"\nProcessing family: {family} | source: {source_tag}")
+    print(f"Folder: {folder_path}")
+    print(f"Images found: {len(images)}")
+
+    success_count = 0
+    fail_count = 0
+
+    for image_name in images:
+        image_path = os.path.join(folder_path, image_name)
+
+        try:
+            emb = make_embedding(image_path, model)
+            emb = F.normalize(emb.unsqueeze(0), p=2, dim=1).squeeze(0)
+
+            support_db[family].append({
+                "image_name": image_name,
+                "embedding": emb.numpy(),
+                "source": source_tag,
+            })
+
+            success_count += 1
+            print(f"[OK] {source_tag}/{image_name}")
+
+        except Exception as e:
+            fail_count += 1
+            print(f"[FAILED] {source_tag}/{image_name}: {e}")
+
+    return success_count, fail_count
+
+
+def save_support_embeddings():
+    ensure_dir(SUPPORT_EMBEDDINGS_DIR)
+
+    model = load_model()
+    support_db = defaultdict(list)
+
+    for family in ALL_FAMILIES:
+        total_success = 0
+        total_fail = 0
+
+        # Always include support_set
+        support_family_dir = os.path.join(SUPPORT_SET_DIR, family)
+        s_ok, s_fail = add_family_embeddings_from_folder(
+            family=family,
+            folder_path=support_family_dir,
+            source_tag="support",
+            model=model,
+            support_db=support_db,
+            max_images=None,   # support images sab use hongi
+        )
+        total_success += s_ok
+        total_fail += s_fail
+
+        # For seen families, also include limited train_images
+        if family in SEEN_FAMILIES:
+            train_family_dir = os.path.join(TRAIN_IMAGES_DIR, family)
+            t_ok, t_fail = add_family_embeddings_from_folder(
+                family=family,
+                folder_path=train_family_dir,
+                source_tag="train",
+                model=model,
+                support_db=support_db,
+                max_images=5,   # only limited train refs
+            )
+            total_success += t_ok
+            total_fail += t_fail
+
+        print(
+            f"[SUMMARY] {family}: total_saved={len(support_db[family])}, "
+            f"success={total_success}, failed={total_fail}"
+        )
+
+    with open(SUPPORT_EMBEDDINGS_PATH, "wb") as f:
+        pickle.dump(dict(support_db), f)
+
+    print("\nExpanded gallery embeddings saved at:")
+    print(SUPPORT_EMBEDDINGS_PATH)
+
+    print("\nFinal family counts:")
+    for family in ALL_FAMILIES:
+        print(f"- {family}: {len(support_db[family])} embeddings")
+
+
+if __name__ == "__main__":
+    save_support_embeddings()

BACKEND/app/training/dataset_loader.py

@@ -0,0 +1 @@
+print("Dataset loader not used directly. PairDataset is used for training.")

BACKEND/app/training/loss_functions.py

@@ -0,0 +1,22 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ContrastiveLoss(nn.Module):
+    """
+    label = 1 -> same class
+    label = 0 -> different class
+    """
+    def __init__(self, margin: float = 1.0):
+        super().__init__()
+        self.margin = margin
+
+    def forward(self, emb1: torch.Tensor, emb2: torch.Tensor, label: torch.Tensor):
+        dist = F.pairwise_distance(emb1, emb2)
+
+        positive_loss = label * torch.pow(dist, 2)
+        negative_loss = (1 - label) * torch.pow(torch.clamp(self.margin - dist, min=0.0), 2)
+
+        loss = torch.mean(positive_loss + negative_loss)
+        return loss

BACKEND/app/training/pair_dataset.py

@@ -0,0 +1,79 @@
+import os
+import random
+from typing import Dict, List
+
+from PIL import Image
+import torch
+from torch.utils.data import Dataset
+from torchvision import transforms
+
+
+class PairDataset(Dataset):
+    def __init__(
+        self,
+        root_dir: str,
+        families: List[str],
+        image_size: int = 224,
+        pairs_per_epoch: int = 1000,
+    ):
+        self.root_dir = root_dir
+        self.families = families
+        self.pairs_per_epoch = pairs_per_epoch
+
+        self.transform = transforms.Compose([
+            transforms.Resize((image_size, image_size)),
+            transforms.ToTensor(),
+        ])
+
+        self.family_to_images: Dict[str, List[str]] = {}
+
+        for family in families:
+            family_dir = os.path.join(root_dir, family)
+            if not os.path.isdir(family_dir):
+                continue
+
+            files = []
+            for f in os.listdir(family_dir):
+                if f.lower().endswith(".png"):
+                    full_path = os.path.join(family_dir, f)
+                    try:
+                        with Image.open(full_path) as img:
+                            img.verify()
+                        files.append(full_path)
+                    except Exception:
+                        continue
+
+            if len(files) >= 2:
+                self.family_to_images[family] = files
+
+        self.valid_families = list(self.family_to_images.keys())
+
+        if len(self.valid_families) < 2:
+            raise ValueError("At least 2 valid families with >=2 images each are required.")
+
+    def __len__(self):
+        return self.pairs_per_epoch
+
+    def _load_image(self, path: str) -> torch.Tensor:
+        img = Image.open(path).convert("L")
+        return self.transform(img)
+
+    def __getitem__(self, index: int):
+        same_class = random.randint(0, 1)
+
+        if same_class == 1:
+            family = random.choice(self.valid_families)
+            img_paths = random.sample(self.family_to_images[family], 2)
+            label = 1.0
+        else:
+            fam1, fam2 = random.sample(self.valid_families, 2)
+            img_paths = [
+                random.choice(self.family_to_images[fam1]),
+                random.choice(self.family_to_images[fam2]),
+            ]
+            label = 0.0
+
+        img1 = self._load_image(img_paths[0])
+        img2 = self._load_image(img_paths[1])
+
+        return img1, img2, torch.tensor(label, dtype=torch.float32)

BACKEND/app/training/train_resnet34.py

@@ -0,0 +1,112 @@
+import os
+import json
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+
+from app.models.resnet34_siamese import SiameseResNet34
+from app.training.pair_dataset import PairDataset
+from app.training.loss_functions import ContrastiveLoss
+
+
+TRAIN_DIR = "data/train_images"
+MODEL_DIR = "trained_models"
+MODEL_PATH = os.path.join(MODEL_DIR, "resnet34_best.pth")
+HISTORY_PATH = os.path.join(MODEL_DIR, "train_history.json")
+
+TRAIN_FAMILIES = ["benign", "banking", "smsware"]
+
+IMAGE_SIZE = 224
+PAIRS_PER_EPOCH = 1000
+EPOCHS = 30
+LR = 0.00005
+TRAIN_BATCH_SIZE = 2
+DEVICE = "cpu"
+
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+
+def train():
+    ensure_dir(MODEL_DIR)
+
+    dataset = PairDataset(
+        root_dir=TRAIN_DIR,
+        families=TRAIN_FAMILIES,
+        image_size=IMAGE_SIZE,
+        pairs_per_epoch=PAIRS_PER_EPOCH,
+    )
+
+    loader = DataLoader(
+        dataset,
+        batch_size=TRAIN_BATCH_SIZE,
+        shuffle=True,
+        num_workers=0,
+    )
+
+    model = SiameseResNet34(
+        embed_dim=128,
+        pretrained=True,
+        freeze_backbone=False
+    ).to(DEVICE)
+
+    # Freeze most of the backbone, train only the deeper part
+    for name, param in model.encoder.feature_extractor.named_parameters():
+        param.requires_grad = False
+        if "7" in name:
+            param.requires_grad = True
+
+    # embedding head ہمیشہ trainable رہے
+    for param in model.encoder.embedding_head.parameters():
+        param.requires_grad = True
+
+    criterion = ContrastiveLoss(margin=1.5)
+    optimizer = torch.optim.Adam(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=LR
+    )
+
+    best_loss = float("inf")
+    history = []
+
+    for epoch in range(EPOCHS):
+        model.train()
+        running_loss = 0.0
+
+        for img1, img2, labels in loader:
+            img1 = img1.to(DEVICE)
+            img2 = img2.to(DEVICE)
+            labels = labels.to(DEVICE).float()
+
+            optimizer.zero_grad()
+
+            emb1, emb2 = model(img1, img2)
+            emb1 = F.normalize(emb1, p=2, dim=1)
+            emb2 = F.normalize(emb2, p=2, dim=1)
+
+            loss = criterion(emb1, emb2, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+        epoch_loss = running_loss / len(loader)
+        history.append({"epoch": epoch + 1, "loss": epoch_loss})
+
+        print(f"Epoch [{epoch + 1}/{EPOCHS}] Loss: {epoch_loss:.4f}")
+
+        if epoch_loss < best_loss:
+            best_loss = epoch_loss
+            torch.save(model.state_dict(), MODEL_PATH)
+            print(f"Best model saved at epoch {epoch + 1}")
+
+    with open(HISTORY_PATH, "w") as f:
+        json.dump(history, f, indent=2)
+
+    print("\nTraining complete.")
+    print("Best model path:", MODEL_PATH)
+
+
+if __name__ == "__main__":
+    train()

BACKEND/app/utils/file_utils.py

@@ -0,0 +1,5 @@
+import os
+
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)

BACKEND/app/utils/image_utils.py

@@ -0,0 +1,5 @@
+from PIL import Image
+
+
+def open_grayscale(image_path: str):
+    return Image.open(image_path).convert("L")

BACKEND/data_split.py

@@ -0,0 +1,270 @@
+import os
+import shutil
+from typing import List, Tuple
+
+import numpy as np
+from PIL import Image
+
+# =========================
+# SETTINGS
+# =========================
+
+SOURCE_DIR = "data/grayscale_images"
+
+TRAIN_DIR = "data/train_images"
+SUPPORT_DIR = "data/support_set"
+TEST_DIR = "data/test_images"
+
+TRAIN_FAMILIES = ["benign", "banking", "smsware"]
+ALL_FAMILIES = ["benign", "banking", "smsware", "adware", "riskware"]
+
+TRAIN_COUNT = 10
+SUPPORT_COUNT = 5
+TEST_COUNT = 5
+
+# =========================
+# MANUAL SUPPORT SELECTION
+# =========================
+# Agar kisi family ke liye yahan filenames di hui hon,
+# to support set unhi files se banega.
+# Baqi split automatically hoga.
+#
+# IMPORTANT:
+# Ye filenames exact waise hi honi chahiye jaisi
+# SOURCE_DIR/family folder me موجود hain.
+#
+# Abhi smsware ke liye manual support ON hai.
+MANUAL_SUPPORT = {
+     "smsware": [
+        "020cdc2d622af016d7cbfcee797e078884380a6635ebe70b36a5c527608ec07f.png",
+        "0221511d597a5ab7b6303e12675dabadf6f48db968fa26403ee70a041e3a6826.png",
+        "043b4fbc2b58040754a20844e8bc85139ce38daffd40ce53ba0a91ba052ca84b.png",
+        "0454a5c0ff9fea30a5084af2354ef142f0ee5dbbf3545edb4bf0d07b2242bbeb.png",
+        "015b473e1d56054bed16899430ea95f9ac940a45ab0ec4888a119279667e7916.png",
+    ]
+}
+
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+def reset_family_dir(path):
+    if os.path.isdir(path):
+        shutil.rmtree(path)
+    os.makedirs(path, exist_ok=True)
+
+def copy_files(files, src_dir, dst_dir):
+    ensure_dir(dst_dir)
+
+    for f in files:
+        src = os.path.join(src_dir, f)
+        dst = os.path.join(dst_dir, f)
+        shutil.copy(src, dst)
+
+def get_image_score(image_path: str) -> float:
+    """
+    Higher score = better / more informative image.
+    Prefer images with reasonable contrast and non-extreme brightness.
+    """
+    try:
+        img = Image.open(image_path).convert("L")
+        arr = np.array(img, dtype=np.float32)
+
+        mean_val = float(arr.mean())
+        std_val = float(arr.std())
+
+        mean_penalty = abs(mean_val - 127.5) / 127.5
+        score = std_val - (mean_penalty * 20.0)
+        return score
+    except Exception:
+        return -1e9
+
+def get_ranked_images(family_src: str) -> List[str]:
+    images = [
+        f for f in os.listdir(family_src)
+        if f.lower().endswith(".png")
+    ]
+
+    scored_images: List[Tuple[str, float]] = []
+
+    for f in images:
+        path = os.path.join(family_src, f)
+        score = get_image_score(path)
+        if score > -1e8:
+            scored_images.append((f, score))
+
+    scored_images.sort(key=lambda x: x[1], reverse=True)
+    return [f for f, _ in scored_images]
+
+def pick_spread_items(images: List[str], count: int) -> List[str]:
+    """
+    Pick evenly spread samples from a ranked list so support is diverse.
+    """
+    if len(images) <= count:
+        return images[:count]
+
+    indices = np.linspace(0, len(images) - 1, count, dtype=int)
+    picked = [images[i] for i in indices]
+
+    unique_picked = []
+    for item in picked:
+        if item not in unique_picked:
+            unique_picked.append(item)
+
+    if len(unique_picked) < count:
+        for item in images:
+            if item not in unique_picked:
+                unique_picked.append(item)
+            if len(unique_picked) == count:
+                break
+
+    return unique_picked[:count]
+
+def validate_manual_support(family: str, family_src: str, manual_files: List[str]) -> List[str]:
+    """
+    Keep only valid manual support files that actually exist.
+    """
+    valid = []
+    missing = []
+
+    for f in manual_files:
+        full_path = os.path.join(family_src, f)
+        if os.path.isfile(full_path):
+            valid.append(f)
+        else:
+            missing.append(f)
+
+    if missing:
+        print(f"[WARNING] Missing manual support files for {family}:")
+        for f in missing:
+            print(f"  - {f}")
+
+    if len(valid) < SUPPORT_COUNT:
+        print(
+            f"[WARNING] Manual support for {family} has only {len(valid)} valid files. "
+            f"Need {SUPPORT_COUNT}. Falling back to auto-fill for remaining."
+        )
+
+    return valid
+
+def split_seen_family(images: List[str], family: str, family_src: str):
+    """
+    Seen family split:
+    - support = 5
+    - train   = 10
+    - test    = 5
+
+    smsware ke liye manual support allow hai.
+    """
+    required = SUPPORT_COUNT + TRAIN_COUNT + TEST_COUNT
+    if len(images) < required:
+        print(f"[WARNING] Seen family has fewer than required images: {len(images)} < {required}")
+
+    pool = images[:max(required, 20)]
+
+    # =========================
+    # Manual support mode
+    # =========================
+    if family in MANUAL_SUPPORT:
+        manual_support = validate_manual_support(family, family_src, MANUAL_SUPPORT[family])
+
+        remaining_candidates = [img for img in pool if img not in manual_support]
+
+        # Agar manual support 5 se kam ho to auto-fill kar do
+        if len(manual_support) < SUPPORT_COUNT:
+            needed = SUPPORT_COUNT - len(manual_support)
+            auto_fill = remaining_candidates[:needed]
+            support = manual_support + auto_fill
+        else:
+            support = manual_support[:SUPPORT_COUNT]
+
+        remaining = [img for img in pool if img not in support]
+        train = remaining[:TRAIN_COUNT]
+        test = remaining[TRAIN_COUNT:TRAIN_COUNT + TEST_COUNT]
+
+        return train, support, test
+
+    # =========================
+    # Auto split for seen families
+    # =========================
+    support_candidates = pool[:15] if len(pool) >= 15 else pool
+    support = pick_spread_items(support_candidates, SUPPORT_COUNT)
+
+    remaining = [img for img in pool if img not in support]
+    train = remaining[:TRAIN_COUNT]
+    test = remaining[TRAIN_COUNT:TRAIN_COUNT + TEST_COUNT]
+
+    return train, support, test
+
+def split_unseen_family(images: List[str]):
+    """
+    Unseen family split:
+    - train   = 0
+    - support = 5
+    - test    = 5
+    """
+    required = SUPPORT_COUNT + TEST_COUNT
+    if len(images) < required:
+        print(f"[WARNING] Unseen family has fewer than required images: {len(images)} < {required}")
+
+    pool = images[:max(required, 15)]
+
+    support_candidates = pool[:10] if len(pool) >= 10 else pool
+    support = pick_spread_items(support_candidates, SUPPORT_COUNT)
+
+    remaining = [img for img in pool if img not in support]
+    test = remaining[:TEST_COUNT]
+
+    train = []
+    return train, support, test
+
+def main():
+    print("\n========== DATASET SPLIT START ==========\n")
+
+    ensure_dir(TRAIN_DIR)
+    ensure_dir(SUPPORT_DIR)
+    ensure_dir(TEST_DIR)
+
+    for family in ALL_FAMILIES:
+        family_src = os.path.join(SOURCE_DIR, family)
+
+        if not os.path.isdir(family_src):
+            print(f"[WARNING] Missing source folder: {family_src}")
+            continue
+
+        images = get_ranked_images(family_src)
+
+        print(f"\nProcessing: {family}")
+        print("Valid images found:", len(images))
+
+        if family in TRAIN_FAMILIES:
+            train, support, test = split_seen_family(images, family, family_src)
+        else:
+            train, support, test = split_unseen_family(images)
+
+        reset_family_dir(os.path.join(TRAIN_DIR, family))
+        reset_family_dir(os.path.join(SUPPORT_DIR, family))
+        reset_family_dir(os.path.join(TEST_DIR, family))
+
+        copy_files(train, family_src, os.path.join(TRAIN_DIR, family))
+        copy_files(support, family_src, os.path.join(SUPPORT_DIR, family))
+        copy_files(test, family_src, os.path.join(TEST_DIR, family))
+
+        print("Train  :", len(train))
+        print("Support:", len(support))
+        print("Test   :", len(test))
+
+        if family in TRAIN_FAMILIES:
+            if family in MANUAL_SUPPORT:
+                print("Seen split  -> manual support(5), train(10), test(5)")
+                print("Manual support files:")
+                for f in support:
+                    print(f"  - {f}")
+            else:
+                print("Seen split  -> support(diverse 5), train(10), test(5)")
+        else:
+            print("Unseen split -> support(diverse 5), test(5), no train")
+
+    print("\n========== DATASET SPLIT DONE ==========\n")
+
+if __name__ == "__main__":
+    main()

BACKEND/dockerfile

@@ -0,0 +1,28 @@
+# ----- Stage 1: React Frontend Build -----
+FROM node:18 AS frontend-build
+WORKDIR /app/frontend
+COPY malware-detection-frontend/package*.json ./
+RUN npm install
+COPY malware-detection-frontend/ ./
+# React build karein (static files 'build' folder mein aayengi)
+RUN npm run build
+
+# ----- Stage 2: Python Backend -----
+FROM python:3.10-slim
+WORKDIR /app/backend
+
+# Build folder ko frontend se copy karein
+COPY --from=frontend-build /app/frontend/build /app/backend/frontend_build
+
+# Backend dependencies install karein
+COPY BACKEND/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Poora backend code copy karein
+COPY BACKEND/ ./
+
+# CRITICAL: Hugging Face Space sirf port 7860 expose karta hai
+EXPOSE 7860
+
+# FastAPI chalayein (port 7860 par)
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

BACKEND/list_models.py

@@ -0,0 +1,10 @@
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+print("Available models:")
+for model in genai.list_models():
+    print(f"  {model.name}")

BACKEND/requirements.txt

@@ -0,0 +1,37 @@
+fastapi
+uvicorn
+python-multipart
+numpy
+pillow
+torch
+torchvision
+pydantic
+python-jose[cryptography]
+passlib[bcrypt]
+python-multipart
+email-validator
+aiosmtplib
+python-dotenv
+werkzeug
+python-jose[cryptography]
+python-dotenv
+sqlalchemy
+aiosqlite
+email-validator
+fastapi
+uvicorn
+python-multipart
+numpy
+pillow
+pydantic
+python-jose[cryptography]
+werkzeug
+sqlalchemy
+python-dotenv
+scikit-learn
+torch --index-url https://download.pytorch.org/whl/cpu
+torchvision --index-url https://download.pytorch.org/whl/cpu
+gradio
+pandas
+scikit-learn
+# Add any other libraries you use, e.g., torch, tensorflow, joblib

BACKEND/run_backend.py

@@ -0,0 +1,27 @@
+import uvicorn
+import os
+import sys
+print(sys.executable)
+
+def main():
+    """
+    Start FastAPI backend server
+    """
+
+    print("\n====================================")
+    print(" Android Malware FSL Backend Server ")
+    print("====================================\n")
+
+    print("Server starting...")
+    print("API URL: http://127.0.0.1:8000")
+    print("Docs: http://127.0.0.1:8000/docs\n")
+
+    uvicorn.run(
+        "app.main:app",
+        host="127.0.0.1",
+        port=8000,
+        reload=True
+    )
+
+if __name__ == "__main__":
+    main()

BACKEND/setup_dataset.py

@@ -0,0 +1,142 @@
+import os
+import zipfile
+from app.preprocessing.apk_pipeline import apk_to_image_pipeline
+
+# =========================
+# SETTINGS
+# =========================
+RAW_APKS_DIR = "data/raw_apks"
+GRAY_IMAGES_DIR = "data/grayscale_images"
+TEMP_DIR = "temp"
+FINAL_SIZE = (300, 300)
+
+# Target number of grayscale images per family
+TARGET_IMAGES_PER_FAMILY = 20
+
+# Families to process
+FAMILIES = ["benign", "banking", "smsware", "adware", "riskware"]
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+def is_valid_apk(file_path: str) -> bool:
+    """
+    Check file validity by trying to open it as APK/ZIP
+    and verifying that at least one .dex exists.
+    Extension does not matter.
+    """
+    try:
+        with zipfile.ZipFile(file_path, "r") as zip_ref:
+            names = zip_ref.namelist()
+            for name in names:
+                if name.lower().endswith(".dex"):
+                    return True
+    except Exception:
+        return False
+    return False
+
+def count_existing_images(folder: str) -> int:
+    """Count PNG files in a directory."""
+    if not os.path.isdir(folder):
+        return 0
+    return len([f for f in os.listdir(folder) if f.lower().endswith(".png")])
+
+def main():
+    ensure_dir(RAW_APKS_DIR)
+    ensure_dir(GRAY_IMAGES_DIR)
+    ensure_dir(TEMP_DIR)
+
+    total_files = 0
+    total_converted = 0
+    total_skipped = 0
+    total_failed = 0
+
+    print("\n========== APK TO GRAYSCALE DATASET SETUP ==========")
+    print(f"Target images per family: {TARGET_IMAGES_PER_FAMILY}\n")
+
+    for family in FAMILIES:
+        input_family_dir = os.path.join(RAW_APKS_DIR, family)
+        output_family_dir = os.path.join(GRAY_IMAGES_DIR, family)
+        ensure_dir(output_family_dir)
+
+        # Count existing images
+        existing = count_existing_images(output_family_dir)
+        needed = TARGET_IMAGES_PER_FAMILY - existing
+
+        if needed <= 0:
+            print(f"\n--- Family: {family} ---")
+            print(f"Already have {existing} images (target {TARGET_IMAGES_PER_FAMILY}). Skipping.")
+            continue
+
+        if not os.path.isdir(input_family_dir):
+            print(f"[WARNING] Family folder not found: {input_family_dir}")
+            continue
+
+        files = [
+            f for f in os.listdir(input_family_dir)
+            if os.path.isfile(os.path.join(input_family_dir, f))
+        ]
+
+        print(f"\n--- Processing family: {family} ---")
+        print(f"Input folder : {input_family_dir}")
+        print(f"Output folder: {output_family_dir}")
+        print(f"Existing images: {existing}")
+        print(f"Need {needed} more to reach {TARGET_IMAGES_PER_FAMILY}")
+        print(f"Available raw APKs: {len(files)}")
+
+        family_converted = 0
+        family_skipped = 0
+        family_failed = 0
+
+        # Process files until we have enough successful conversions
+        for file_name in files:
+            # Stop if we already reached the target
+            if family_converted >= needed:
+                break
+
+            total_files += 1
+            file_path = os.path.join(input_family_dir, file_name)
+            image_name = os.path.splitext(file_name)[0] + ".png"
+            output_image_path = os.path.join(output_family_dir, image_name)
+
+            # Skip if output already exists (to avoid reprocessing)
+            if os.path.isfile(output_image_path):
+                print(f"[SKIP] Already exists: {image_name}")
+                continue
+
+            if not is_valid_apk(file_path):
+                print(f"[SKIPPED] Not a valid APK: {file_name}")
+                total_skipped += 1
+                family_skipped += 1
+                continue
+
+            try:
+                apk_to_image_pipeline(
+                    apk_path=file_path,
+                    temp_dir=TEMP_DIR,
+                    output_image_path=output_image_path,
+                    final_size=FINAL_SIZE,
+                )
+                print(f"[OK] {file_name} -> {image_name}")
+                total_converted += 1
+                family_converted += 1
+            except Exception as e:
+                print(f"[FAILED] {file_name}: {e}")
+                total_failed += 1
+                family_failed += 1
+
+        print(f"\nFamily summary: {family}")
+        print(f"Converted this run: {family_converted}")
+        print(f"Skipped (invalid APK): {family_skipped}")
+        print(f"Failed (conversion error): {family_failed}")
+        print(f"Total images now in output: {existing + family_converted} / {TARGET_IMAGES_PER_FAMILY}")
+
+    print("\n========== FINAL DATASET REPORT ==========")
+    print(f"Total files processed (across all families): {total_files}")
+    print(f"Total converted (new images): {total_converted}")
+    print(f"Total skipped (invalid APKs): {total_skipped}")
+    print(f"Total failed (conversion errors): {total_failed}")
+    print("\nDone.")
+
+if __name__ == "__main__":
+    main()

BACKEND/support_embeddings.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1c8ad31ceceb345af0055921124428d9428cd8a5e4e2b682f4887c7aeea66b9
+size 19914

BACKEND/train_and_prepare.py

@@ -0,0 +1,13 @@
+import subprocess
+import sys
+
+def run(cmd):
+    print(f"\nRunning: {cmd}\n")
+    result = subprocess.run(cmd, shell=True)
+    if result.returncode != 0:
+        raise SystemExit(f"Command failed: {cmd}")
+
+if __name__ == "__main__":
+    run("python -m app.training.train_resnet34")
+    run("python -m app.support.save_support_embeddings")
+    print("\nTraining + support embedding preparation complete.")

BACKEND/trained_models/evaluation_metrics.json

@@ -0,0 +1,59 @@
+{
+  "overall_accuracy": 88.0,
+  "seen_accuracy": 93.33,
+  "unseen_accuracy": 80.0,
+  "family_accuracy": {
+    "adware": 80.0,
+    "banking": 80.0,
+    "benign": 100.0,
+    "riskware": 80.0,
+    "smsware": 100.0
+  },
+  "final_loss": null,
+  "confusion_matrix": {
+    "labels": [
+      "adware",
+      "banking",
+      "benign",
+      "riskware",
+      "smsware"
+    ],
+    "data": [
+      [
+        4,
+        0,
+        0,
+        0,
+        1
+      ],
+      [
+        0,
+        4,
+        0,
+        1,
+        0
+      ],
+      [
+        0,
+        0,
+        5,
+        0,
+        0
+      ],
+      [
+        1,
+        0,
+        0,
+        4,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        5
+      ]
+    ]
+  }
+}

BACKEND/trained_models/train_history.json

@@ -0,0 +1,122 @@
+[
+  {
+    "epoch": 1,
+    "loss": 0.4506978592146188
+  },
+  {
+    "epoch": 2,
+    "loss": 0.27496393894823634
+  },
+  {
+    "epoch": 3,
+    "loss": 0.1254722394684377
+  },
+  {
+    "epoch": 4,
+    "loss": 0.0696122650919956
+  },
+  {
+    "epoch": 5,
+    "loss": 0.04518843412091075
+  },
+  {
+    "epoch": 6,
+    "loss": 0.03079532652905391
+  },
+  {
+    "epoch": 7,
+    "loss": 0.025460728151967614
+  },
+  {
+    "epoch": 8,
+    "loss": 0.01982011537145435
+  },
+  {
+    "epoch": 9,
+    "loss": 0.017253640811187125
+  },
+  {
+    "epoch": 10,
+    "loss": 0.014067793231458623
+  },
+  {
+    "epoch": 11,
+    "loss": 0.01228759345602434
+  },
+  {
+    "epoch": 12,
+    "loss": 0.010558591230152275
+  },
+  {
+    "epoch": 13,
+    "loss": 0.009027703136934235
+  },
+  {
+    "epoch": 14,
+    "loss": 0.006941486623447417
+  },
+  {
+    "epoch": 15,
+    "loss": 0.005425198441284692
+  },
+  {
+    "epoch": 16,
+    "loss": 0.004878156908180927
+  },
+  {
+    "epoch": 17,
+    "loss": 0.004208211276602924
+  },
+  {
+    "epoch": 18,
+    "loss": 0.007560494044383972
+  },
+  {
+    "epoch": 19,
+    "loss": 0.00530580484863458
+  },
+  {
+    "epoch": 20,
+    "loss": 0.002409123999372241
+  },
+  {
+    "epoch": 21,
+    "loss": 0.0017899585990744527
+  },
+  {
+    "epoch": 22,
+    "loss": 0.0011776607247920765
+  },
+  {
+    "epoch": 23,
+    "loss": 0.0008682082814884779
+  },
+  {
+    "epoch": 24,
+    "loss": 0.0005899137800715835
+  },
+  {
+    "epoch": 25,
+    "loss": 0.0004260540119180405
+  },
+  {
+    "epoch": 26,
+    "loss": 0.00020756016330960848
+  },
+  {
+    "epoch": 27,
+    "loss": 0.0028575134301947855
+  },
+  {
+    "epoch": 28,
+    "loss": 0.033012302423116126
+  },
+  {
+    "epoch": 29,
+    "loss": 0.0010803415227048987
+  },
+  {
+    "epoch": 30,
+    "loss": 0.000570854778501598
+  }
+]

malware-detection-frontend

@@ -1 +0,0 @@
-Subproject commit 440de81d7bee80b7835ae54a55661f446b56b08e

malware-detection-frontend/.gitignore

@@ -0,0 +1,31 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+echo "node_modules/
+/.next
+/build
+/.env
+.DS_Store
+*.log" > .gitignore
+public/image/signup.png
+public/image/signup1.png

malware-detection-frontend/README.md

@@ -0,0 +1,70 @@
+# Getting Started with Create React App
+
+This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm start`
+
+Runs the app in the development mode.\
+Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
+
+The page will reload when you make changes.\
+You may also see any lint errors in the console.
+
+### `npm test`
+
+Launches the test runner in the interactive watch mode.\
+See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
+
+### `npm run build`
+
+Builds the app for production to the `build` folder.\
+It correctly bundles React in production mode and optimizes the build for the best performance.
+
+The build is minified and the filenames include the hashes.\
+Your app is ready to be deployed!
+
+See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
+
+### `npm run eject`
+
+**Note: this is a one-way operation. Once you `eject`, you can't go back!**
+
+If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
+
+Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
+
+You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
+
+## Learn More
+
+You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
+
+To learn React, check out the [React documentation](https://reactjs.org/).
+
+### Code Splitting
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
+
+### Analyzing the Bundle Size
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
+
+### Making a Progressive Web App
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
+
+### Advanced Configuration
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
+
+### Deployment
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
+
+### `npm run build` fails to minify
+
+This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)