Vite + React

37 |
38 | 39 | 40 | {result.type === 'encrypted' ? 'Encrypted Content' : 'Decrypted Content'} 41 | 42 | 50 |
51 | 52 |
53 |
60 |       </div>
61 | 
62 |       {result.type === 'encrypted' && result.hint && (
63 |         <div className="result-info">
64 |           <Info size={16} />
65 |           <span>Password hint: {result.hint}</span>
66 |         </div>
67 |       )}
68 | 
69 |       <div className="result-stats">
70 |         <span className="stat">
71 |           Length: {result.content.length} characters
72 |         </span>
73 |         {result.type === 'encrypted' && (
74 |           <span className="stat">
75 |             AES-256 encrypted
76 |           </span>
77 |         )}
78 |       </div>
79 |     </div>
80 |   );
81 | };
82 | 
83 | export default ResultDisplay; 


--------------------------------------------------------------------------------
/Frontend/src/components/DecryptForm.jsx:
--------------------------------------------------------------------------------
  1 | import React, { useState } from 'react';
  2 | import { Eye, EyeOff, Unlock, AlertCircle } from 'lucide-react';
  3 | import { pycryptAPI } from '../services/api';
  4 | 
  5 | const DecryptForm = ({ onResult, onLoading, onError }) => {
  6 |   const [encryptedContent, setEncryptedContent] = useState('');
  7 |   const [password, setPassword] = useState('');
  8 |   const [showPassword, setShowPassword] = useState(false);
  9 |   const [isLoading, setIsLoading] = useState(false);
 10 | 
 11 |   const handleSubmit = async (e) => {
 12 |     e.preventDefault();
 13 |     
 14 |     if (!encryptedContent.trim()) {
 15 |       onError('Please enter encrypted content to decrypt');
 16 |       return;
 17 |     }
 18 |     
 19 |     if (!password.trim()) {
 20 |       onError('Please enter the password');
 21 |       return;
 22 |     }
 23 | 
 24 |     setIsLoading(true);
 25 |     onLoading(true);
 26 |     onError('');
 27 | 
 28 |     try {
 29 |       const result = await pycryptAPI.decryptText(encryptedContent, password);
 30 |       
 31 |       if (result.success) {
 32 |         onResult({
 33 |           type: 'decrypted',
 34 |           content: result.data.decrypted_text,
 35 |           originalEncrypted: encryptedContent
 36 |         });
 37 |       } else {
 38 |         onError(result.error);
 39 |       }
 40 |     } catch (error) {
 41 |       onError('Failed to decrypt text. Please check your password and try again.');
 42 |     } finally {
 43 |       setIsLoading(false);
 44 |       onLoading(false);
 45 |     }
 46 |   };
 47 | 
 48 |   const handleClear = () => {
 49 |     setEncryptedContent('');
 50 |     setPassword('');
 51 |     onResult(null);
 52 |     onError('');
 53 |   };
 54 | 
 55 |   return (
 56 |     <form onSubmit={handleSubmit} className="decrypt-form">
 57 |       <div className="form-group">
 58 |         <label htmlFor="decrypt-content">Encrypted Content</label>
 59 |         <textarea
 60 |           id="decrypt-content"
 61 |           value={encryptedContent}
 62 |           onChange={(e) => setEncryptedContent(e.target.value)}
 63 |           placeholder="Paste your encrypted content here..."
 64 |           rows={6}
 65 |           className="form-textarea encrypted-content"
 66 |           disabled={isLoading}
 67 |         />
 68 |       </div>
 69 | 
 70 |       <div className="form-group">
 71 |         <label htmlFor="decrypt-password">Password</label>
 72 |         <div className="password-input-wrapper">
 73 |           <input
 74 |             id="decrypt-password"
 75 |             type={showPassword ? 'text' : 'password'}
 76 |             value={password}
 77 |             onChange={(e) => setPassword(e.target.value)}
 78 |             placeholder="Enter your password"
 79 |             className="form-input"
 80 |             disabled={isLoading}
 81 |           />
 82 |           <button
 83 |             type="button"
 84 |             onClick={() => setShowPassword(!showPassword)}
 85 |             className="password-toggle"
 86 |             disabled={isLoading}
 87 |           >
 88 |             {showPassword ? <EyeOff size={20} /> : <Eye size={20} />}
 89 |           </button>
 90 |         </div>
 91 |       </div>
 92 | 
 93 |       <div className="form-actions">
 94 |         <button
 95 |           type="submit"
 96 |           className="btn btn-primary"
 97 |           disabled={isLoading || !encryptedContent.trim() || !password.trim()}
 98 |         >
 99 |           <Unlock size={20} />
100 |           {isLoading ? 'Decrypting...' : 'Decrypt Text'}
101 |         </button>
102 |         <button
103 |           type="button"
104 |           onClick={handleClear}
105 |           className="btn btn-secondary"
106 |           disabled={isLoading}
107 |         >
108 |           Clear
109 |         </button>
110 |       </div>
111 |     </form>
112 |   );
113 | };
114 | 
115 | export default DecryptForm; 


--------------------------------------------------------------------------------
/Frontend/src/assets/react.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>


--------------------------------------------------------------------------------
/Frontend/src/components/EncryptForm.jsx:
--------------------------------------------------------------------------------
  1 | import React, { useState } from 'react';
  2 | import { Eye, EyeOff, Lock, AlertCircle } from 'lucide-react';
  3 | import { pycryptAPI } from '../services/api';
  4 | 
  5 | const EncryptForm = ({ onResult, onLoading, onError }) => {
  6 |   const [text, setText] = useState('');
  7 |   const [password, setPassword] = useState('');
  8 |   const [hint, setHint] = useState('');
  9 |   const [showPassword, setShowPassword] = useState(false);
 10 |   const [isLoading, setIsLoading] = useState(false);
 11 | 
 12 |   const handleSubmit = async (e) => {
 13 |     e.preventDefault();
 14 |     
 15 |     if (!text.trim()) {
 16 |       onError('Please enter text to encrypt');
 17 |       return;
 18 |     }
 19 |     
 20 |     if (!password.trim()) {
 21 |       onError('Please enter a password');
 22 |       return;
 23 |     }
 24 | 
 25 |     setIsLoading(true);
 26 |     onLoading(true);
 27 |     onError('');
 28 | 
 29 |     try {
 30 |       const result = await pycryptAPI.encryptText(text, password, hint);
 31 |       
 32 |       if (result.success) {
 33 |         onResult({
 34 |           type: 'encrypted',
 35 |           content: result.data.encrypted_content,
 36 |           hint: result.data.hint,
 37 |           originalText: text
 38 |         });
 39 |       } else {
 40 |         onError(result.error);
 41 |       }
 42 |     } catch (error) {
 43 |       onError('Failed to encrypt text. Please try again.');
 44 |     } finally {
 45 |       setIsLoading(false);
 46 |       onLoading(false);
 47 |     }
 48 |   };
 49 | 
 50 |   const handleClear = () => {
 51 |     setText('');
 52 |     setPassword('');
 53 |     setHint('');
 54 |     onResult(null);
 55 |     onError('');
 56 |   };
 57 | 
 58 |   return (
 59 |     <form onSubmit={handleSubmit} className="encrypt-form">
 60 |       <div className="form-group">
 61 |         <label htmlFor="encrypt-text">Text to Encrypt</label>
 62 |         <textarea
 63 |           id="encrypt-text"
 64 |           value={text}
 65 |           onChange={(e) => setText(e.target.value)}
 66 |           placeholder="Enter your secret message here..."
 67 |           rows={6}
 68 |           className="form-textarea"
 69 |           disabled={isLoading}
 70 |         />
 71 |       </div>
 72 | 
 73 |       <div className="form-group">
 74 |         <label htmlFor="encrypt-password">Password</label>
 75 |         <div className="password-input-wrapper">
 76 |           <input
 77 |             id="encrypt-password"
 78 |             type={showPassword ? 'text' : 'password'}
 79 |             value={password}
 80 |             onChange={(e) => setPassword(e.target.value)}
 81 |             placeholder="Enter a strong password"
 82 |             className="form-input"
 83 |             disabled={isLoading}
 84 |           />
 85 |           <button
 86 |             type="button"
 87 |             onClick={() => setShowPassword(!showPassword)}
 88 |             className="password-toggle"
 89 |             disabled={isLoading}
 90 |           >
 91 |             {showPassword ? <EyeOff size={20} /> : <Eye size={20} />}
 92 |           </button>
 93 |         </div>
 94 |       </div>
 95 | 
 96 |       <div className="form-group">
 97 |         <label htmlFor="encrypt-hint">Password Hint (Optional)</label>
 98 |         <input
 99 |           id="encrypt-hint"
100 |           type="text"
101 |           value={hint}
102 |           onChange={(e) => setHint(e.target.value)}
103 |           placeholder="Optional hint to remember your password"
104 |           className="form-input"
105 |           disabled={isLoading}
106 |         />
107 |       </div>
108 | 
109 |       <div className="form-actions">
110 |         <button
111 |           type="submit"
112 |           className="btn btn-primary"
113 |           disabled={isLoading || !text.trim() || !password.trim()}
114 |         >
115 |           <Lock size={20} />
116 |           {isLoading ? 'Encrypting...' : 'Encrypt Text'}
117 |         </button>
118 |         <button
119 |           type="button"
120 |           onClick={handleClear}
121 |           className="btn btn-secondary"
122 |           disabled={isLoading}
123 |         >
124 |           Clear
125 |         </button>
126 |       </div>
127 |     </form>
128 |   );
129 | };
130 | 
131 | export default EncryptForm; 


--------------------------------------------------------------------------------
/Code of Conduct.md:
--------------------------------------------------------------------------------
 1 | Contributor Covenant Code of Conduct
 2 | ## Our Pledge
 3 | We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
 4 | 
 5 | We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
 6 | 
 7 | ## Our Standards
 8 | Examples of behavior that contributes to a positive environment for our community include:
 9 | 
10 | Demonstrating empathy and kindness toward other people
11 | Being respectful of differing opinions, viewpoints, and experiences
12 | Giving and gracefully accepting constructive feedback
13 | Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
14 | Focusing on what is best not just for us as individuals, but for the overall community
15 | Examples of unacceptable behavior include:
16 | 
17 | The use of sexualized language or imagery, and sexual attention or advances of any kind
18 | Trolling, insulting or derogatory comments, and personal or political attacks
19 | Public or private harassment
20 | Publishing others' private information, such as a physical or email address, without their explicit permission
21 | Other conduct which could reasonably be considered inappropriate in a professional setting
22 | 
23 | ## Enforcement Responsibilities
24 | Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
25 | 
26 | Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
27 | 
28 | ## Scope
29 | This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
30 | 
31 | Enforcement
32 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at . All complaints will be reviewed and investigated promptly and fairly.
33 | 
34 | All community leaders are obligated to respect the privacy and security of the reporter of any incident.
35 | 
36 | Enforcement Guidelines
37 | Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
38 | 
39 | 1. Correction
40 | Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
41 | 
42 | Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
43 | 
44 | 2. Warning
45 | Community Impact: A violation through a single incident or series of actions.
46 | 
47 | Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
48 | 
49 | 3. Temporary Ban
50 | Community Impact: A serious violation of community standards, including sustained inappropriate behavior.
51 | 
52 | Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
53 | 
54 | 4. Permanent Ban
55 | Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
56 | 
57 | Consequence: A permanent ban from any sort of public interaction within the community.
58 | 
59 | 


