VignereBreaker.py

import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import (
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QLabel,
    QPushButton,
    QGroupBox,
    QScrollArea,
    QLineEdit,
    QComboBox,
    QApplication,
    QTextEdit,
    QMessageBox,
    QFormLayout,
)

from ChiSquare import ChiSquare
from FrequencyAnalysis import Frequency
from FriedmanAnalysis import Friedman
from SubstringDistance import SubstringDistance
import markdown


class AlphabetSlider(QWidget):
    """Widget for shifting cipher alphabets with improved visual feedback"""

    def __init__(self, alphabet, parent, index=0):
        super(QWidget, self).__init__(parent)
        self.parent1 = parent
        self.alphabet = alphabet
        self.oalphabet = alphabet
        self.shift = 0
        self.index = index
        layout = QVBoxLayout()

        # Add position label
        position_label = QLabel(f"Position {index}")
        position_label.setStyleSheet("font-weight: bold; color: #555;")
        layout.addWidget(position_label)

        # Control layout
        control_layout = QHBoxLayout()

        self.lbutton = QPushButton("◀")
        self.lbutton.setToolTip("Shift alphabet left (decrease key value)")
        self.lbutton.setFixedWidth(40)
        self.lbutton.clicked.connect(self.shiftLeft)
        control_layout.addWidget(self.lbutton)

        # Shift indicator
        self.shift_label = QLabel(
            f"Shift: {self.shift} Key Value: {self.oalphabet[self.shift]}"
        )
        self.shift_label.setAlignment(Qt.AlignCenter)
        self.shift_label.setStyleSheet("font-weight: bold; color: #0066cc;")
        self.shift_label.setMinimumWidth(80)
        control_layout.addWidget(self.shift_label)

        self.rbutton = QPushButton("▶")
        self.rbutton.setToolTip("Shift alphabet right (increase key value)")
        self.rbutton.setFixedWidth(40)
        self.rbutton.clicked.connect(self.shiftRight)
        control_layout.addWidget(self.rbutton)

        layout.addLayout(control_layout)

        # Alphabet display
        self.label = QLabel(alphabet)
        self.label.setAlignment(Qt.AlignCenter)
        self.label.setStyleSheet(
            """
            QLabel {
                font-family: 'Courier New', monospace;
                font-size: 12pt;
                padding: 8px;
                background-color: #f0f0f0;
                border: 1px solid #ccc;
                border-radius: 4px;
            }
        """
        )
        layout.addWidget(self.label)

        self.setLayout(layout)

    def shiftRight(self):
        self.alphabet = self.alphabet[-1] + self.alphabet[:-1]
        self.label.setText(self.alphabet)
        self.shift = (self.shift + 1) % len(self.alphabet)
        self.shift_label.setText(
            f"Shift: {self.shift} Key Value: {self.oalphabet[self.shift]}"
        )
        self.parent1.changePreview()

    def shiftLeft(self):
        self.alphabet = self.alphabet[1:] + self.alphabet[0]
        self.label.setText(self.alphabet)
        self.shift = (self.shift - 1) % len(self.alphabet)
        self.shift_label.setText(
            f"Shift: {self.shift} Key Value: {self.oalphabet[self.shift]}"
        )
        self.parent1.changePreview()

    def setAlphabet(self, alphabet):
        self.alphabet = alphabet
        self.oalphabet = alphabet
        self.shift = 0
        self.shift_label.setText(
            f"Shift: {self.shift} Key Value: {self.oalphabet[self.shift]}"
        )
        self.label.setText(self.alphabet)
        self.parent1.changePreview()


