SignPhotos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why did the encryption algorithm go to therapy? It had too many issues to decrypt!\n",
    "#need to test the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: Pillow in c:\\users\\ray81\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (10.2.0)\n",
      "Requirement already satisfied: cryptography in c:\\users\\ray81\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (42.0.7)\n",
      "Requirement already satisfied: cffi>=1.12 in c:\\users\\ray81\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from cryptography) (1.16.0)\n",
      "Requirement already satisfied: pycparser in c:\\users\\ray81\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from cffi>=1.12->cryptography) (2.22)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 23.0.1 -> 24.0\n",
      "[notice] To update, run: C:\\Users\\ray81\\AppData\\Local\\Programs\\Python\\Python310\\python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "!pip install Pillow cryptography"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def add_watermark(image_path, watermark_text, output_path):\n",
    "    # Load the original image\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Convert image to grayscale\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "    # Create a binary watermark image\n",
    "    watermark = np.zeros_like(gray)\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "    cv2.putText(watermark, watermark_text, (10, 50), font, 1, 255, 2, cv2.LINE_AA)\n",
    "\n",
    "    # Embed the watermark by adding it to the LSB of the image\n",
    "    watermarked = cv2.addWeighted(gray, 1, watermark, 0.1, 0)\n",
    "    watermarked = cv2.merge([watermarked, watermarked, watermarked])\n",
    "\n",
    "    # Save the watermarked image\n",
    "    cv2.imwrite(output_path, watermarked)\n",
    "\n",
    "# Example usage\n",
    "add_watermark('photo.jpg', 'My Watermark', 'watermarked_photo.jpg')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'photo.jpg'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[2], line 56\u001b[0m\n\u001b[0;32m     53\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m signature\n\u001b[0;32m     55\u001b[0m \u001b[38;5;66;03m# Create a digital signature\u001b[39;00m\n\u001b[1;32m---> 56\u001b[0m signature \u001b[38;5;241m=\u001b[39m \u001b[43mcreate_signature\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mphoto.jpg\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprivate_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     58\u001b[0m \u001b[38;5;66;03m# Save the signature to a file\u001b[39;00m\n\u001b[0;32m     59\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msignature.bin\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwb\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m signature_file:\n",
      "Cell \u001b[1;32mIn[2], line 35\u001b[0m, in \u001b[0;36mcreate_signature\u001b[1;34m(image_path, private_key)\u001b[0m\n\u001b[0;32m     34\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcreate_signature\u001b[39m(image_path, private_key):\n\u001b[1;32m---> 35\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mimage_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m image_file:\n\u001b[0;32m     36\u001b[0m         image_data \u001b[38;5;241m=\u001b[39m image_file\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m     38\u001b[0m \u001b[38;5;66;03m# Create a hash of the image\u001b[39;00m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\IPython\\core\\interactiveshell.py:310\u001b[0m, in \u001b[0;36m_modified_open\u001b[1;34m(file, *args, **kwargs)\u001b[0m\n\u001b[0;32m    303\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[0;32m    304\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    305\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    306\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    307\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    308\u001b[0m     )\n\u001b[1;32m--> 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'photo.jpg'"
     ]
    }
   ],
   "source": [
    "from cryptography.hazmat.primitives import hashes, serialization\n",
    "from cryptography.hazmat.primitives.asymmetric import padding, rsa\n",
    "from cryptography.hazmat.primitives.asymmetric.utils import Prehashed\n",
    "\n",
    "# Generate a private key for signing\n",
    "private_key = rsa.generate_private_key(\n",
    "    public_exponent=65537,\n",
    "    key_size=2048\n",
    ")\n",
    "\n",
    "# Save the private key\n",
    "with open(\"private_key.pem\", \"wb\") as key_file:\n",
    "    key_file.write(\n",
    "        private_key.private_bytes(\n",
    "            encoding=serialization.Encoding.PEM,\n",
    "            format=serialization.PrivateFormat.TraditionalOpenSSL,\n",
    "            encryption_algorithm=serialization.NoEncryption()\n",
    "        )\n",
    "    )\n",
    "\n",
    "# Generate a public key for verification\n",
    "public_key = private_key.public_key()\n",
    "\n",
    "# Save the public key\n",
    "with open(\"public_key.pem\", \"wb\") as key_file:\n",
    "    key_file.write(\n",
    "        public_key.public_bytes(\n",
    "            encoding=serialization.Encoding.PEM,\n",
    "            format=serialization.PublicFormat.SubjectPublicKeyInfo\n",
    "        )\n",
    "    )\n",
    "\n",
    "# Function to create a digital signature\n",
    "def create_signature(image_path, private_key):\n",
    "    with open(image_path, \"rb\") as image_file:\n",
    "        image_data = image_file.read()\n",
    "\n",
    "    # Create a hash of the image\n",
    "    image_hash = hashes.Hash(hashes.SHA256())\n",
    "    image_hash.update(image_data)\n",
    "    digest = image_hash.finalize()\n",
    "\n",
    "    # Sign the hash with the private key\n",
    "    signature = private_key.sign(\n",
    "        digest,\n",
    "        padding.PSS(\n",
    "            mgf=padding.MGF1(hashes.SHA256()),\n",
    "            salt_length=padding.PSS.MAX_LENGTH\n",
    "        ),\n",
    "        Prehashed(hashes.SHA256())\n",
    "    )\n",
    "\n",
    "    return signature\n",
    "\n",
    "# Create a digital signature\n",
    "signature = create_signature(\"photo.jpg\", private_key)\n",
    "\n",
    "# Save the signature to a file\n",
    "with open(\"signature.bin\", \"wb\") as signature_file:\n",
    "    signature_file.write(signature)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'signature.bin'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[3], line 34\u001b[0m\n\u001b[0;32m     31\u001b[0m     public_key \u001b[38;5;241m=\u001b[39m serialization\u001b[38;5;241m.\u001b[39mload_pem_public_key(key_file\u001b[38;5;241m.\u001b[39mread())\n\u001b[0;32m     33\u001b[0m \u001b[38;5;66;03m# Load the signature\u001b[39;00m\n\u001b[1;32m---> 34\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msignature.bin\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m signature_file:\n\u001b[0;32m     35\u001b[0m     signature \u001b[38;5;241m=\u001b[39m signature_file\u001b[38;5;241m.\u001b[39mread()\n\u001b[0;32m     37\u001b[0m \u001b[38;5;66;03m# Verify the signature\u001b[39;00m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\IPython\\core\\interactiveshell.py:310\u001b[0m, in \u001b[0;36m_modified_open\u001b[1;34m(file, *args, **kwargs)\u001b[0m\n\u001b[0;32m    303\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[0;32m    304\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    305\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    306\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    307\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    308\u001b[0m     )\n\u001b[1;32m--> 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'signature.bin'"
     ]
    }
   ],
   "source": [
    "#vertify digital signature\n",
    "\n",
    "from cryptography.hazmat.primitives.asymmetric import padding\n",
    "from cryptography.hazmat.primitives import hashes, serialization\n",
    "\n",
    "# Function to verify a digital signature\n",
    "def verify_signature(image_path, signature, public_key):\n",
    "    with open(image_path, \"rb\") as image_file:\n",
    "        image_data = image_file.read()\n",
    "\n",
    "    # Create a hash of the image\n",
    "    image_hash = hashes.Hash(hashes.SHA256())\n",
    "    image_hash.update(image_data)\n",
    "    digest = image_hash.finalize()\n",
    "\n",
    "    # Verify the signature with the public key\n",
    "    try:\n",
    "        public_key.verify(\n",
    "            signature,\n",
    "            digest,\n",
    "            padding.PSS(\n",
    "                mgf=padding.MGF1(hashes.SHA256()),\n",
    "                salt_length=padding.PSS.MAX_LENGTH\n",
    "            ),\n",
    "            Prehashed(hashes.SHA256())\n",
    "        )\n",
    "        print(\"Signature is valid.\")\n",
    "    except Exception as e:\n",
    "        print(\"Signature verification failed:\", str(e))\n",
    "\n",
    "# Load the public key\n",
    "with open(\"public_key.pem\", \"rb\") as key_file:\n",
    "    public_key = serialization.load_pem_public_key(key_file.read())\n",
    "\n",
    "# Load the signature\n",
    "with open(\"signature.bin\", \"rb\") as signature_file:\n",
    "    signature = signature_file.read()\n",
    "\n",
    "# Verify the signature\n",
    "verify_signature(\"photo.jpg\", signature, public_key)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from PIL import Image, ImageDraw, ImageFont\n",
    "\n",
    "def add_signature(image_path, signature_text, output_path):\n",
    "    # Open an image file\n",
    "    with Image.open(image_path) as img:\n",
    "        draw = ImageDraw.Draw(img)\n",
    "        font = ImageFont.truetype(\"arial.ttf\", 50)  # Adjust font and size as needed\n",
    "\n",
    "        # Position for the signature (bottom right corner)\n",
    "        text_width, text_height = draw.textsize(signature_text, font)\n",
    "        width, height = img.size\n",
    "        x = width - text_width - 10\n",
    "        y = height - text_height - 10\n",
    "\n",
    "        # Add the signature to the image\n",
    "        draw.text((x, y), signature_text, font=font, fill=(255, 255, 255))\n",
    "\n",
    "        # Save the image with the signature\n",
    "        img.save(output_path)\n",
    "\n",
    "# Example usage\n",
    "add_signature(\"photo.jpg\", \"John Doe\", \"signed_photo.jpg\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives import hashes, serialization\n",
    "from cryptography.hazmat.primitives.asymmetric import padding\n",
    "from cryptography.exceptions import InvalidSignature\n",
    "\n",
    "# Load the public key\n",
    "with open(\"public_key.pem\", \"rb\") as key_file:\n",
    "    public_key = serialization.load_pem_public_key(key_file.read())\n",
    "\n",
    "# Load the signature\n",
    "with open(\"signature.sig\", \"rb\") as signature_file\":\n",
    "    signature = signature_file.read()\n",
    "\n",
    "# Load the photo\n",
    "with open(\"photo.jpg\", \"rb\") as photo_file:\n",
    "    photo_data = photo_file.read()\n",
    "\n",
    "# Verify the signature\n",
    "try:\n",
    "    public_key.verify(\n",
    "        signature,\n",
    "        photo_data,\n",
    "        padding.PKCS1v15(),\n",
    "        hashes.SHA256()\n",
    "    )\n",
    "    print(\"Signature is valid.\")\n",
    "except InvalidSignature:\n",
    "    print(\"Signature is invalid.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives import hashes, serialization\n",
    "from cryptography.hazmat.primitives.asymmetric import padding\n",
    "\n",
    "# Load the private key\n",
    "with open(\"private_key.pem\", \"rb\") as key_file:\n",
    "    private_key = serialization.load_pem_private_key(\n",
    "        key_file.read(),\n",
    "        password=None  # or provide the password if the key is encrypted\n",
    "    )\n",
    "\n",
    "# Load the photo\n",
    "with open(\"photo.jpg\", \"rb\") as photo_file:\n",
    "    photo_data = photo_file.read()\n",
    "\n",
    "# Create the hash and sign it\n",
    "signature = private_key.sign(\n",
    "    photo_data,\n",
    "    padding.PKCS1v15(),\n",
    "    hashes.SHA256()\n",
    ")\n",
    "\n",
    "# Save the signature to a file\n",
    "with open(\"signature.sig\", \"wb\") as signature_file:\n",
    "    signature_file.write(signature)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def embed_watermark(image_path, watermark_text, output_path):\n",
    "    # Load the original image\n",
    "    image = cv2.imread(image_path, cv2.IMREAD_COLOR)\n",
    "    \n",
    "    # Convert the image to float32 for better precision\n",
    "    image_float = np.float32(image)\n",
    "    \n",
    "    # Create a binary watermark image\n",
    "    watermark = np.zeros((image.shape[0], image.shape[1]), dtype=np.uint8)\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "    cv2.putText(watermark, watermark_text, (10, 50), font, 1, 255, 2, cv2.LINE_AA)\n",
    "    \n",
    "    # Normalize the watermark to range between 0 and 1\n",
    "    watermark = watermark / 255.0\n",
    "    \n",
    "    # Embed the watermark in the least significant bits of the image\n",
    "    watermarked_image = image_float\n",
    "    watermarked_image[:,:,0] = image_float[:,:,0] * (1 - watermark) + watermark * 255\n",
    "    \n",
    "    # Convert back to uint8\n",
    "    watermarked_image = np.uint8(watermarked_image)\n",
    "    \n",
    "    # Save the watermarked image\n",
    "    cv2.imwrite(output_path, watermarked_image)\n",
    "\n",
    "# Example usage\n",
    "embed_watermark('photo.jpg', 'My Watermark', 'watermarked_photo.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_watermark(watermarked_image_path):\n",
    "    # Load the watermarked image\n",
    "    watermarked_image = cv2.imread(watermarked_image_path, cv2.IMREAD_COLOR)\n",
    "    \n",
    "    # Convert the image to float32\n",
    "    watermarked_image_float = np.float32(watermarked_image)\n",
    "    \n",
    "    # Extract the watermark from the least significant bits\n",
    "    extracted_watermark = watermarked_image_float[:,:,0] - np.round(watermarked_image_float[:,:,0])\n",
    "    \n",
    "    # Normalize the watermark to range between 0 and 255\n",
    "    extracted_watermark = np.abs(extracted_watermark * 255)\n",
    "    \n",
    "    # Convert to uint8\n",
    "    extracted_watermark = np.uint8(extracted_watermark)\n",
    "    \n",
    "    return extracted_watermark\n",
    "\n",
    "# Example usage\n",
    "extracted_watermark = extract_watermark('watermarked_photo.png')\n",
    "cv2.imshow('Extracted Watermark', extracted_watermark)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "\n",
    "def create_hash(image_path):\n",
    "    # Read the image in binary mode\n",
    "    with open(image_path, 'rb') as image_file:\n",
    "        image_data = image_file.read()\n",
    "        \n",
    "    # Create a SHA-256 hash of the image\n",
    "    hash_object = hashlib.sha256(image_data)\n",
    "    hash_value = hash_object.hexdigest()\n",
    "    \n",
    "    return hash_value\n",
    "\n",
    "# Example usage\n",
    "hash_value = create_hash('photo.jpg')\n",
    "print(\"Hash Value:\", hash_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives import hashes\n",
    "from cryptography.hazmat.primitives.asymmetric import padding, rsa\n",
    "from cryptography.hazmat.primitives import serialization\n",
    "\n",
    "# Generate a private key (for demonstration purposes; usually, you have an existing key)\n",
    "private_key = rsa.generate_private_key(\n",
    "    public_exponent=65537,\n",
    "    key_size=2048,\n",
    ")\n",
    "\n",
    "# Serialize the private key to store it securely\n",
    "private_pem = private_key.private_bytes(\n",
    "    encoding=serialization.Encoding.PEM,\n",
    "    format=serialization.PrivateFormat.TraditionalOpenSSL,\n",
    "    encryption_algorithm=serialization.NoEncryption()\n",
    ")\n",
    "\n",
    "# Load the private key (in practice, load it from a secure storage)\n",
    "private_key = serialization.load_pem_private_key(\n",
    "    private_pem,\n",
    "    password=None,\n",
    ")\n",
    "\n",
    "# Function to sign the hash\n",
    "def sign_hash(hash_value, private_key):\n",
    "    # Convert the hash value to bytes\n",
    "    hash_bytes = bytes(hash_value, 'utf-8')\n",
    "    \n",
    "    # Sign the hash using the private key\n",
    "    signature = private_key.sign(\n",
    "        hash_bytes,\n",
    "        padding.PSS(\n",
    "            mgf=padding.MGF1(hashes.SHA256()),\n",
    "            salt_length=padding.PSS.MAX_LENGTH\n",
    "        ),\n",
    "        hashes.SHA256()\n",
    "    )\n",
    "    \n",
    "    return signature\n",
    "\n",
    "# Example usage\n",
    "signature = sign_hash(hash_value, private_key)\n",
    "print(\"Digital Signature:\", signature)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cryptography.hazmat.primitives.asymmetric import padding\n",
    "\n",
    "# Serialize the public key to distribute it securely\n",
    "public_key = private_key.public_key()\n",
    "public_pem = public_key.public_bytes(\n",
    "    encoding=serialization.Encoding.PEM,\n",
    "    format=serialization.PublicFormat.SubjectPublicKeyInfo\n",
    ")\n",
    "\n",
    "# Load the public key (in practice, load it from a distributed key)\n",
    "public_key = serialization.load_pem_public_key(public_pem)\n",
    "\n",
    "# Function to verify the signature\n",
    "def verify_signature(image_path, signature, public_key):\n",
    "    # Create the hash of the received image\n",
    "    received_hash_value = create_hash(image_path)\n",
    "    received_hash_bytes = bytes(received_hash_value, 'utf-8')\n",
    "    \n",
    "    # Verify the signature using the public key\n",
    "    try:\n",
    "        public_key.verify(\n",
    "            signature,\n",
    "            received_hash_bytes,\n",
    "            padding.PSS(\n",
    "                mgf=padding.MGF1(hashes.SHA256()),\n",
    "                salt_length=padding.PSS.MAX_LENGTH\n",
    "            ),\n",
    "            hashes.SHA256()\n",
    "        )\n",
    "        return True\n",
    "    except Exception as e:\n",
    "        print(\"Verification failed:\", e)\n",
    "        return False\n",
    "\n",
    "# Example usage\n",
    "verification_result = verify_signature('photo.jpg', signature, public_key)\n",
    "print(\"Verification Result:\", verification_result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "def pixelate_image(input_image_path, output_image_path, pixel_size):\n",
    "    # Open the input image\n",
    "    image = Image.open(input_image_path)\n",
    "    \n",
    "    # Get the size of the image\n",
    "    width, height = image.size\n",
    "    \n",
    "    # Resize the image to a smaller size\n",
    "    small_image = image.resize(\n",
    "        (width // pixel_size, height // pixel_size),\n",
    "        resample=Image.NEAREST\n",
    "    )\n",
    "    \n",
    "    # Scale it back up to the original size\n",
    "    pixelated_image = small_image.resize(\n",
    "        (width, height),\n",
    "        Image.NEAREST\n",
    "    )\n",
    "    \n",
    "    # Save the pixelated image\n",
    "    pixelated_image.save(output_image_path)\n",
    "    \n",
    "# Example usage\n",
    "input_image_path = 'input.jpg'\n",
    "output_image_path = 'output_pixelated.jpg'\n",
    "pixel_size = 10  # Adjust the pixel size for more or less pixelation\n",
    "\n",
    "pixelate_image(input_image_path, output_image_path, pixel_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "def mosaic_encrypt(image_path, block_size):\n",
    "    image = Image.open(image_path)\n",
    "    image = image.convert('RGB')\n",
    "    pixel_array = np.array(image)\n",
    "\n",
    "    for i in range(0, image.size[1], block_size):\n",
    "        for j in range(0, image.size[0], block_size):\n",
    "            for k in range(3):  # 对RGB三个通道分别处理\n",
    "                block = pixel_array[i:i + block_size, j:j + block_size, k]\n",
    "                block_mean = block.mean()\n",
    "                block[:, :] = block_mean\n",
    "\n",
    "    encrypted_image = Image.fromarray(pixel_array)\n",
    "    encrypted_image.save('encrypted_image.png')\n",
    "    return 'encrypted_image.png'\n",
    "\n",
    "def mosaic_decrypt(image_path, block_size):\n",
    "    # 马赛克加密是不可逆的，所以解密只能通过逆向方法进行，但图像会失真\n",
    "    return image_path\n",
    "\n",
    "# 示例使用\n",
    "original_image_path = 'path_to_your_image.png'\n",
    "block_size = 10  # 设置马赛克块大小\n",
    "\n",
    "# 加密图像\n",
    "encrypted_image_path = mosaic_encrypt(original_image_path, block_size)\n",
    "print(f\"加密后的图像已保存至: {encrypted_image_path}\")\n",
    "\n",
    "# 解密图像\n",
    "decrypted_image_path = mosaic_decrypt(encrypted_image_path, block_size)\n",
    "print(f\"解密后的图像路径: {decrypted_image_path}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
    "from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC\n",
    "from cryptography.hazmat.primitives import hashes\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "import os\n",
    "\n",
    "def encrypt_image(image_path, password, output_path):\n",
    "    # 读取图像\n",
    "    image = Image.open(image_path)\n",
    "    image = image.convert('RGB')\n",
    "    image_data = image.tobytes()\n",
    "    \n",
    "    # 生成对称密钥\n",
    "    salt = os.urandom(16)\n",
    "    kdf = PBKDF2HMAC(\n",
    "        algorithm=hashes.SHA256(),\n",
    "        length=32,\n",
    "        salt=salt,\n",
    "        iterations=100000,\n",
    "        backend=default_backend()\n",
    "    )\n",
    "    key = kdf.derive(password.encode())\n",
    "    \n",
    "    # 加密图像数据\n",
    "    iv = os.urandom(16)\n",
    "    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())\n",
    "    encryptor = cipher.encryptor()\n",
    "    padded_data = image_data + b' ' * (16 - len(image_data) % 16)  # 对齐数据到块大小\n",
    "    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()\n",
    "    \n",
    "    # 保存加密后的图像数据\n",
    "    with open(output_path, 'wb') as f:\n",
    "        f.write(salt + iv + encrypted_data)\n",
    "\n",
    "# 示例使用\n",
    "image_path = 'path_to_your_image.png'\n",
    "password = 'your_password'\n",
    "output_path = 'encrypted_image.enc'\n",
    "encrypt_image(image_path, password, output_path)\n",
    "print(f\"加密后的图像已保存至: {output_path}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\n",
    "from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC\n",
    "from cryptography.hazmat.primitives import hashes\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "\n",
    "def decrypt_image(encrypted_path, password, output_path, image_size):\n",
    "    with open(encrypted_path, 'rb') as f:\n",
    "        salt = f.read(16)\n",
    "        iv = f.read(16)\n",
    "        encrypted_data = f.read()\n",
    "    \n",
    "    # 生成对称密钥\n",
    "    kdf = PBKDF2HMAC(\n",
    "        algorithm=hashes.SHA256(),\n",
    "        length=32,\n",
    "        salt=salt,\n",
    "        iterations=100000,\n",
    "        backend=default_backend()\n",
    "    )\n",
    "    key = kdf.derive(password.encode())\n",
    "    \n",
    "    # 解密图像数据\n",
    "    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())\n",
    "    decryptor = cipher.decryptor()\n",
    "    decrypted_padded_data = decryptor.update(encrypted_data) + decryptor.finalize()\n",
    "    decrypted_data = decrypted_padded_data.rstrip(b' ')\n",
    "    \n",
    "    # 转换为图像并保存\n",
    "    decrypted_image = Image.frombytes('RGB', image_size, decrypted_data)\n",
    "    decrypted_image.save(output_path)\n",
    "\n",
    "# 示例使用\n",
    "encrypted_path = 'encrypted_image.enc'\n",
    "password = 'your_password'\n",
    "output_path = 'decrypted_image.png'\n",
    "image_size = (800, 600)  # 替换为原始图像的尺寸\n",
    "decrypt_image(encrypted_path, password, output_path, image_size)\n",
    "print(f\"解密后的图像已保存至: {output_path}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "def arnold_cat_map(image_array, iterations):\n",
    "    \"\"\"Apply the Arnold Cat Map to the given image array.\"\"\"\n",
    "    N = image_array.shape[0]\n",
    "    result = np.copy(image_array)\n",
    "    for _ in range(iterations):\n",
    "        new_array = np.copy(result)\n",
    "        for x in range(N):\n",
    "            for y in range(N):\n",
    "                new_x = (x + y) % N\n",
    "                new_y = (x + 2*y) % N\n",
    "                new_array[new_x, new_y] = result[x, y]\n",
    "        result = new_array\n",
    "    return result\n",
    "\n",
    "def inverse_arnold_cat_map(image_array, iterations):\n",
    "    \"\"\"Apply the inverse Arnold Cat Map to the given image array.\"\"\"\n",
    "    N = image_array.shape[0]\n",
    "    result = np.copy(image_array)\n",
    "    for _ in range(iterations):\n",
    "        new_array = np.copy(result)\n",
    "        for x in range(N):\n",
    "            for y in range(N):\n",
    "                new_x = (2*x - y) % N\n",
    "                new_y = (-x + y) % N\n",
    "                new_array[new_x, new_y] = result[x, y]\n",
    "        result = new_array\n",
    "    return result\n",
    "\n",
    "def transform_image(input_image_path, output_image_path, iterations, inverse=False):\n",
    "    \"\"\"Load an image, apply (inverse) Arnold Cat Map, and save the result.\"\"\"\n",
    "    image = Image.open(input_image_path)\n",
    "    image = image.convert('L')  # Convert to grayscale\n",
    "    image_array = np.array(image)\n",
    "    \n",
    "    if image_array.shape[0] != image_array.shape[1]:\n",
    "        raise ValueError(\"Image must be square.\")\n",
    "\n",
    "    if inverse:\n",
    "        transformed_image_array = inverse_arnold_cat_map(image_array, iterations)\n",
    "    else:\n",
    "        transformed_image_array = arnold_cat_map(image_array, iterations)\n",
    "\n",
    "    transformed_image = Image.fromarray(transformed_image_array)\n",
    "    transformed_image.save(output_image_path)\n",
    "\n",
    "# Example usage\n",
    "transform_image('input_image.png', 'transformed_image.png', iterations=10)\n",
    "transform_image('transformed_image.png', 'recovered_image.png', iterations=10, inverse=True)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}