--------------------------------------------------------------------------------
/Frontend/src/App.jsx:
--------------------------------------------------------------------------------
  1 | import React, { useState, useEffect } from 'react';
  2 | import { Shield, Wifi, WifiOff, AlertCircle } from 'lucide-react';
  3 | import EncryptForm from './components/EncryptForm';
  4 | import DecryptForm from './components/DecryptForm';
  5 | import ResultDisplay from './components/ResultDisplay';
  6 | import { pycryptAPI } from './services/api';
  7 | import './App.css';
  8 | 
  9 | function App() {
 10 |   const [activeTab, setActiveTab] = useState('encrypt');
 11 |   const [result, setResult] = useState(null);
 12 |   const [error, setError] = useState('');
 13 |   const [isLoading, setIsLoading] = useState(false);
 14 |   const [apiStatus, setApiStatus] = useState('checking');
 15 | 
 16 |   // Check API health on component mount
 17 |   useEffect(() => {
 18 |     checkApiHealth();
 19 |   }, []);
 20 | 
 21 |   const checkApiHealth = async () => {
 22 |     try {
 23 |       const healthResult = await pycryptAPI.healthCheck();
 24 |       setApiStatus(healthResult.success ? 'connected' : 'disconnected');
 25 |     } catch (error) {
 26 |       setApiStatus('disconnected');
 27 |     }
 28 |   };
 29 | 
 30 |   const handleTabChange = (tab) => {
 31 |     setActiveTab(tab);
 32 |     setResult(null);
 33 |     setError('');
 34 |   };
 35 | 
 36 |   const handleResult = (newResult) => {
 37 |     setResult(newResult);
 38 |     setError('');
 39 |   };
 40 | 
 41 |   const handleError = (errorMessage) => {
 42 |     setError(errorMessage);
 43 |     setResult(null);
 44 |   };
 45 | 
 46 |   const handleLoading = (loading) => {
 47 |     setIsLoading(loading);
 48 |   };
 49 | 
 50 |   return (
 51 |     <div className="app">
 52 |       <header className="app-header">
 53 |         <div className="header-content">
 54 |           <div className="logo">
 55 |             <Shield size={32} />
 56 |             <h1>PyCrypt</h1>
 57 |           </div>
 58 |           <div className="subtitle">
 59 |             Secure Text Encryption & Decryption
 60 |           </div>
 61 |           <div className={`api-status ${apiStatus}`}>
 62 |             {apiStatus === 'connected' ? <Wifi size={16} /> : <WifiOff size={16} />}
 63 |             <span>
 64 |               {apiStatus === 'checking' ? 'Checking...' : 
 65 |                apiStatus === 'connected' ? 'API Connected' : 'API Disconnected'}
 66 |             </span>
 67 |           </div>
 68 |         </div>
 69 |       </header>
 70 | 
 71 |       <main className="app-main">
 72 |         <div className="container">
 73 |           <div className="tabs">
 74 |             <button
 75 |               className={`tab ${activeTab === 'encrypt' ? 'active' : ''}`}
 76 |               onClick={() => handleTabChange('encrypt')}
 77 |               disabled={isLoading}
 78 |             >
 79 |               🔒 Encrypt
 80 |             </button>
 81 |             <button
 82 |               className={`tab ${activeTab === 'decrypt' ? 'active' : ''}`}
 83 |               onClick={() => handleTabChange('decrypt')}
 84 |               disabled={isLoading}
 85 |             >
 86 |               🔓 Decrypt
 87 |             </button>
 88 |           </div>
 89 | 
 90 |           <div className="content">
 91 |             <div className="form-section">
 92 |               {activeTab === 'encrypt' ? (
 93 |                 <EncryptForm
 94 |                   onResult={handleResult}
 95 |                   onLoading={handleLoading}
 96 |                   onError={handleError}
 97 |                 />
 98 |               ) : (
 99 |                 <DecryptForm
100 |                   onResult={handleResult}
101 |                   onLoading={handleLoading}
102 |                   onError={handleError}
103 |                 />
104 |               )}
105 |             </div>
106 | 
107 |             <div className="result-section">
108 |               <ResultDisplay result={result} error={error} />
109 |             </div>
110 |           </div>
111 | 
112 |           {apiStatus === 'disconnected' && (
113 |             <div className="api-warning">
114 |               <AlertCircle size={20} />
115 |               <span>
116 |                 Cannot connect to PyCrypt API. Make sure the Flask server is running on 
117 |                 <code>http://localhost:5000</code>
118 |               </span>
119 |               <button onClick={checkApiHealth} className="retry-btn">
120 |                 Retry
121 |               </button>
122 |             </div>
123 |           )}
124 |         </div>
125 |       </main>
126 | 
127 |       <footer className="app-footer">
128 |         <p>
129 |           Powered by AES-256 encryption with PBKDF2 key derivation and HMAC verification
130 |         </p>
131 |       </footer>
132 |     </div>
133 |   );
134 | }
135 | 
136 | export default App;
137 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 🔐 Text Encryption & Decryption Web App
  2 | 
  3 | A Flask-based web application that allows users to **encrypt and decrypt text** using two well-known cryptographic techniques: **RSA Algorithm** and **Caesar Cipher**. This app is designed for educational purposes to demonstrate both symmetric and asymmetric encryption in a beginner-friendly interface.
  4 | 
  5 | ---
  6 | 
  7 | <table align="center">
  8 |     <thead align="center">
  9 |         <tr border: 2px;>
 10 |             <td><b>🌟 Stars</b></td>
 11 |             <td><b>🍴 Forks</b></td>
 12 |             <td><b>🐛 Issues</b></td>
 13 |             <td><b>🔔 Open PRs</b></td>
 14 |             <td><b>🔕 Close PRs</b></td>
 15 |         </tr>
 16 |      </thead>
 17 |     <tbody>
 18 |          <tr>
 19 |             <td><img alt="Stars" src="https://img.shields.io/github/stars/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool?style=flat&logo=github"/></td>
 20 |              <td><img alt="Forks" src="https://img.shields.io/github/forks/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool?style=flat&logo=github"/></td>
 21 |             <td><img alt="Issues" src="https://img.shields.io/github/issues/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool?style=flat&logo=github"/></td>
 22 |             <td><img alt="Open Pull Requests" src="https://img.shields.io/github/issues-pr/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool?style=flat&logo=github"/></td>
 23 |            <td><img alt="Close Pull Requests" src="https://img.shields.io/github/issues-pr-closed/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool?style=flat&color=green&logo=github"/></td>
 24 |         </tr>
 25 |     </tbody>
 26 | </table>
 27 | 
 28 | ---
 29 | 
 30 | ## 🌟 Features
 31 | 
 32 | - 🧠 Implements **RSA (Asymmetric Encryption)**
 33 | - 🔁 Supports **Caesar Cipher (Symmetric Encryption)**
 34 | - 🌐 Clean **web interface** using Flask & HTML templates
 35 | - 🧪 Encrypt and decrypt both messages and characters
 36 | - 📦 Easy to run locally (no database required)
 37 | 
 38 | ---
 39 | 
 40 | ## 🔐 Algorithms Overview
 41 | 
 42 | ### ✅ RSA Algorithm
 43 | 
 44 | RSA is an **asymmetric cryptographic algorithm**, meaning it uses a **public key** for encryption and a **private key** for decryption.
 45 | 
 46 | #### How it works:
 47 | 
 48 | 1. Select two prime numbers `P = 53` and `Q = 59`
 49 | 2. Compute `n = P * Q = 3127`
 50 | 3. Compute φ(n) = (P - 1)(Q - 1) = 3016
 51 | 4. Choose a public exponent `e = 3` such that `1 < e < φ(n)` and `e` is coprime to φ(n)
 52 | 5. Compute private key `d` such that `d = (k * φ(n) + 1) / e`, for some integer `k`
 53 | 
 54 | **Example:**
 55 | - Plaintext: "HI" → 8 9
 56 | - Encrypted: `c = (89^3) % 3127 = 1394`
 57 | - Decrypted: `p = (1394^2011) % 3127 = 89` → "HI"
 58 | 
 59 | ---
 60 | 
 61 | ### ✅ Caesar Cipher
 62 | 
 63 | A **substitution cipher** that shifts each letter by a fixed number (`shift`) in the alphabet.
 64 | 
 65 | #### Example:
 66 | - Plaintext: `HELLO`
 67 | - Shift: `3`
 68 | - Encrypted: `KHOOR`
 69 | - Decrypted: `HELLO` (by shifting back)
 70 | 
 71 | ---
 72 | 
 73 | 
 74 | ## 🚀 Getting Started
 75 | 
 76 | ### ✅ Prerequisites
 77 | 
 78 | - Python 3.x
 79 | - Flask
 80 | 
 81 | ### 📦 Installation
 82 | 
 83 | ```bash
 84 | git clone https://github.com/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool.git
 85 | cd Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool
 86 | pip install flask
 87 | ```
 88 | 
 89 | Run the app:
 90 | ```bash
 91 | python app.py
 92 | ```
 93 | 
 94 | Then visit [http://localhost:5000](http://localhost:5000) in your browser.
 95 | 
 96 | ---
 97 | 
 98 | ## 📸 Screenshots
 99 | 
100 | > ![image](https://github.com/user-attachments/assets/098f6c3c-e280-4dab-afae-d0e4d7e37385)
101 | 
102 | 
103 | ---
104 | 
105 | ## 💡 Use Cases
106 | 
107 | - Learn and visualize basic cryptographic methods  
108 | - Understand the difference between symmetric & asymmetric encryption  
109 | - Educational tool for Python + Flask + Cryptography
110 | 
111 | ---
112 | 
113 | ## 🤝 Contributing
114 | 
115 | Contributions are welcome! To contribute:
116 | 
117 | 1. **Fork** the repository  
118 | 2. **Create a new branch**  
119 | 3. **Make your changes**  
120 | 4. **Submit a pull request**
121 | 
122 | ---
123 | 
124 | ## 👥 Contributors
125 | 
126 | Thanks to these amazing people for their contributions:
127 | 
128 | [![GitHub Contributors](https://contrib.rocks/image?repo=surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool)](https://github.com/surjeetsinhthakur123/Text-Encryption-And-Decryption-Using-Rsa-Algorithm-and-Caesar-Ciphar-Tool/graphs/contributors)
129 | 
130 | > *Feel free to add your name here via a pull request if you contribute!*
131 | 
132 | ---
133 | 
134 | ## 📄 License
135 | 
136 | This project is licensed under the **MIT License**.
137 | 
138 | ---
139 | 
140 | ## 🙋 Author
141 | 
142 | **Surjeet Sinh Thakur**  
143 | 🔗 [GitHub Profile](https://github.com/surjeetsinhthakur123)
144 | 
145 | 


--------------------------------------------------------------------------------
/Backend/README.md:
--------------------------------------------------------------------------------
  1 | # PyCrypt - Secure Encryption API
  2 | 
  3 | A secure, password-based file and text encryption/decryption REST API using AES-256, PBKDF2, and HMAC integrity verification. Perfect for integration with React applications and other web frontends.
  4 | 
  5 | ## 🚀 Quick Start
  6 | 
  7 | ### Installation
  8 | ```bash
  9 | cd PyCrypt
 10 | pip install -r requirements.txt
 11 | ```
 12 | 
 13 | ### Start the API Server
 14 | ```bash
 15 | python start_api.py
 16 | ```
 17 | 
 18 | The API will be available at `http://localhost:5000`
 19 | 
 20 | ### Test the API
 21 | ```bash
 22 | python test_api.py
 23 | ```
 24 | 
 25 | ## 🔥 Features
 26 | 
 27 | ### Security
 28 | - **AES-256-CBC encryption** with secure random IV
 29 | - **PBKDF2 key derivation** (200,000 iterations) 
 30 | - **HMAC-SHA256 verification** for integrity
 31 | - **Secure random salt generation**
 32 | - **Automatic cleanup** of temporary files
 33 | - **Password hints** support
 34 | 
 35 | ### API Capabilities
 36 | - **Text encryption/decryption** via JSON
 37 | - **File upload encryption/decryption**
 38 | - **File download** (encrypted/decrypted)
 39 | - **CORS enabled** for web app integration
 40 | - **RESTful endpoints** with proper error handling
 41 | - **Base64 encoding** for binary-safe transfers
 42 | 
 43 | ## 🌐 API Endpoints
 44 | 
 45 | | Method | Endpoint | Description |
 46 | |--------|----------|-------------|
 47 | | GET | `/api/health` | Health check |
 48 | | POST | `/api/encrypt/text` | Encrypt text content |
 49 | | POST | `/api/decrypt/text` | Decrypt text content |
 50 | | POST | `/api/encrypt/file` | Encrypt uploaded file |
 51 | | POST | `/api/decrypt/file` | Decrypt file content |
 52 | | POST | `/api/download/encrypted` | Download encrypted file |
 53 | | POST | `/api/download/decrypted` | Download decrypted file |
 54 | 
 55 | ## 📖 Usage Examples
 56 | 
 57 | ### React/JavaScript Integration
 58 | ```javascript
 59 | // Encrypt text
 60 | const encryptText = async (text, password) => {
 61 |   const response = await fetch('http://localhost:5000/api/encrypt/text', {
 62 |     method: 'POST',
 63 |     headers: { 'Content-Type': 'application/json' },
 64 |     body: JSON.stringify({
 65 |       text: text,
 66 |       password: password,
 67 |       hint: 'Optional hint'
 68 |     })
 69 |   });
 70 |   return await response.json();
 71 | };
 72 | 
 73 | // Decrypt text
 74 | const decryptText = async (encryptedContent, password) => {
 75 |   const response = await fetch('http://localhost:5000/api/decrypt/text', {
 76 |     method: 'POST',
 77 |     headers: { 'Content-Type': 'application/json' },
 78 |     body: JSON.stringify({
 79 |       encrypted_content: encryptedContent,
 80 |       password: password
 81 |     })
 82 |   });
 83 |   return await response.json();
 84 | };
 85 | 
 86 | // File encryption
 87 | const encryptFile = async (file, password) => {
 88 |   const formData = new FormData();
 89 |   formData.append('file', file);
 90 |   formData.append('password', password);
 91 |   formData.append('hint', 'File hint');
 92 |   
 93 |   const response = await fetch('http://localhost:5000/api/encrypt/file', {
 94 |     method: 'POST',
 95 |     body: formData
 96 |   });
 97 |   return await response.json();
 98 | };
 99 | ```
100 | 
101 | ### Python Client Example
102 | ```python
103 | import requests
104 | 
105 | # Encrypt text
106 | response = requests.post('http://localhost:5000/api/encrypt/text', json={
107 |     'text': 'Secret message',
108 |     'password': 'my_password',
109 |     'hint': 'Remember this!'
110 | })
111 | result = response.json()
112 | 
113 | # Decrypt text
114 | response = requests.post('http://localhost:5000/api/decrypt/text', json={
115 |     'encrypted_content': result['encrypted_content'],
116 |     'password': 'my_password'
117 | })
118 | decrypted = response.json()
119 | print(decrypted['decrypted_text'])
120 | ```
121 | 
122 | ## 🏗️ Project Structure
123 | ```
124 | PyCrypt/
125 | ├── api.py              # Main Flask API server
126 | ├── start_api.py        # API startup script
127 | ├── test_api.py         # API test suite
128 | ├── crypto/
129 | │   ├── encryptor.py    # AES encryption logic
130 | │   ├── decryptor.py    # AES decryption logic
131 | │   └── utils.py        # Crypto utilities (salt, IV, HMAC)
132 | ├── API_DOCS.md         # Detailed API documentation
133 | ├── requirements.txt    # Python dependencies
134 | └── README.md          # This file
135 | ```
136 | 
137 | ## 🔒 Security Details
138 | 
139 | ### Encryption Process
140 | 1. **Random salt generation** (16 bytes)
141 | 2. **PBKDF2 key derivation** from password + salt
142 | 3. **Random IV generation** (16 bytes) 
143 | 4. **AES-256-CBC encryption** of content
144 | 5. **HMAC-SHA256 calculation** for integrity
145 | 6. **Secure file header** with magic bytes + version
146 | 
147 | ### File Format
148 | ```
149 | [MAGIC][VERSION][SALT][IV][HMAC][HINT][ENCRYPTED_DATA]
150 | ```
151 | 
152 | ### Why This is Secure
153 | - **No password storage** - passwords are only used for key derivation
154 | - **Salt prevents rainbow tables** - unique salt per encryption
155 | - **IV prevents pattern analysis** - unique IV per encryption  
156 | - **HMAC prevents tampering** - any modification is detected
157 | - **Strong key derivation** - 200k iterations makes brute force costly
158 | - **Memory cleanup** - temporary files are securely wiped
159 | 
160 | ## 🚀 Integration with React
161 | 
162 | This API is designed to work seamlessly with React applications:
163 | 
164 | 1. **CORS enabled** - no cross-origin issues
165 | 2. **JSON responses** - easy to parse in JavaScript
166 | 3. **File upload support** - works with HTML file inputs
167 | 4. **Base64 encoding** - handles binary data safely
168 | 5. **Error handling** - consistent error response format
169 | 
170 | ## 📚 Documentation
171 | 
172 | - **API_DOCS.md** - Complete endpoint documentation with examples
173 | - **Built-in health check** - `/api/health` for monitoring
174 | - **Comprehensive tests** - Run `python test_api.py` to verify functionality
175 | 
176 | ## 🛠️ Development
177 | 
178 | ### Running Tests
179 | ```bash
180 | python test_api.py
181 | ```
182 | 
183 | ### Environment
184 | - **Python 3.9+** required
185 | - **16MB max file size** (configurable)
186 | - **Temporary file cleanup** automatic
187 | - **Development mode** with debug logging
188 | 
189 | ## 🎯 Use Cases
190 | 
191 | - **React web applications** needing client-side encryption
192 | - **Secure file storage** with password protection  
193 | - **API-based encryption services** for multiple frontends
194 | - **Secure data transfer** between applications
195 | - **Privacy-focused applications** requiring strong crypto
196 | 
197 | Built with security, simplicity, and React integration in mind! 🔐 


--------------------------------------------------------------------------------
/Backend/API_DOCS.md:
--------------------------------------------------------------------------------
  1 | # PyCrypt Flask API Documentation
  2 | 
  3 | A REST API for secure file and text encryption/decryption using AES encryption with PBKDF2 key derivation and HMAC verification.
  4 | 
  5 | ## Getting Started
  6 | 
  7 | ### Installation
  8 | ```bash
  9 | cd PyCrypt
 10 | pip install -r requirements.txt
 11 | ```
 12 | 
 13 | ### Running the Server
 14 | ```bash
 15 | python api.py
 16 | ```
 17 | 
 18 | The API will be available at `http://localhost:5000`
 19 | 
 20 | ## API Endpoints
 21 | 
 22 | ### Health Check
 23 | **GET** `/api/health`
 24 | 
 25 | Returns the health status of the API.
 26 | 
 27 | **Response:**
 28 | ```json
 29 | {
 30 |   "status": "healthy",
 31 |   "service": "PyCrypt API",
 32 |   "version": "1.0.0"
 33 | }
 34 | ```
 35 | 
 36 | ### Text Encryption
 37 | **POST** `/api/encrypt/text`
 38 | 
 39 | Encrypt text content with a password.
 40 | 
 41 | **Request Body (JSON):**
 42 | ```json
 43 | {
 44 |   "text": "Your secret message here",
 45 |   "password": "your_strong_password",
 46 |   "hint": "Optional password hint"
 47 | }
 48 | ```
 49 | 
 50 | **Response:**
 51 | ```json
 52 | {
 53 |   "success": true,
 54 |   "encrypted_content": "base64_encoded_encrypted_data",
 55 |   "hint": "Optional password hint"
 56 | }
 57 | ```
 58 | 
 59 | ### Text Decryption
 60 | **POST** `/api/decrypt/text`
 61 | 
 62 | Decrypt text content with a password.
 63 | 
 64 | **Request Body (JSON):**
 65 | ```json
 66 | {
 67 |   "encrypted_content": "base64_encoded_encrypted_data",
 68 |   "password": "your_strong_password"
 69 | }
 70 | ```
 71 | 
 72 | **Response:**
 73 | ```json
 74 | {
 75 |   "success": true,
 76 |   "decrypted_text": "Your secret message here"
 77 | }
 78 | ```
 79 | 
 80 | ### File Encryption
 81 | **POST** `/api/encrypt/file`
 82 | 
 83 | Encrypt an uploaded file with a password.
 84 | 
 85 | **Request (multipart/form-data):**
 86 | - `file`: The file to encrypt
 87 | - `password`: Encryption password
 88 | - `hint`: Optional password hint
 89 | 
 90 | **Response:**
 91 | ```json
 92 | {
 93 |   "success": true,
 94 |   "filename": "original_filename.txt",
 95 |   "encrypted_content": "base64_encoded_encrypted_data",
 96 |   "hint": "Optional password hint"
 97 | }
 98 | ```
 99 | 
100 | ### File Decryption
101 | **POST** `/api/decrypt/file`
102 | 
103 | Decrypt file content with a password.
104 | 
105 | **Request Body (JSON):**
106 | ```json
107 | {
108 |   "encrypted_content": "base64_encoded_encrypted_data",
109 |   "password": "your_strong_password",
110 |   "filename": "original_filename.txt"
111 | }
112 | ```
113 | 
114 | **Response:**
115 | ```json
116 | {
117 |   "success": true,
118 |   "filename": "original_filename.txt",
119 |   "decrypted_content": "base64_encoded_decrypted_data"
120 | }
121 | ```
122 | 
123 | ### Download Encrypted File
124 | **POST** `/api/download/encrypted`
125 | 
126 | Download encrypted content as a file.
127 | 
128 | **Request Body (JSON):**
129 | ```json
130 | {
131 |   "encrypted_content": "base64_encoded_encrypted_data",
132 |   "filename": "encrypted_file.enc"
133 | }
134 | ```
135 | 
136 | **Response:** File download
137 | 
138 | ### Download Decrypted File
139 | **POST** `/api/download/decrypted`
140 | 
141 | Download decrypted content as a file.
142 | 
143 | **Request Body (JSON):**
144 | ```json
145 | {
146 |   "decrypted_content": "base64_encoded_decrypted_data",
147 |   "filename": "decrypted_file.txt"
148 | }
149 | ```
150 | 
151 | **Response:** File download
152 | 
153 | ## Usage Examples
154 | 
155 | ### React/JavaScript Example
156 | 
157 | ```javascript
158 | // Encrypt text
159 | const encryptText = async (text, password) => {
160 |   const response = await fetch('http://localhost:5000/api/encrypt/text', {
161 |     method: 'POST',
162 |     headers: {
163 |       'Content-Type': 'application/json',
164 |     },
165 |     body: JSON.stringify({
166 |       text: text,
167 |       password: password,
168 |       hint: 'My secret hint'
169 |     })
170 |   });
171 |   
172 |   const result = await response.json();
173 |   return result;
174 | };
175 | 
176 | // Decrypt text
177 | const decryptText = async (encryptedContent, password) => {
178 |   const response = await fetch('http://localhost:5000/api/decrypt/text', {
179 |     method: 'POST',
180 |     headers: {
181 |       'Content-Type': 'application/json',
182 |     },
183 |     body: JSON.stringify({
184 |       encrypted_content: encryptedContent,
185 |       password: password
186 |     })
187 |   });
188 |   
189 |   const result = await response.json();
190 |   return result;
191 | };
192 | 
193 | // Encrypt file
194 | const encryptFile = async (file, password) => {
195 |   const formData = new FormData();
196 |   formData.append('file', file);
197 |   formData.append('password', password);
198 |   formData.append('hint', 'File encryption hint');
199 |   
200 |   const response = await fetch('http://localhost:5000/api/encrypt/file', {
201 |     method: 'POST',
202 |     body: formData
203 |   });
204 |   
205 |   const result = await response.json();
206 |   return result;
207 | };
208 | ```
209 | 
210 | ### Python Example
211 | 
212 | ```python
213 | import requests
214 | import base64
215 | 
216 | # Encrypt text
217 | def encrypt_text(text, password):
218 |     response = requests.post('http://localhost:5000/api/encrypt/text', json={
219 |         'text': text,
220 |         'password': password,
221 |         'hint': 'My secret hint'
222 |     })
223 |     return response.json()
224 | 
225 | # Decrypt text
226 | def decrypt_text(encrypted_content, password):
227 |     response = requests.post('http://localhost:5000/api/decrypt/text', json={
228 |         'encrypted_content': encrypted_content,
229 |         'password': password
230 |     })
231 |     return response.json()
232 | 
233 | # Example usage
234 | result = encrypt_text("Hello, World!", "my_password")
235 | print(f"Encrypted: {result['encrypted_content']}")
236 | 
237 | decrypted = decrypt_text(result['encrypted_content'], "my_password")
238 | print(f"Decrypted: {decrypted['decrypted_text']}")
239 | ```
240 | 
241 | ## Security Features
242 | 
243 | - **AES-256 encryption** in CBC mode
244 | - **PBKDF2** key derivation with 200,000 iterations
245 | - **HMAC-SHA256** for integrity verification
246 | - **Secure random salt and IV** generation
247 | - **Automatic cleanup** of temporary files
248 | - **Password-based encryption** with optional hints
249 | 
250 | ## Error Handling
251 | 
252 | All endpoints return JSON responses with error information when something goes wrong:
253 | 
254 | ```json
255 | {
256 |   "error": "Error message describing what went wrong"
257 | }
258 | ```
259 | 
260 | Common HTTP status codes:
261 | - `200`: Success
262 | - `400`: Bad Request (missing required fields)
263 | - `500`: Internal Server Error
264 | 
265 | ## CORS Support
266 | 
267 | The API includes CORS support for cross-origin requests, making it easy to integrate with React applications running on different ports. 


--------------------------------------------------------------------------------
/static/styles.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     margin: 0;
  3 |     padding: 40px 20px;
  4 |     min-height: 100vh;
  5 |     background-color: #a2ccf2;
  6 |     display: flex;
  7 |     justify-content: center;
  8 |     box-sizing: border-box;
  9 |     overflow-x: hidden;
 10 | }
 11 | 
 12 | .container {
 13 |     max-width: 1000px;
 14 |     width: 100%;
 15 |     background: rgba(255, 255, 255, 0.15); /* semi-transparent */
 16 |     backdrop-filter: blur(10px);           /* frosted glass effect */
 17 |     -webkit-backdrop-filter: blur(10px);   /* Safari support */
 18 |     padding: 20px;
 19 |     border-radius: 20px;
 20 |     box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
 21 |     border: 1px solid rgba(255, 255, 255, 0.3);
 22 |     transition: all 0.3s ease;
 23 | }
 24 | 
 25 | .container:hover {
 26 |     box-shadow: 0 10px 40px rgba(0, 0, 0, 0.25);
 27 | }
 28 | 
 29 | h1 {
 30 |     text-align: center;
 31 |     color: #192a5e;
 32 |     margin-top: 0%;
 33 | }
 34 | 
 35 | .section {
 36 |     padding: 20px;
 37 |     border: 2px solid #192a5e;
 38 |     border-radius: 5px;
 39 |     background-color: #f9f9f9;
 40 |     border-color: #333;
 41 | }
 42 | 
 43 | .section h2 {
 44 |     margin-top: 0;
 45 |     color: #192a5e;
 46 |     border-bottom: 1px solid #ddd;
 47 |     padding-bottom: 10px;
 48 | }
 49 | 
 50 | .form-group {
 51 |     margin-bottom: 15px;
 52 | }
 53 | 
 54 | label {
 55 |     display: block;
 56 |     margin-bottom: 5px;
 57 |     font-weight: bold;
 58 |     color: #2b2b2b;
 59 | }
 60 | 
 61 | input[type="number"], input[type="text"], textarea {
 62 |     width: 100%;
 63 |     padding: 8px;
 64 |     border: 1px solid #ddd;
 65 |     border-radius: 4px;
 66 |     box-sizing: border-box;
 67 | }
 68 | 
 69 | textarea {
 70 |     min-height: 10px;
 71 |     resize: vertical;
 72 | }
 73 | 
 74 | button {
 75 |     background: linear-gradient(135deg, #4facfe, #00f2fe);
 76 |     color: rgb(0, 0, 0);
 77 |     border: none;
 78 |     padding: 12px 20px;
 79 |     border-radius: 8px;
 80 |     cursor: pointer;
 81 |     font-size: 16px;
 82 |     font-weight: 500;
 83 |     transition: all 0.3s ease;
 84 |     box-shadow: 0 4px 12px rgba(79, 172, 254, 0.3);
 85 | }
 86 | 
 87 | button:hover {
 88 |     background: linear-gradient(135deg, #00f2fe, #4facfe);
 89 |     transform: translateY(-2px);
 90 |     box-shadow: 0 6px 16px rgba(79, 172, 254, 0.4);
 91 | }
 92 | 
 93 | .result {
 94 |     margin-top: 20px;
 95 |     padding: 15px 20px;
 96 |     border: 2px solid #cce5ff;
 97 |     border-radius: 8px;
 98 |     background-color: #f0faff;
 99 |     color: #003366;
100 |     font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
101 |     font-size: 15px;
102 |     line-height: 1.5;
103 |     white-space: pre-wrap;
104 |     word-wrap: break-word;
105 |     box-shadow: 0 4px 8px rgba(0, 123, 255, 0.15);
106 |     transition: all 0.3s ease-in-out;
107 | }
108 | 
109 | .download-link {
110 |     display: inline-block;
111 |     margin-top: 12px;
112 |     padding: 10px 16px;
113 |     background: linear-gradient(135deg, #4facfe, #00f2fe);
114 |     color: #003366;
115 |     text-decoration: none;
116 |     border-radius: 6px;
117 |     font-weight: 600;
118 |     font-size: 14px;
119 |     transition: all 0.3s ease;
120 |     box-shadow: 0 4px 12px rgba(79, 172, 254, 0.3);
121 | }
122 | 
123 | .download-link:hover {
124 |     background: linear-gradient(135deg, #00f2fe, #4facfe);
125 |     color: #000000;
126 |     text-decoration: none;
127 |     transform: translateY(-2px);
128 |     box-shadow: 0 6px 16px rgba(79, 172, 254, 0.4);
129 | }
130 | 
131 | #key-results {
132 |     margin-top: 20px;
133 |     padding: 20px;
134 |     border: 2px dashed #007bff;
135 |     border-radius: 12px;
136 |     background-color: #f0f8ff;
137 |     box-shadow: 0 4px 12px rgba(0, 123, 255, 0.1);
138 |     transition: all 0.3s ease;
139 | }
140 | 
141 | #key-results h3 {
142 |     color: #0056b3;
143 |     margin-bottom: 15px;
144 |     text-align: center;
145 |     font-size: 22px;
146 |     border-bottom: 1px solid #b3d4fc;
147 |     padding-bottom: 8px;
148 | }
149 | 
150 | .key-display {
151 |     background: #e6f2ff;
152 |     padding: 15px 20px;
153 |     border-radius: 8px;
154 |     margin-bottom: 15px;
155 |     border: 1px solid #cce5ff;
156 |     box-shadow: inset 0 0 8px rgba(0, 123, 255, 0.1);
157 | }
158 | 
159 | .key-display p {
160 |     margin: 6px 0;
161 |     font-size: 15px;
162 |     color: #333;
163 |     line-height: 1.5;
164 | }
165 | 
166 | .key-display strong {
167 |     font-size: 16px;
168 |     color: #004085;
169 | }
170 | 
171 | #encrypt-results {
172 |     margin-top: 20px;
173 |     padding: 20px;
174 |     border: 2px dashed #007bff;
175 |     border-radius: 12px;
176 |     background-color: #f0f8ff;
177 |     box-shadow: 0 4px 12px rgba(0, 123, 255, 0.1);
178 |     transition: all 0.3s ease;
179 | }
180 | 
181 | #encrypt-results h3 {
182 |     color: #0056b3;
183 |     margin-bottom: 15px;
184 |     text-align: center;
185 |     font-size: 22px;
186 |     border-bottom: 1px solid #b3d4fc;
187 |     padding-bottom: 8px;
188 | }
189 | 
190 | #decrypt-results {
191 |     margin-top: 20px;
192 |     padding: 20px;
193 |     border: 2px dashed #007bff;
194 |     border-radius: 12px;
195 |     background-color: #f0f8ff;
196 |     box-shadow: 0 4px 12px rgba(0, 123, 255, 0.1);
197 |     transition: all 0.3s ease;
198 | }
199 | 
200 | #decrypt-results h3 {
201 |     color: #0056b3;
202 |     margin-bottom: 15px;
203 |     text-align: center;
204 |     font-size: 22px;
205 |     border-bottom: 1px solid #b3d4fc;
206 |     padding-bottom: 8px;
207 | }
208 | 
209 | .tabs {
210 |     display: flex;
211 |     background-color: #a2ccf2;
212 |     padding: 10px;
213 |     border-radius: 8px 8px 0 0;
214 |     border-color: #007bff;
215 |     border-style: solid;
216 |     gap: 10px;  
217 | }
218 | 
219 | .tab {
220 |     padding: 10px 20px;
221 |     cursor: pointer;
222 |     background-color: #ffffff;
223 |     border: 2px solid #ccc;
224 |     border-bottom: none;
225 |     border-radius: 8px 8px 0 0;
226 |     font-weight: 500;
227 |     color: #333;
228 |     transition: all 0.3s ease;
229 | }
230 | 
231 | .tab:hover {
232 |     background-color: #ffffff;
233 |     color: #007bff;
234 |     border-color: #007bff;
235 |     transform: translateY(-3px);
236 | }
237 | 
238 | .tab.active {
239 |     background-color: #ffffff;
240 |     border-color: #007bff;
241 |     color: #007bff;
242 |     font-weight: bold;
243 |     margin-bottom: -1px;
244 |     box-shadow: 0 -2px 4px rgba(0, 123, 255, 0.2);
245 | }
246 | 
247 | .tab-content {
248 |     display: none;
249 |     padding: 20px;
250 |     background-color: #ffffff;
251 |     border: 3px solid #007bff;
252 |     border-top: none;
253 |     border-radius: 0 0 8px 8px;
254 | }
255 | 
256 | .tab-content.active {
257 |     display: block;
258 | }
259 | 
260 | .result-container {
261 |     position: relative;
262 |     display: inline-block;
263 |     width: 100%;
264 | }
265 | 
266 | .result {
267 |     margin-top: 15px;
268 |     padding: 10px;
269 |     border: 1px solid #ddd;
270 |     border-radius: 4px;
271 |     background-color: white;
272 |     white-space: pre-wrap;
273 |     word-wrap: break-word;
274 |     min-height: 80px;
275 |     padding-right: 60px;
276 |     position: relative;
277 | }
278 | 
279 | .copy-button {
280 |     position: absolute;
281 |     top: 10px;
282 |     right: 10px;
283 |     padding: 4px 10px;
284 |     background-color: #3498db;
285 |     color: black;
286 |     border: none;
287 |     border-radius: 4px;
288 |     cursor: pointer;
289 |     font-size: 12px;
290 |     transition: background-color 0.3s ease;
291 | }
292 | 
293 | .copy-button:hover {
294 |     background-color: #2980b9;
295 | }
296 | 


--------------------------------------------------------------------------------
/app.py:
--------------------------------------------------------------------------------
  1 | from flask import Flask, render_template, request, jsonify, send_file
  2 | import os
  3 | from math import gcd
  4 | from Crypto.Cipher import PKCS1_OAEP
  5 | from Crypto.PublicKey import RSA
  6 | from Crypto.Hash import SHA256
  7 | from Crypto import Random
  8 | import base64
  9 | import random
 10 | from sympy import randprime
 11 | 
 12 | app = Flask(__name__)
 13 | app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB file limit
 14 | 
 15 | # Encryption alphabet for RSA (custom mapping) 
 16 | alphabet_e = {'a': '01', 'b': '02', 'c': '03', 'd': '04', 'e': '05', 'f': '06', 'g': '07', 'h': '08',
 17 |               'i': '09', 'j': '10', 'k': '11', 'l': '12', 'm': '13', 'n': '14', 'o': '15', 'p': '16',
 18 |               'q': '17', 'r': '18', 's': '19', 't': '20', 'u': '21', 'v': '22', 'w': '23', 'x': '24',
 19 |               'y': '25', 'z': '26', 'A': '27', 'B': '28', 'C': '29', 'D': '30', 'E': '31', 'F': '32',
 20 |               'G': '33', 'H': '34', 'I': '35', 'J': '36', 'K': '37', 'L': '38', 'M': '39', 'N': '40',
 21 |               'O': '41', 'P': '42', 'Q': '43', 'R': '44', 'S': '45', 'T': '46', 'U': '47', 'V': '48',
 22 |               'W': '49', 'X': '50', 'Y': '51', 'Z': '52', ' ': '53', '.': '54', ',': '55', '?': '56',
 23 |               '!': '57', '@': '58', '#': '59', '$': '60', '%': '61', '^': '62', '&': '63', '*': '64',
 24 |               '(': '65', ')': '66', '-': '67', '_': '68', '=': '69', '+': '70', '[': '71', ']': '72',
 25 |               '{': '73', '}': '74', '|': '75', '\\': '76', ':': '77', ';': '78', '"': '79', '\'': '80',
 26 |               '<': '81', '>': '82', '/': '83', '~': '85', '`': '86', '\n': '87'}
 27 | 
 28 | alphabet_d = {v: k for k, v in alphabet_e.items()}
 29 | 
 30 | # --- Secure RSA Implementation ---
 31 | def generate_large_prime(bits=512):
 32 |     """Generate a large prime number using PyCryptodome's method"""
 33 |     return RSA.generate(bits, Random.new().read).p
 34 | 
 35 | def generate_keys(p, q):
 36 |     """Generate RSA keys with proper security"""
 37 |     # Validate inputs
 38 |     if not isinstance(p, int) or not isinstance(q, int) or p <= 0 or q <= 0:
 39 |         raise ValueError("p and q must be positive integers")
 40 |     
 41 |     # Generate proper RSA key pair
 42 |     n = p * q
 43 |     phi = (p - 1) * (q - 1)
 44 |     
 45 |     # Use standard exponent 65537
 46 |     e = 65537
 47 |     
 48 |     # Ensure e is coprime with phi
 49 |     if gcd(e, phi) != 1:
 50 |         raise ValueError("e is not coprime with phi(n). Try different primes.")
 51 |     
 52 |     # Calculate modular inverse for d
 53 |     d = pow(e, -1, phi)
 54 |     
 55 |     # Return components needed for our operations
 56 |     return n, e, d, p, q
 57 | 
 58 | def rsa_encrypt(message, public_key):
 59 |     """Encrypt using RSA with OAEP padding"""
 60 |     e, n = public_key
 61 |     key = RSA.construct((n, e))
 62 |     cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)
 63 |     encrypted = cipher.encrypt(message.encode('utf-8'))
 64 |     return base64.b64encode(encrypted).decode('utf-8')
 65 | 
 66 | def rsa_decrypt(encrypted_message, private_key):
 67 |     """Decrypt using RSA with OAEP padding"""
 68 |     d, n, p, q = private_key
 69 |     key = RSA.construct((n, 65537, d, p, q))
 70 |     cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)
 71 |     encrypted = base64.b64decode(encrypted_message)
 72 |     return cipher.decrypt(encrypted).decode('utf-8')
 73 | 
 74 | # --- Caesar Cipher Functions (unchanged) ---
 75 | def caesar_encrypt(message, shift):
 76 |     result = ''
 77 |     for char in message:
 78 |         if char.isalpha():
 79 |             base = ord('A') if char.isupper() else ord('a')
 80 |             shifted = chr((ord(char) - base + shift) % 26 + base)
 81 |             result += shifted
 82 |         else:
 83 |             result += char
 84 |     return result
 85 | 
 86 | def caesar_decrypt(message, shift):
 87 |     return caesar_encrypt(message, -shift)
 88 | 
 89 | # --- Flask Routes ---
 90 | @app.route('/')
 91 | def index():
 92 |     return render_template('index.html')
 93 | 
 94 | @app.route('/generate_keys', methods=['POST'])
 95 | def generate_keys_route():
 96 |     try:
 97 |         p = int(request.form['p'])
 98 |         q = int(request.form['q'])
 99 |         N, e, d, p_val, q_val = generate_keys(p, q)