class VigenereWindow(QWidget):
    """Main window for Vigenère cipher analysis with improved UX"""

    def __init__(self, parent=None):
        super(VigenereWindow, self).__init__(parent)

        self.setWindowTitle("Vigenère Cipher Analyzer")
        self.setMinimumSize(900, 700)

        main_layout = QVBoxLayout()

        # Add instructions panel
        self.add_instructions_panel(main_layout)

        # Add alphabet configuration section
        self.add_alphabet_config(main_layout)

        # Add ciphertext input section
        self.add_ciphertext_input(main_layout)

        # Add analysis tools section
        self.add_analysis_tools(main_layout)

        # Add key configuration section
        self.add_key_config(main_layout)

        # Add statistics section
        self.add_statistics_section(main_layout)

        # Add preview section
        self.add_preview_section(main_layout)

        self.setLayout(main_layout)

        # Initialize analysis windows
        self.substringd = None
        self.friedmanw = None
        self.frequencyw = None
        self.chiw = None

    def add_instructions_panel(self, layout):
        """Add collapsible instructions panel"""
        instructions_group = QGroupBox("ℹ️ Instructions")
        instructions_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #4CAF50;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #4CAF50;
            }
        """
        )

        instructions_layout = QVBoxLayout()

        instructions_text = QLabel(
            markdown.markdown(
                """
## How to use this tool:

1. **Enter ciphertext:** Paste the encrypted text you want to analyze
2. **Determine key length:** Use Friedman Test or Substring Distance analysis
3. **Set key length:** Select the likely key length from the dropdown
4. **Analyze frequencies:** Use Frequency or Chi-Square analysis to find shift values
5. **Adjust shifts:** Use the arrow buttons to shift each alphabet position until readable text appears
6. **Read decrypted text:** View the result in the preview panel at the bottom

**Tips:**