100 |         return jsonify({
101 |             'success': True, 
102 |             'N': N, 
103 |             'e': e, 
104 |             'd': d,
105 |             
106 |         })
107 |     except ValueError as ve:
108 |         return jsonify({'success': False, 'error': f"Invalid input: {str(ve)}. Please ensure p and q are valid positive integers."})
109 |     except Exception as e:
110 |         return jsonify({'success': False, 'error': str(e)})
111 | 
112 | @app.route('/encrypt', methods=['POST'])
113 | def encrypt_route():
114 |     try:
115 |         N = int(request.form['N'])
116 |         e = int(request.form['e'])
117 |         message = request.form['message']
118 |         
119 |         if 'file' in request.files:
120 |             file = request.files['file']
121 |             if file.filename != '':
122 |                 message = file.read().decode('utf-8')
123 |         
124 |         encrypted = rsa_encrypt(message, (e, N))
125 |         
126 |         with open('encrypted.txt', 'w') as f:
127 |             f.write(encrypted)
128 |             
129 |         return jsonify({
130 |             'success': True, 
131 |             'encrypted': encrypted, 
132 |             'download_link': '/download/encrypted.txt',
133 |             
134 |         })
135 |     except Exception as ex:
136 |         return jsonify({'success': False, 'error': str(ex)})
137 | 
138 | @app.route('/decrypt', methods=['POST'])
139 | def decrypt_route():
140 |     try:
141 |         N = int(request.form['N'])
142 |         d = int(request.form['d'])
143 |         p = int(request.form.get('p', 0))
144 |         q = int(request.form.get('q', 0))
145 |         message = request.form['message']
146 |         
147 |         if 'file' in request.files:
148 |             file = request.files['file']
149 |             if file.filename != '':
150 |                 message = file.read().decode('utf-8')
151 |         
152 |         # We need p and q for proper key construction
153 |         if p == 0 or q == 0:
154 |             raise ValueError("p and q are required for decryption")
155 |         
156 |         decrypted = rsa_decrypt(message, (d, N, p, q))
157 |         
158 |         with open('decrypted.txt', 'w') as f:
159 |             f.write(decrypted)
160 |             
161 |         return jsonify({
162 |             'success': True, 
163 |             'decrypted': decrypted, 
164 |             'download_link': '/download/decrypted.txt',
165 |            
166 |         })
167 |     except Exception as ex:
168 |         return jsonify({'success': False, 'error': str(ex)})
169 | 
170 | @app.route('/encrypt_caesar', methods=['POST'])
171 | def encrypt_caesar():
172 |     try:
173 |         shift = int(request.form['shift'])
174 |         message = request.form['message']
175 |         
176 |         # No need for file handling logic from the original here
177 |         
178 |         encrypted = caesar_encrypt(message, shift)
179 |         
180 |         # Simply return the result as JSON, no file writing needed
181 |         return jsonify({'success': True, 'encrypted': encrypted})
182 |     except Exception as e:
183 |         return jsonify({'success': False, 'error': str(e)})
184 | 
185 | @app.route('/decrypt_caesar', methods=['POST'])
186 | def decrypt_caesar():
187 |     try:
188 |         shift = int(request.form['shift'])
189 |         message = request.form['message']
190 |         
191 |         decrypted = caesar_decrypt(message, shift)
192 |         
193 |         # Simply return the result as JSON
194 |         return jsonify({'success': True, 'decrypted': decrypted})
195 |     except Exception as e:
196 |         return jsonify({'success': False, 'error': str(e)})
197 | 
198 | @app.route('/random_prime')
199 | def random_prime():
200 |     # You can adjust the range as needed for your application
201 |     prime = randprime(100, 1000)
202 |     return jsonify({'prime': prime})
203 | 
204 | @app.route('/download/<filename>')
205 | def download(filename):
206 |     # Security for file downloads (prevent path traversal)
207 |     safe_filename = os.path.basename(filename)
208 |     filepath = os.path.join(app.config['UPLOAD_FOLDER'], safe_filename)
209 |     if os.path.exists(filepath):
210 |         return send_file(filepath, as_attachment=True)
211 |     else:
212 |         return "file not found", 404 # Return a proper error if the file is not found
213 | 
214 | if __name__ == '__main__':
215 |     app.run(debug=True)


--------------------------------------------------------------------------------
/Backend/test_api.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | """
  3 | PyCrypt API Test Script
  4 | 
  5 | Test script to verify that the API endpoints are working correctly.
  6 | Run this after starting the API server to test functionality.
  7 | """
  8 | 
  9 | import requests
 10 | import json
 11 | import time
 12 | import base64
 13 | 
 14 | API_BASE_URL = "http://localhost:5000/api"
 15 | 
 16 | def test_health_check():
 17 |     """Test the health check endpoint"""
 18 |     print("🔍 Testing health check endpoint...")
 19 |     try:
 20 |         response = requests.get(f"{API_BASE_URL}/health")
 21 |         if response.status_code == 200:
 22 |             data = response.json()
 23 |             print(f"✅ Health check passed: {data['status']}")
 24 |             return True
 25 |         else:
 26 |             print(f"❌ Health check failed: {response.status_code}")
 27 |             return False
 28 |     except Exception as e:
 29 |         print(f"❌ Health check error: {e}")
 30 |         return False
 31 | 
 32 | def test_text_encryption_decryption():
 33 |     """Test text encryption and decryption"""
 34 |     print("\n🔍 Testing text encryption/decryption...")
 35 |     
 36 |     test_text = "Hello, this is a secret message for testing! 🔐"
 37 |     test_password = "test_password_123"
 38 |     test_hint = "Test password hint"
 39 |     
 40 |     try:
 41 |         # Test encryption
 42 |         print("  📤 Testing text encryption...")
 43 |         encrypt_response = requests.post(f"{API_BASE_URL}/encrypt/text", json={
 44 |             "text": test_text,
 45 |             "password": test_password,
 46 |             "hint": test_hint
 47 |         })
 48 |         
 49 |         if encrypt_response.status_code != 200:
 50 |             print(f"❌ Encryption failed: {encrypt_response.status_code}")
 51 |             return False
 52 |         
 53 |         encrypt_data = encrypt_response.json()
 54 |         if not encrypt_data.get('success'):
 55 |             print(f"❌ Encryption failed: {encrypt_data.get('error')}")
 56 |             return False
 57 |         
 58 |         encrypted_content = encrypt_data['encrypted_content']
 59 |         print(f"✅ Text encrypted successfully (length: {len(encrypted_content)} chars)")
 60 |         
 61 |         # Test decryption
 62 |         print("  📥 Testing text decryption...")
 63 |         decrypt_response = requests.post(f"{API_BASE_URL}/decrypt/text", json={
 64 |             "encrypted_content": encrypted_content,
 65 |             "password": test_password
 66 |         })
 67 |         
 68 |         if decrypt_response.status_code != 200:
 69 |             print(f"❌ Decryption failed: {decrypt_response.status_code}")
 70 |             return False
 71 |         
 72 |         decrypt_data = decrypt_response.json()
 73 |         if not decrypt_data.get('success'):
 74 |             print(f"❌ Decryption failed: {decrypt_data.get('error')}")
 75 |             return False
 76 |         
 77 |         decrypted_text = decrypt_data['decrypted_text']
 78 |         
 79 |         if decrypted_text == test_text:
 80 |             print("✅ Text decryption successful - original text recovered!")
 81 |             return True
 82 |         else:
 83 |             print(f"❌ Decrypted text doesn't match original:")
 84 |             print(f"   Original: {test_text}")
 85 |             print(f"   Decrypted: {decrypted_text}")
 86 |             return False
 87 |             
 88 |     except Exception as e:
 89 |         print(f"❌ Text encryption/decryption error: {e}")
 90 |         return False
 91 | 
 92 | def test_file_encryption_decryption():
 93 |     """Test file encryption and decryption"""
 94 |     print("\n🔍 Testing file encryption/decryption...")
 95 |     
 96 |     # Create test file content
 97 |     test_content = "This is test file content for encryption!\nLine 2 of the test file.\n🔒 Security test!"
 98 |     test_password = "file_test_password_456"
 99 |     test_hint = "File test hint"