- The Friedman test helps estimate key length based on Index of Coincidence
- Substring distance looks for repeating patterns in the ciphertext
- Frequency analysis compares letter frequencies to expected English frequencies
- Chi-square analysis provides a statistical measure of how English-like the text is
        """
            )
        )
        instructions_text.setWordWrap(True)
        instructions_text.setStyleSheet("padding: 10px; font-weight: normal;")

        scroll = QScrollArea()
        scroll.setWidget(instructions_text)

        instructions_layout.addWidget(scroll)
        instructions_group.setLayout(instructions_layout)

        layout.addWidget(instructions_group)

    def add_alphabet_config(self, layout):
        """Add alphabet configuration section"""
        alphabet_group = QGroupBox("📝 Alphabet Configuration")
        alphabet_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #2196F3;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #2196F3;
            }
        """
        )

        alphabet_layout = QFormLayout()

        # Plain alphabet
        plain_label = QLabel("Plaintext Alphabet:")
        plain_label.setToolTip(
            "The alphabet used for the decrypted text (usually standard A-Z)"
        )
        self.plainalphabettextbox = QLineEdit()
        self.plainalphabettextbox.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        self.plainalphabettextbox.setPlaceholderText(
            "Enter plaintext alphabet (e.g., ABCDEFGHIJKLMNOPQRSTUVWXYZ)"
        )
        self.plainalphabettextbox.textChanged.connect(self.changePlainLabel)
        alphabet_layout.addRow(plain_label, self.plainalphabettextbox)

        # Cipher alphabet
        cipher_label = QLabel("Ciphertext Alphabet:")
        cipher_label.setToolTip(
            "The alphabet used in the encrypted text (may be reordered)"
        )
        self.cipheralphabettextbox = QLineEdit()
        self.cipheralphabettextbox.setText("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        self.cipheralphabettextbox.setPlaceholderText("Enter ciphertext alphabet")
        self.cipheralphabettextbox.textChanged.connect(self.changeCipherLabel)
        alphabet_layout.addRow(cipher_label, self.cipheralphabettextbox)

        alphabet_group.setLayout(alphabet_layout)
        layout.addWidget(alphabet_group)

    def add_ciphertext_input(self, layout):
        """Add ciphertext input section"""
        ciphertext_group = QGroupBox("🔒 Encrypted Text Input")
        ciphertext_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #FF5722;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #FF5722;
            }
        """
        )

        ciphertext_layout = QVBoxLayout()

        label = QLabel("Paste your encrypted text below:")
        ciphertext_layout.addWidget(label)

        self.ciphertextbox = QTextEdit()
        self.ciphertextbox.setPlaceholderText("Enter or paste ciphertext here...")
        self.ciphertextbox.setMaximumHeight(100)
        self.ciphertextbox.textChanged.connect(self.cipherTextChanged)
        ciphertext_layout.addWidget(self.ciphertextbox)

        # Add character count
        self.char_count_label = QLabel("Characters: 0")
        self.char_count_label.setStyleSheet("color: #666; font-style: italic;")
        ciphertext_layout.addWidget(self.char_count_label)

        ciphertext_group.setLayout(ciphertext_layout)
        layout.addWidget(ciphertext_group)

    def add_analysis_tools(self, layout):
        """Add analysis tools section"""
        tools_group = QGroupBox("🔍 Analysis Tools")
        tools_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #9C27B0;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #9C27B0;
            }
        """
        )

        tools_layout = QVBoxLayout()

        # First row: Key length analysis
        key_length_layout = QHBoxLayout()
        key_length_label = QLabel("Determine Key Length:")
        key_length_label.setStyleSheet("font-weight: bold;")
        key_length_layout.addWidget(key_length_label)

        self.substringd_button = QPushButton("📊 Substring Distance")
        self.substringd_button.setToolTip(
            "Find repeating patterns to estimate key length"
        )
        self.substringd_button.clicked.connect(self.launch_substringd)
        key_length_layout.addWidget(self.substringd_button)

        self.friedman_button = QPushButton("📈 Friedman Test")
        self.friedman_button.setToolTip(
            "Calculate Index of Coincidence to estimate key length"
        )
        self.friedman_button.clicked.connect(self.launch_friedman)
        key_length_layout.addWidget(self.friedman_button)

        key_length_layout.addStretch()
        tools_layout.addLayout(key_length_layout)

        # Second row: Frequency analysis
        freq_layout = QHBoxLayout()
        freq_label = QLabel("Analyze Letter Frequencies:")
        freq_label.setStyleSheet("font-weight: bold;")
        freq_layout.addWidget(freq_label)

        self.frequency_button = QPushButton("📊 Frequency Analysis")
        self.frequency_button.setToolTip(
            "Compare letter frequencies with expected English frequencies"
        )
        self.frequency_button.clicked.connect(self.launch_frequency)
        freq_layout.addWidget(self.frequency_button)

        self.chi_button = QPushButton("📉 Chi-Square Analysis")
        self.chi_button.setToolTip("Statistical analysis to find the best shift values")
        self.chi_button.clicked.connect(self.launch_chi)
        freq_layout.addWidget(self.chi_button)

        freq_layout.addStretch()
        tools_layout.addLayout(freq_layout)

        tools_group.setLayout(tools_layout)
        layout.addWidget(tools_group)

    def add_key_config(self, layout):
        """Add key configuration section"""
        key_group = QGroupBox("🔑 Key Configuration")
        key_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #FF9800;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #FF9800;
            }
        """
        )

        key_layout = QVBoxLayout()

        # Key length selector
        length_layout = QHBoxLayout()
        length_label = QLabel("Key Length:")
        length_label.setToolTip("Number of different Caesar shifts in the key")
        length_label.setStyleSheet("font-weight: bold;")
        length_layout.addWidget(length_label)

        self.number_alphabets = QComboBox()
        self.number_alphabets.addItems([str(x) for x in range(1, 25)])
        self.number_alphabets.setToolTip(
            "Select the estimated length of the Vigenère key"
        )
        self.number_alphabets.currentIndexChanged.connect(self.changeNumberAlphabets)
        length_layout.addWidget(self.number_alphabets)

        length_layout.addStretch()
        key_layout.addLayout(length_layout)

        # Current cipher alphabet display
        self.ciphertextlabel = QLabel("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        self.ciphertextlabel.setAlignment(Qt.AlignCenter)
        self.ciphertextlabel.setStyleSheet(
            """
            font-family: 'Courier New', monospace;
            font-size: 11pt;
            padding: 5px;
            background-color: #fff3e0;
            border: 1px solid #FF9800;
            border-radius: 3px;
        """
        )
        key_layout.addWidget(self.ciphertextlabel)

        # Alphabet sliders in scroll area
        slider_label = QLabel("Adjust each position of the key:")
        slider_label.setStyleSheet("font-weight: bold; margin-top: 10px;")
        key_layout.addWidget(slider_label)

        scrollArea = QScrollArea()
        scrollArea.setWidgetResizable(True)
        scrollArea.setMaximumHeight(300)
        alphabet_widget = QWidget()
        self.alphabet_widget_layout = QVBoxLayout()
        self.alphabets = [AlphabetSlider("ABCDEFGHIJKLMNOPQRSTUVWXYZ", self, 0)]
        self.alphabet_widget_layout.addWidget(self.alphabets[0])
        alphabet_widget.setLayout(self.alphabet_widget_layout)
        scrollArea.setWidget(alphabet_widget)
        key_layout.addWidget(scrollArea)

        key_group.setLayout(key_layout)
        layout.addWidget(key_group)

    def add_statistics_section(self, layout):
        """Add statistics display section"""
        stats_group = QGroupBox("📊 Statistics")
        stats_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #607D8B;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #607D8B;
            }
        """
        )

        stats_layout = QHBoxLayout()

        ic_label = QLabel("Index of Coincidence:")
        ic_label.setToolTip(
            "Higher IC (closer to 0.065) suggests more English-like text"
        )
        stats_layout.addWidget(ic_label)

        self.overall_IC_label = QLabel("N/A")
        self.overall_IC_label.setStyleSheet("font-weight: bold; color: #0066cc;")
        stats_layout.addWidget(self.overall_IC_label)

        stats_layout.addStretch()

        chi_label = QLabel("Chi-Square Value:")
        chi_label.setToolTip("Lower chi-square value suggests better match to English")
        stats_layout.addWidget(chi_label)

        self.overall_chi_label = QLabel("N/A")
        self.overall_chi_label.setStyleSheet("font-weight: bold; color: #0066cc;")
        stats_layout.addWidget(self.overall_chi_label)

        stats_group.setLayout(stats_layout)
        layout.addWidget(stats_group)

    def add_preview_section(self, layout):
        """Add decrypted text preview section"""
        preview_group = QGroupBox("✅ Decrypted Text Preview")
        preview_group.setStyleSheet(
            """
            QGroupBox {
                font-weight: bold;
                border: 2px solid #4CAF50;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 10px;
            }
            QGroupBox::title {
                color: #4CAF50;
            }
        """
        )

        preview_layout = QVBoxLayout()

        help_label = QLabel(
            "The decrypted text appears below. Adjust the key shifts until readable text appears:"
        )
        help_label.setStyleSheet("font-style: italic; color: #666;")
        preview_layout.addWidget(help_label)

        self.previewtextbox = QTextEdit()
        self.previewtextbox.setReadOnly(True)
        self.previewtextbox.setPlaceholderText("Decrypted text will appear here...")
        self.previewtextbox.setStyleSheet(
            """
            QTextEdit {
                font-family: 'Courier New', monospace;
                font-size: 11pt;
                background-color: #e8f5e9;
            }
        """
        )
        preview_layout.addWidget(self.previewtextbox)

        # Add copy button
        copy_button = QPushButton("📋 Copy Decrypted Text")
        copy_button.clicked.connect(self.copy_preview)
        copy_button.setToolTip("Copy the decrypted text to clipboard")
        preview_layout.addWidget(copy_button)

        preview_group.setLayout(preview_layout)
        layout.addWidget(preview_group)

    def copy_preview(self):
        """Copy decrypted text to clipboard"""
        clipboard = QApplication.clipboard()
        clipboard.setText(self.decode(include_forgein=False))

        # Show confirmation
        QMessageBox.information(self, "Copied", "Decrypted text copied to clipboard!")

    def cipherTextChanged(self):
        # Update character count
        text = self.ciphertextbox.toPlainText()
        cipher_alpha = self.cipheralphabettextbox.text()
        alpha_chars = sum(1 for c in text if c in cipher_alpha)
        self.char_count_label.setText(
            f"Characters: {len(text)} (Alphabet chars: {alpha_chars})"
        )

        self.changePreview()
        if self.substringd:
            self.substringd.plot()
        if self.friedmanw:
            self.friedmanw.plot()
        if self.frequencyw:
            self.frequencyw.plot()

    def changeCipherLabel(self):
        self.ciphertextlabel.setText(self.cipheralphabettextbox.text())
        self.changePreview()
        if self.friedmanw:
            self.friedmanw.plot()

    def changePlainLabel(self):
        text = self.plainalphabettextbox.text()
        for i, w in enumerate(self.alphabets):
            w.setAlphabet(text)
        self.changePreview()

    def changeNumberAlphabets(self):
        new = int(self.number_alphabets.currentText())
        text = self.plainalphabettextbox.text()

        while new > len(self.alphabets):
            w = AlphabetSlider(text, self, len(self.alphabets))
            self.alphabets.append(w)
            self.alphabet_widget_layout.addWidget(w)

        while new < len(self.alphabets):
            self.alphabet_widget_layout.removeWidget(self.alphabets[-1])
            self.alphabets[-1].deleteLater()
            self.alphabets.remove(self.alphabets[-1])

        if self.frequencyw:
            self.frequencyw.lengthbox.setCurrentText(
                self.number_alphabets.currentText()
            )

        if self.chiw:
            self.chiw.lengthbox.setCurrentText(self.number_alphabets.currentText())

        self.changePreview()

    def decode(self, include_forgein=True):
        ciphertext = self.ciphertextbox.toPlainText()
        cipher_alpha = self.cipheralphabettextbox.text()

        out = ""
        i = 0
        for c in ciphertext:
            if c in cipher_alpha:
                d = cipher_alpha.index(c)
                out += self.alphabets[i % len(self.alphabets)].alphabet[d]
                i += 1
            else:
                if include_forgein:
                    out += c
        return out

    def changePreview(self):
        out = self.decode()

        alpha = self.cipheralphabettextbox.text()
        try:
            ic_value = Friedman.IC(out, alpha)
            self.overall_IC_label.setText(f"{ic_value:.4f}")
        except:
            self.overall_IC_label.setText("N/A")

        if self.chiw:
            try:
                chi_value = self.chiw.current_chi_value()
                self.overall_chi_label.setText(f"{chi_value:.2f}")
            except:
                self.overall_chi_label.setText("N/A")

        # Format preview text in columns
        length = len(self.alphabets)
        formatted_lines = []
        for i in range(0, len(out), length * 10):  # 10 groups per line
            line_chunk = out[i : i + length * 10]
            groups = [
                line_chunk[j : j + length] for j in range(0, len(line_chunk), length)
            ]
            formatted_lines.append("  ".join(groups))

        self.previewtextbox.setText("\n".join(formatted_lines))

    def launch_substringd(self):
        if not self.substringd:
            self.substringd = SubstringDistance(self)

        if not self.substringd.isVisible():
            self.substringd.show()

    def launch_friedman(self):
        if not self.friedmanw:
            self.friedmanw = Friedman(self)

        if not self.friedmanw.isVisible():
            self.friedmanw.show()

    def launch_frequency(self):
        if not self.frequencyw:
            self.frequencyw = Frequency(self)

        if not self.frequencyw.isVisible():
            self.frequencyw.show()

    def launch_chi(self):
        if not self.chiw:
            self.chiw = ChiSquare(self)

        if not self.chiw.isVisible():
            self.chiw.show()


if __name__ == "__main__":
    app = QApplication(sys.argv)

    # Set application-wide style
    app.setStyle("Fusion")

    main = VigenereWindow()
    main.show()

    sys.exit(app.exec_())