100 |     
101 |     try:
102 |         # Test file encryption (simulate file upload)
103 |         print("  📤 Testing file encryption...")
104 |         files = {'file': ('test.txt', test_content, 'text/plain')}
105 |         data = {'password': test_password, 'hint': test_hint}
106 |         
107 |         encrypt_response = requests.post(f"{API_BASE_URL}/encrypt/file", files=files, data=data)
108 |         
109 |         if encrypt_response.status_code != 200:
110 |             print(f"❌ File encryption failed: {encrypt_response.status_code}")
111 |             return False
112 |         
113 |         encrypt_data = encrypt_response.json()
114 |         if not encrypt_data.get('success'):
115 |             print(f"❌ File encryption failed: {encrypt_data.get('error')}")
116 |             return False
117 |         
118 |         encrypted_content = encrypt_data['encrypted_content']
119 |         filename = encrypt_data['filename']
120 |         print(f"✅ File encrypted successfully: {filename}")
121 |         
122 |         # Test file decryption
123 |         print("  📥 Testing file decryption...")
124 |         decrypt_response = requests.post(f"{API_BASE_URL}/decrypt/file", json={
125 |             "encrypted_content": encrypted_content,
126 |             "password": test_password,
127 |             "filename": filename
128 |         })
129 |         
130 |         if decrypt_response.status_code != 200:
131 |             print(f"❌ File decryption failed: {decrypt_response.status_code}")
132 |             return False
133 |         
134 |         decrypt_data = decrypt_response.json()
135 |         if not decrypt_data.get('success'):
136 |             print(f"❌ File decryption failed: {decrypt_data.get('error')}")
137 |             return False
138 |         
139 |         # Decode the decrypted content
140 |         decrypted_content_b64 = decrypt_data['decrypted_content']
141 |         decrypted_content = base64.b64decode(decrypted_content_b64).decode('utf-8')
142 |         
143 |         if decrypted_content.strip() == test_content.strip():
144 |             print("✅ File decryption successful - original content recovered!")
145 |             return True
146 |         else:
147 |             print(f"❌ Decrypted content doesn't match original:")
148 |             print(f"   Original length: {len(test_content)}")
149 |             print(f"   Decrypted length: {len(decrypted_content)}")
150 |             return False
151 |             
152 |     except Exception as e:
153 |         print(f"❌ File encryption/decryption error: {e}")
154 |         return False
155 | 
156 | def test_wrong_password():
157 |     """Test decryption with wrong password"""
158 |     print("\n🔍 Testing wrong password handling...")
159 |     
160 |     test_text = "Secret message"
161 |     correct_password = "correct_password"
162 |     wrong_password = "wrong_password"
163 |     
164 |     try:
165 |         # Encrypt with correct password
166 |         encrypt_response = requests.post(f"{API_BASE_URL}/encrypt/text", json={
167 |             "text": test_text,
168 |             "password": correct_password
169 |         })
170 |         
171 |         encrypt_data = encrypt_response.json()
172 |         encrypted_content = encrypt_data['encrypted_content']
173 |         
174 |         # Try to decrypt with wrong password
175 |         decrypt_response = requests.post(f"{API_BASE_URL}/decrypt/text", json={
176 |             "encrypted_content": encrypted_content,
177 |             "password": wrong_password
178 |         })
179 |         
180 |         if decrypt_response.status_code == 200:
181 |             decrypt_data = decrypt_response.json()
182 |             if decrypt_data.get('success'):
183 |                 print("❌ Wrong password test failed - decryption should have failed!")
184 |                 return False
185 |             else:
186 |                 print("✅ Wrong password correctly rejected")
187 |                 return True
188 |         else:
189 |             print("✅ Wrong password correctly rejected (HTTP error)")
190 |             return True
191 |             
192 |     except Exception as e:
193 |         print(f"❌ Wrong password test error: {e}")
194 |         return False
195 | 
196 | def main():
197 |     """Run all API tests"""
198 |     print("🚀 Starting PyCrypt API Tests")
199 |     print("=" * 50)
200 |     
201 |     tests = [
202 |         test_health_check,
203 |         test_text_encryption_decryption,
204 |         test_file_encryption_decryption,
205 |         test_wrong_password
206 |     ]
207 |     
208 |     passed = 0
209 |     total = len(tests)
210 |     
211 |     for test in tests:
212 |         if test():
213 |             passed += 1
214 |         time.sleep(0.5)  # Small delay between tests
215 |     
216 |     print("\n" + "=" * 50)
217 |     print(f"📊 Test Results: {passed}/{total} tests passed")
218 |     
219 |     if passed == total:
220 |         print("🎉 All tests passed! API is working correctly.")
221 |         return True
222 |     else:
223 |         print("⚠️  Some tests failed. Check the API server and try again.")
224 |         return False
225 | 
226 | if __name__ == '__main__':
227 |     success = main()
228 |     exit(0 if success else 1) 


--------------------------------------------------------------------------------
/Frontend/src/App.css:
--------------------------------------------------------------------------------
  1 | /* Reset and base styles */
  2 | * {
  3 |   margin: 0;
  4 |   padding: 0;
  5 |   box-sizing: border-box;
  6 | }
  7 | 
  8 | body {
  9 |   font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
 10 |   background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
 11 |   min-height: 100vh;
 12 |   color: #333;
 13 | }
 14 | 
 15 | /* App layout */
 16 | .app {
 17 |   min-height: 100vh;
 18 |   display: flex;
 19 |   flex-direction: column;
 20 | }
 21 | 
 22 | /* Header */
 23 | .app-header {
 24 |   background: rgba(255, 255, 255, 0.95);
 25 |   backdrop-filter: blur(10px);
 26 |   border-bottom: 1px solid rgba(255, 255, 255, 0.2);
 27 |   padding: 1.5rem 0;
 28 |   box-shadow: 0 2px 20px rgba(0, 0, 0, 0.1);
 29 | }
 30 | 
 31 | .header-content {
 32 |   max-width: 1200px;
 33 |   margin: 0 auto;
 34 |   padding: 0 2rem;
 35 |   display: flex;
 36 |   flex-direction: column;
 37 |   align-items: center;
 38 |   gap: 0.5rem;
 39 | }
 40 | 
 41 | .logo {
 42 |   display: flex;
 43 |   align-items: center;
 44 |   gap: 0.75rem;
 45 |   color: #4c51bf;
 46 | }
 47 | 
 48 | .logo h1 {
 49 |   font-size: 2rem;
 50 |   font-weight: 700;
 51 |   margin: 0;
 52 | }
 53 | 
 54 | .subtitle {
 55 |   color: #666;
 56 |   font-size: 1.1rem;
 57 |   font-weight: 400;
 58 | }
 59 | 
 60 | .api-status {
 61 |   display: flex;
 62 |   align-items: center;
 63 |   gap: 0.5rem;
 64 |   padding: 0.5rem 1rem;
 65 |   border-radius: 20px;
 66 |   font-size: 0.875rem;
 67 |   font-weight: 500;
 68 | }
 69 | 
 70 | .api-status.connected {
 71 |   background: #d1fae5;
 72 |   color: #065f46;
 73 | }
 74 | 
 75 | .api-status.disconnected {
 76 |   background: #fee2e2;
 77 |   color: #991b1b;
 78 | }
 79 | 
 80 | .api-status.checking {
 81 |   background: #fef3c7;
 82 |   color: #92400e;
 83 | }
 84 | 
 85 | /* Main content */
 86 | .app-main {
 87 |   flex: 1;
 88 |   padding: 2rem 0;
 89 | }
 90 | 
 91 | .container {
 92 |   max-width: 1000px;
 93 |   margin: 0 auto;
 94 |   padding: 0 2rem;
 95 | }
 96 | 
 97 | /* Tabs */
 98 | .tabs {
 99 |   display: flex;
100 |   gap: 0.5rem;
101 |   margin-bottom: 2rem;
102 |   background: rgba(255, 255, 255, 0.1);
103 |   padding: 0.5rem;
104 |   border-radius: 12px;
105 |   backdrop-filter: blur(10px);
106 | }
107 | 
108 | .tab {
109 |   flex: 1;
110 |   padding: 1rem 2rem;
111 |   background: transparent;
112 |   border: none;
113 |   border-radius: 8px;
114 |   color: rgba(255, 255, 255, 0.8);
115 |   font-size: 1rem;
116 |   font-weight: 600;
117 |   cursor: pointer;
118 |   transition: all 0.3s ease;
119 | }
120 | 
121 | .tab:hover {
122 |   background: rgba(255, 255, 255, 0.1);
123 |   color: white;
124 | }
125 | 
126 | .tab.active {
127 |   background: white;
128 |   color: #4c51bf;
129 |   box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
130 | }
131 | 
132 | .tab:disabled {
133 |   opacity: 0.6;
134 |   cursor: not-allowed;
135 | }
136 | 
137 | /* Content layout */
138 | .content {
139 |   display: grid;
140 |   grid-template-columns: 1fr 1fr;
141 |   gap: 2rem;
142 | }
143 | 
144 | .form-section,
145 | .result-section {
146 |   background: rgba(255, 255, 255, 0.95);
147 |   border-radius: 16px;
148 |   padding: 2rem;
149 |   box-shadow: 0 8px 30px rgba(0, 0, 0, 0.1);
150 |   backdrop-filter: blur(10px);
151 | }
152 | 
153 | /* Forms */
154 | .encrypt-form,
155 | .decrypt-form {
156 |   display: flex;
157 |   flex-direction: column;
158 |   gap: 1.5rem;
159 | }
160 | 
161 | .form-group {
162 |   display: flex;
163 |   flex-direction: column;
164 |   gap: 0.5rem;
165 | }
166 | 
167 | .form-group label {
168 |   font-weight: 600;
169 |   color: #374151;
170 |   font-size: 0.875rem;
171 |   text-transform: uppercase;
172 |   letter-spacing: 0.5px;
173 | }
174 | 
175 | .form-input,
176 | .form-textarea {
177 |   padding: 0.75rem 1rem;
178 |   border: 2px solid #e5e7eb;
179 |   border-radius: 8px;
180 |   font-size: 1rem;
181 |   transition: all 0.3s ease;
182 |   background: white;
183 | }
184 | 
185 | .form-input:focus,
186 | .form-textarea:focus {
187 |   outline: none;
188 |   border-color: #4c51bf;
189 |   box-shadow: 0 0 0 3px rgba(76, 81, 191, 0.1);
190 | }
191 | 
192 | .form-textarea {
193 |   resize: vertical;
194 |   min-height: 120px;
195 |   font-family: 'Courier New', monospace;
196 | }
197 | 
198 | .form-textarea.encrypted-content {
199 |   background: #f8fafc;
200 |   font-size: 0.875rem;
201 | }
202 | 
203 | /* Password input */
204 | .password-input-wrapper {
205 |   position: relative;
206 |   display: flex;
207 |   align-items: center;
208 | }
209 | 
210 | .password-toggle {
211 |   position: absolute;
212 |   right: 0.75rem;
213 |   background: none;
214 |   border: none;
215 |   color: #6b7280;
216 |   cursor: pointer;
217 |   padding: 0.25rem;
218 |   border-radius: 4px;
219 |   transition: color 0.3s ease;
220 | }
221 | 
222 | .password-toggle:hover {
223 |   color: #4c51bf;
224 | }
225 | 
226 | /* Buttons */
227 | .form-actions {
228 |   display: flex;
229 |   gap: 1rem;
230 |   margin-top: 1rem;
231 | }
232 | 
233 | .btn {
234 |   display: flex;
235 |   align-items: center;
236 |   gap: 0.5rem;
237 |   padding: 0.875rem 1.5rem;
238 |   border: none;
239 |   border-radius: 8px;
240 |   font-size: 1rem;
241 |   font-weight: 600;
242 |   cursor: pointer;
243 |   transition: all 0.3s ease;
244 |   text-decoration: none;
245 | }
246 | 
247 | .btn-primary {
248 |   background: linear-gradient(135deg, #4c51bf, #667eea);
249 |   color: white;
250 |   flex: 1;
251 | }
252 | 
253 | .btn-primary:hover:not(:disabled) {
254 |   transform: translateY(-2px);
255 |   box-shadow: 0 8px 25px rgba(76, 81, 191, 0.4);
256 | }
257 | 
258 | .btn-secondary {
259 |   background: #f3f4f6;
260 |   color: #374151;
261 |   border: 1px solid #d1d5db;
262 | }
263 | 
264 | .btn-secondary:hover:not(:disabled) {
265 |   background: #e5e7eb;
266 | }
267 | 
268 | .btn:disabled {
269 |   opacity: 0.6;
270 |   cursor: not-allowed;
271 |   transform: none !important;
272 | }
273 | 
274 | /* Result display */
275 | .result-container {
276 |   display: flex;
277 |   flex-direction: column;
278 |   gap: 1rem;
279 | }
280 | 
281 | .result-container.error {
282 |   border-left: 4px solid #ef4444;
283 | }
284 | 
285 | .result-header {
286 |   display: flex;
287 |   align-items: center;
288 |   justify-content: space-between;
289 |   gap: 0.5rem;
290 | }
291 | 
292 | .result-header span {
293 |   display: flex;
294 |   align-items: center;
295 |   gap: 0.5rem;
296 |   font-weight: 600;
297 |   color: #374151;
298 | }
299 | 
300 | .copy-btn {
301 |   display: flex;
302 |   align-items: center;
303 |   gap: 0.5rem;
304 |   padding: 0.5rem 1rem;
305 |   background: #f3f4f6;
306 |   border: 1px solid #d1d5db;
307 |   border-radius: 6px;
308 |   font-size: 0.875rem;
309 |   cursor: pointer;
310 |   transition: all 0.3s ease;
311 | }
312 | 
313 | .copy-btn:hover {
314 |   background: #4c51bf;
315 |   color: white;
316 |   border-color: #4c51bf;
317 | }
318 | 
319 | .copy-btn.copied {
320 |   background: #10b981;
321 |   color: white;
322 |   border-color: #10b981;
323 | }
324 | 
325 | .result-textarea {
326 |   width: 100%;
327 |   padding: 1rem;
328 |   border: 2px solid #e5e7eb;
329 |   border-radius: 8px;
330 |   font-family: 'Courier New', monospace;
331 |   font-size: 0.875rem;
332 |   background: #f8fafc;
333 |   resize: vertical;
334 |   min-height: 120px;
335 | }
336 | 
337 | .result-info {
338 |   display: flex;
339 |   align-items: center;
340 |   gap: 0.5rem;
341 |   padding: 0.75rem;
342 |   background: #dbeafe;
343 |   border-radius: 8px;
344 |   color: #1e40af;
345 |   font-size: 0.875rem;
346 | }
347 | 
348 | .result-stats {
349 |   display: flex;
350 |   gap: 1rem;
351 |   font-size: 0.875rem;
352 |   color: #6b7280;
353 | }
354 | 
355 | .stat {
356 |   padding: 0.25rem 0.5rem;
357 |   background: #f3f4f6;
358 |   border-radius: 4px;
359 | }
360 | 
361 | .error-message {
362 |   color: #ef4444;
363 |   padding: 1rem;
364 |   background: #fef2f2;
365 |   border-radius: 8px;
366 |   border-left: 4px solid #ef4444;
367 | }
368 | 
369 | /* API Warning */
370 | .api-warning {
371 |   display: flex;
372 |   align-items: center;
373 |   gap: 1rem;
374 |   padding: 1rem;
375 |   background: #fef3c7;
376 |   border: 1px solid #f59e0b;
377 |   border-radius: 8px;
378 |   margin-top: 2rem;
379 |   color: #92400e;
380 | }
381 | 
382 | .api-warning code {
383 |   background: rgba(0, 0, 0, 0.1);
384 |   padding: 0.25rem 0.5rem;
385 |   border-radius: 4px;
386 |   font-family: 'Courier New', monospace;
387 | }
388 | 
389 | .retry-btn {
390 |   padding: 0.5rem 1rem;
391 |   background: #f59e0b;
392 |   color: white;
393 |   border: none;
394 |   border-radius: 6px;
395 |   cursor: pointer;
396 |   font-weight: 600;
397 | }
398 | 
399 | .retry-btn:hover {
400 |   background: #d97706;
401 | }
402 | 
403 | /* Footer */
404 | .app-footer {
405 |   text-align: center;
406 |   padding: 2rem;
407 |   color: rgba(255, 255, 255, 0.8);
408 |   font-size: 0.875rem;
409 | }
410 | 
411 | /* Responsive design */
412 | @media (max-width: 768px) {
413 |   .content {
414 |     grid-template-columns: 1fr;
415 |     gap: 1.5rem;
416 |   }
417 |   
418 |   .header-content {
419 |     padding: 0 1rem;
420 |   }
421 |   
422 |   .container {
423 |     padding: 0 1rem;
424 |   }
425 |   
426 |   .form-section,
427 |   .result-section {
428 |     padding: 1.5rem;
429 |   }
430 |   
431 |   .tabs {
432 |     flex-direction: column;
433 |   }
434 |   
435 |   .form-actions {
436 |     flex-direction: column;
437 |   }
438 | }
439 | 
440 | @media (max-width: 480px) {
441 |   .logo h1 {
442 |     font-size: 1.5rem;
443 |   }
444 |   
445 |   .subtitle {
446 |     font-size: 1rem;
447 |   }
448 |   
449 |   .form-section,
450 |   .result-section {
451 |     padding: 1rem;
452 |   }
453 | }
454 | 


--------------------------------------------------------------------------------
/Backend/api.py:
--------------------------------------------------------------------------------
  1 | from flask import Flask, request, jsonify, send_file
  2 | from flask_cors import CORS
  3 | import os
  4 | import tempfile
  5 | import base64
  6 | import io
  7 | from crypto.encryptor import encrypt_file
  8 | from crypto.decryptor import decrypt_file
  9 | from crypto.utils import wipe_file
 10 | 
 11 | app = Flask(__name__)
 12 | CORS(app)  # Enable CORS for React app integration
 13 | 
 14 | # Configure upload folder and max file size
 15 | UPLOAD_FOLDER = tempfile.gettempdir()
 16 | app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 17 | app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
 18 | 
 19 | @app.route('/api/health', methods=['GET'])
 20 | def health_check():
 21 |     """Health check endpoint"""
 22 |     return jsonify({
 23 |         'status': 'healthy',
 24 |         'service': 'PyCrypt API',
 25 |         'version': '1.0.0'
 26 |     })
 27 | 
 28 | @app.route('/api/encrypt/text', methods=['POST'])
 29 | def encrypt_text():
 30 |     """Encrypt text content with password"""
 31 |     try:
 32 |         data = request.get_json()
 33 |         if not data:
 34 |             return jsonify({'error': 'JSON data required'}), 400
 35 |         
 36 |         text = data.get('text')
 37 |         password = data.get('password')
 38 |         hint = data.get('hint')
 39 |         
 40 |         if not text or not password:
 41 |             return jsonify({'error': 'Both text and password are required'}), 400
 42 |         
 43 |         # Create temporary file for text
 44 |         with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as temp_file:
 45 |             temp_file.write(text)
 46 |             temp_file_path = temp_file.name
 47 |         
 48 |         try:
 49 |             # Encrypt the file
 50 |             encrypted_file_path = encrypt_file(temp_file_path, password, hint=hint, overwrite=True)
 51 |             
 52 |             # Read encrypted content
 53 |             with open(encrypted_file_path, 'rb') as f:
 54 |                 encrypted_content = base64.b64encode(f.read()).decode('utf-8')
 55 |             
 56 |             # Clean up temporary files
 57 |             os.unlink(temp_file_path)
 58 |             os.unlink(encrypted_file_path)
 59 |             
 60 |             return jsonify({
 61 |                 'success': True,
 62 |                 'encrypted_content': encrypted_content,
 63 |                 'hint': hint if hint else None
 64 |             })
 65 |             
 66 |         except Exception as e:
 67 |             # Clean up on error
 68 |             if os.path.exists(temp_file_path):
 69 |                 os.unlink(temp_file_path)
 70 |             raise e
 71 |             
 72 |     except Exception as e:
 73 |         return jsonify({'error': str(e)}), 500
 74 | 
 75 | @app.route('/api/decrypt/text', methods=['POST'])
 76 | def decrypt_text():
 77 |     """Decrypt text content with password"""
 78 |     try:
 79 |         data = request.get_json()
 80 |         if not data:
 81 |             return jsonify({'error': 'JSON data required'}), 400
 82 |         
 83 |         encrypted_content = data.get('encrypted_content')
 84 |         password = data.get('password')
 85 |         
 86 |         if not encrypted_content or not password:
 87 |             return jsonify({'error': 'Both encrypted_content and password are required'}), 400
 88 |         
 89 |         # Create temporary file for encrypted content
 90 |         with tempfile.NamedTemporaryFile(mode='wb', delete=False, suffix='.enc') as temp_file:
 91 |             temp_file.write(base64.b64decode(encrypted_content))
 92 |             temp_file_path = temp_file.name
 93 |         
 94 |         try:
 95 |             # Decrypt the file
 96 |             decrypted_file_path = decrypt_file(temp_file_path, password, overwrite=True)
 97 |             
 98 |             # Read decrypted content
 99 |             with open(decrypted_file_path, 'r', encoding='utf-8') as f:
100 |                 decrypted_text = f.read()
101 |             
102 |             # Clean up temporary files
103 |             os.unlink(temp_file_path)
104 |             os.unlink(decrypted_file_path)
105 |             
106 |             return jsonify({
107 |                 'success': True,
108 |                 'decrypted_text': decrypted_text
109 |             })
110 |             
111 |         except Exception as e:
112 |             # Clean up on error
113 |             if os.path.exists(temp_file_path):
114 |                 os.unlink(temp_file_path)
115 |             raise e
116 |             
117 |     except Exception as e:
118 |         return jsonify({'error': str(e)}), 500
119 | 
120 | @app.route('/api/encrypt/file', methods=['POST'])
121 | def encrypt_file_endpoint():
122 |     """Encrypt uploaded file with password"""
123 |     try:
124 |         if 'file' not in request.files:
125 |             return jsonify({'error': 'No file uploaded'}), 400
126 |         
127 |         file = request.files['file']
128 |         password = request.form.get('password')
129 |         hint = request.form.get('hint')
130 |         
131 |         if file.filename == '':
132 |             return jsonify({'error': 'No file selected'}), 400
133 |         
134 |         if not password:
135 |             return jsonify({'error': 'Password is required'}), 400
136 |         
137 |         # Save uploaded file temporarily
138 |         temp_file_path = os.path.join(app.config['UPLOAD_FOLDER'], 
139 |                                     f"temp_{file.filename}")
140 |         file.save(temp_file_path)
141 |         
142 |         try:
143 |             # Encrypt the file
144 |             encrypted_file_path = encrypt_file(temp_file_path, password, hint=hint, overwrite=True)
145 |             
146 |             # Read encrypted file content
147 |             with open(encrypted_file_path, 'rb') as f:
148 |                 encrypted_content = base64.b64encode(f.read()).decode('utf-8')
149 |             
150 |             # Clean up temporary files
151 |             os.unlink(temp_file_path)
152 |             os.unlink(encrypted_file_path)
153 |             
154 |             return jsonify({
155 |                 'success': True,
156 |                 'filename': file.filename,
157 |                 'encrypted_content': encrypted_content,
158 |                 'hint': hint if hint else None
159 |             })
160 |             
161 |         except Exception as e:
162 |             # Clean up on error
163 |             if os.path.exists(temp_file_path):
164 |                 os.unlink(temp_file_path)
165 |             raise e
166 |             
167 |     except Exception as e:
168 |         return jsonify({'error': str(e)}), 500
169 | 
170 | @app.route('/api/decrypt/file', methods=['POST'])
171 | def decrypt_file_endpoint():
172 |     """Decrypt file content with password"""
173 |     try:
174 |         data = request.get_json()
175 |         if not data:
176 |             return jsonify({'error': 'JSON data required'}), 400
177 |         
178 |         encrypted_content = data.get('encrypted_content')
179 |         password = data.get('password')
180 |         filename = data.get('filename', 'decrypted_file')
181 |         
182 |         if not encrypted_content or not password:
183 |             return jsonify({'error': 'Both encrypted_content and password are required'}), 400
184 |         
185 |         # Create temporary file for encrypted content
186 |         temp_file_path = os.path.join(app.config['UPLOAD_FOLDER'], 
187 |                                     f"temp_encrypted_{filename}.enc")
188 |         
189 |         with open(temp_file_path, 'wb') as f:
190 |             f.write(base64.b64decode(encrypted_content))
191 |         
192 |         try:
193 |             # Decrypt the file
194 |             decrypted_file_path = decrypt_file(temp_file_path, password, overwrite=True)
195 |             
196 |             # Read decrypted content as base64 for binary safety
197 |             with open(decrypted_file_path, 'rb') as f:
198 |                 decrypted_content = base64.b64encode(f.read()).decode('utf-8')
199 |             
200 |             # Clean up temporary files
201 |             os.unlink(temp_file_path)
202 |             os.unlink(decrypted_file_path)
203 |             
204 |             return jsonify({
205 |                 'success': True,
206 |                 'filename': filename,
207 |                 'decrypted_content': decrypted_content
208 |             })
209 |             
210 |         except Exception as e:
211 |             # Clean up on error
212 |             if os.path.exists(temp_file_path):
213 |                 os.unlink(temp_file_path)
214 |             raise e
215 |             
216 |     except Exception as e:
217 |         return jsonify({'error': str(e)}), 500
218 | 
219 | @app.route('/api/download/encrypted', methods=['POST'])
220 | def download_encrypted():
221 |     """Download encrypted content as file"""
222 |     try:
223 |         data = request.get_json()
224 |         encrypted_content = data.get('encrypted_content')
225 |         filename = data.get('filename', 'encrypted_file.enc')
226 |         
227 |         if not encrypted_content:
228 |             return jsonify({'error': 'encrypted_content is required'}), 400
229 |         
230 |         # Create file-like object from base64 content
231 |         file_data = base64.b64decode(encrypted_content)
232 |         file_obj = io.BytesIO(file_data)
233 |         
234 |         return send_file(
235 |             file_obj,
236 |             as_attachment=True,
237 |             download_name=filename,
238 |             mimetype='application/octet-stream'
239 |         )
240 |         
241 |     except Exception as e:
242 |         return jsonify({'error': str(e)}), 500
243 | 
244 | @app.route('/api/download/decrypted', methods=['POST'])
245 | def download_decrypted():
246 |     """Download decrypted content as file"""
247 |     try:
248 |         data = request.get_json()
249 |         decrypted_content = data.get('decrypted_content')
250 |         filename = data.get('filename', 'decrypted_file.txt')
251 |         
252 |         if not decrypted_content:
253 |             return jsonify({'error': 'decrypted_content is required'}), 400
254 |         
255 |         # Create file-like object from base64 content
256 |         file_data = base64.b64decode(decrypted_content)
257 |         file_obj = io.BytesIO(file_data)
258 |         
259 |         return send_file(
260 |             file_obj,
261 |             as_attachment=True,
262 |             download_name=filename,
263 |             mimetype='application/octet-stream'
264 |         )
265 |         
266 |     except Exception as e:
267 |         return jsonify({'error': str(e)}), 500
268 | 
269 | @app.route('/api/wipe', methods=['POST'])
270 | def secure_wipe():
271 |     """Securely wipe a temporary file (for auto-wipe functionality)"""
272 |     try:
273 |         data = request.get_json()
274 |         file_id = data.get('file_id')
275 |         
276 |         if not file_id:
277 |             return jsonify({'error': 'file_id is required'}), 400
278 |         
279 |         # This would be used with a file tracking system
280 |         # For now, just return success as files are auto-cleaned
281 |         return jsonify({
282 |             'success': True,
283 |             'message': 'File wiped successfully'
284 |         })
285 |         
286 |     except Exception as e:
287 |         return jsonify({'error': str(e)}), 500
288 | 
289 | if __name__ == '__main__':
290 |     app.run(host='0.0.0.0', port=5000, debug=True) 


--------------------------------------------------------------------------------
/templates/index.html:
--------------------------------------------------------------------------------
  1 | <!-- templates/index.html -->
  2 | <!DOCTYPE html>
  3 | <html lang="en">
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |     <title>RSA Encryption/Decryption Tool</title>
  8 |     <link rel="stylesheet" href="/static/styles.css">
  9 | </head>
 10 | <body>
 11 |     <div class="container">
 12 |         <h1>RSA Encryption/Decryption Tool</h1>
 13 |         
 14 |         <div class="tabs">
 15 |             <div class="tab active" onclick="switchTab('key-generation')">Key Generation</div>
 16 |             <div class="tab" onclick="switchTab('encryption')">Encryption</div>
 17 |             <div class="tab" onclick="switchTab('decryption')">Decryption</div>
 18 |             <div class="tab" onclick="switchTab('caesar-cipher')">Caesar Cipher</div>
 19 |         </div>
 20 |         
 21 |         <div id="key-generation" class="tab-content active">
 22 |             <div class="section">
 23 |                 <h2>Generate RSA Keys</h2>
 24 |                 <div class="form-group">
 25 |                     <label for="prime1">Prime 1:</label>
 26 |                     <input type="text" id="prime1" name="prime1">
 27 |                     <button type="button" onclick="generateRandomPrime('prime1')">Random</button>
 28 |                 </div>
 29 |                 <div class="form-group">
 30 |                     <label for="prime2">Prime 2:</label>
 31 |                     <input type="text" id="prime2" name="prime2">
 32 |                     <button type="button" onclick="generateRandomPrime('prime2')">Random</button>
 33 |                 </div>
 34 |                 <button onclick="generateKeys()">Generate Keys</button>
 35 |                 
 36 |                 <div id="key-results" style="display: none;">
 37 |                     <h3>Generated Keys</h3>
 38 |                     <div class="key-display">
 39 |                         <p><strong>Public Key:</strong></p>
 40 |                         <p>N: <span id="public-N"></span></p>
 41 |                         <p>e: <span id="public-e"></span></p>
 42 |                     </div>
 43 |                     <div class="key-display">
 44 |                         <p><strong>Private Key:</strong></p>
 45 |                         <p>N: <span id="private-N"></span></p>
 46 |                         <p>d: <span id="private-d"></span></p>
 47 |                     </div>
 48 |                 </div>
 49 |             </div>
 50 |         </div>
 51 |         
 52 |         <div id="encryption" class="tab-content">
 53 |             <div class="section">
 54 |                 <h2>Encrypt Message</h2>
 55 |                 <div class="form-group">
 56 |                     <label for="encrypt-N">N:</label>
 57 |                     <input type="number" id="encrypt-N" min="1" step="1" placeholder="Modulus (N)">
 58 |                 </div>
 59 |                 <div class="form-group">
 60 |                     <label for="encrypt-e">e:</label>
 61 |                     <input type="number" id="encrypt-e" min="1" step="1" placeholder="Public Exponent (e)">
 62 |                 </div>
 63 |                 <div class="form-group">
 64 |                     <label for="encrypt-message">Message to Encrypt:</label>
 65 |                     <textarea id="encrypt-message">
66 |
67 |
68 | Or Upload a file: 69 | 70 |
71 | 72 | 73 | 81 | 82 |
Encrypted Result

Decrypt Message

Decrypted Result

Caesar Cipher
