Частотный анализ

f(k) ≈ C / k^α

IC = Σᵢ₌₁ⁿ [fᵢ(fᵢ-1)] / [N(N-1)]

χ² = Σᵢ₌₁ⁿ (Oᵢ - Eᵢ)² / Eᵢ

АЛГОРИТМ FrequencyAttack(ciphertext):
1. frequencies = CountLetters(ciphertext)
2. sorted_freq = Sort(frequencies, descending=True)
3. russian_freq = ['О', 'Е', 'А', 'И', 'Н', 'Т', ...]
4. 
5. FOR each possible_shift in [0..32]:
6.     decrypted = CaesarDecrypt(ciphertext, possible_shift)
7.     score = CalculateScore(decrypted, russian_freq)
8.     IF score > best_score:
9.         best_shift = possible_shift
10.        best_text = decrypted
11.
12. RETURN best_text, best_shift

АЛГОРИТМ KasiskiMethod(ciphertext):
1. repeats = FindRepeats(ciphertext, min_length=3)
2. distances = []
3. FOR each repeat in repeats:
4.     FOR each pair of positions (p1, p2) in repeat:
5.         distances.append(p2 - p1)
6. 
7. common_factors = FindCommonFactors(distances)
8. key_length_candidates = common_factors
9. 
10. FOR each L in key_length_candidates:
11.     ic_score = CalculateAverageIC(ciphertext, L)
12.     IF ic_score > threshold:
13.         RETURN L

Зашифрованный текст:
ДФХСЦЦУГЩУЦФКУ ГЩДУДЪУЖКЦСУЦЪСЙ

def count_frequencies(text):
    freq = {}
    clean_text = ''.join(c.upper() for c in text if c.isalpha())
    
    for char in clean_text:
        freq[char] = freq.get(char, 0) + 1
    
    total = len(clean_text)
    return {char: count/total*100 for char, count in freq.items()}

def brute_force_caesar(ciphertext):
    best_score = 0
    best_shift = 0
    
    for shift in range(33):
        decrypted = caesar_decrypt(ciphertext, shift)
        score = calculate_russian_score(decrypted)
        
        if score > best_score:
            best_score = score
            best_shift = shift
    
    return caesar_decrypt(ciphertext, best_shift), best_shift

ЧОПЬЖЕМЫЕЧИЭЕГЩДЛВПДЯЙВЮЧБТЬМОЩФФЦБЛЛСЪВЙЩКНМЪЮРЫБ
ЕСНСУСКБЗФПФЮЩЗЭИЖТНЙИЬЩЮЪЩКДЪИОЦЩЩВЪЧУАГКНХНЫЙЯКО
ЪИРЙФКЛМЪЪЖЬТЬЬФЮЧЫЁЙФНЫЙЫЁЙЧЧСЙЮЧХМСУЙЮПВИНСЦЬТДМ
КПДЭЫЕЧЩПЦЫЮЮЧИАЧЦШУЫМЭУПЫЕЩНЭТЬШАЮЧБТНАИФЗИТЬЛЛСЪ
ВЙЩУПЫЮЮЛЦПНМЗЭЧНЫЬЧИЯРЦЬМЫФК

def find_repeats(text, min_length=3, max_length=5):
    repeats = {}
    text_length = len(text)
    
    for length in range(min_length, max_length + 1):
        for i in range(text_length - length + 1):
            fragment = text[i:i+length]
            
            if fragment not in repeats:
                repeats[fragment] = []
            repeats[fragment].append(i)
    
    # Оставляем только повторяющиеся
    return {frag: positions for frag, positions in repeats.items() 
            if len(positions) > 1}

def calculate_ic(text):
    frequencies = {}
    for char in text:
        frequencies[char] = frequencies.get(char, 0) + 1
    
    n = len(text)
    ic = sum(f * (f - 1) for f in frequencies.values()) / (n * (n - 1))
    return ic

def test_key_length(ciphertext, length):
    groups = [''] * length
    for i, char in enumerate(ciphertext):
        groups[i % length] += char
    
    average_ic = sum(calculate_ic(group) for group in groups) / length
    return average_ic

ЧЭЯОЩСГИЪЖСЫЭЭЫ...

ОФЙФФЮЩЩРЬЮЮУП...

def vigenere_decrypt(ciphertext, key):
    alphabet = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
    result = ''
    key_length = len(key)
    
    for i, char in enumerate(ciphertext):
        if char in alphabet:
            cipher_pos = alphabet.index(char)
            key_pos = alphabet.index(key[i % key_length])
            plain_pos = (cipher_pos - key_pos) % 33
            result += alphabet[plain_pos]
    
    return result

СОВРЕМЕННЫЕ КРИПТОГРАФИЧЕСКИЕ МЕТОДЫ ЗАЩИТЫ ИНФОРМАЦИИ 
ОСНОВАНЫ НА СЛОЖНЫХ МАТЕМАТИЧЕСКИХ АЛГОРИТМАХ КОТОРЫЕ 
ОБЕСПЕЧИВАЮТ КОНФИДЕНЦИАЛЬНОСТЬ И ЦЕЛОСТНОСТЬ ДАННЫХ 
ПРИ ПЕРЕДАЧЕ ПО СЕТЯМ И ХРАНЕНИИ В БАЗАХ ДАННЫХ

import re
from collections import Counter
import math

class FrequencyAnalyzer:
    
    # Эталонные частоты для русского языка
    RUSSIAN_FREQ = {
        'О': 10.97, 'Е': 8.45, 'А': 8.01, 'И': 7.35, 'Н': 6.70,
        'Т': 6.26, 'С': 5.53, 'Р': 4.97, 'В': 4.33, 'Л': 4.40,
        'К': 3.49, 'М': 3.21, 'Д': 2.98, 'П': 2.81, 'У': 2.62,
        # ... остальные буквы
    }
    
    RUSSIAN_IC = 0.0553
    ALPHABET = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
    
    def __init__(self):
        self.alphabet_size = len(self.ALPHABET)
    
    def clean_text(self, text):
        """Очистка текста: только русские буквы, верхний регистр"""
        return re.sub(r'[^А-ЯЁ]', '', text.upper())
    
    def calculate_frequencies(self, text):
        """Подсчет частот букв в процентах"""
        clean = self.clean_text(text)
        if not clean:
            return {}
        
        counter = Counter(clean)
        total = len(clean)
        return {char: (count / total) * 100 
                for char, count in counter.items()}
    
    def calculate_ic(self, text):
        """Вычисление индекса совпадений"""
        clean = self.clean_text(text)
        n = len(clean)
        if n <= 1:
            return 0
        
        counter = Counter(clean)
        ic = sum(count * (count - 1) 
                for count in counter.values()) / (n * (n - 1))
        return ic
    
    def chi_squared_score(self, observed_freq):
        """Хи-квадрат оценка похожести на русский язык"""
        score = 0
        for char in self.ALPHABET:
            observed = observed_freq.get(char, 0)
            expected = self.RUSSIAN_FREQ.get(char, 0.1)
            score += (observed - expected) ** 2 / expected
        return score
    
    def break_caesar(self, ciphertext):
        """Взлом шифра Цезаря"""
        clean_cipher = self.clean_text(ciphertext)
        best_score = float('inf')
        best_shift = 0
        best_text = ""
        
        for shift in range(self.alphabet_size):
            # Расшифровка с текущим сдвигом
            decrypted = self._caesar_decrypt(clean_cipher, shift)
            
            # Оценка качества расшифровки
            freq = self.calculate_frequencies(decrypted)
            score = self.chi_squared_score(freq)
            
            if score < best_score:
                best_score = score
                best_shift = shift
                best_text = decrypted
        
        return {
            'text': best_text,
            'shift': best_shift,
            'score': best_score,
            'key': self.ALPHABET[best_shift]
        }
    
    def _caesar_decrypt(self, text, shift):
        """Расшифровка Цезаря с заданным сдвигом"""
        result = ""
        for char in text:
            old_pos = self.ALPHABET.index(char)
            new_pos = (old_pos - shift) % self.alphabet_size
            result += self.ALPHABET[new_pos]
        return result
    
    def find_key_length_kasiski(self, ciphertext, min_repeat=3):
        """Поиск длины ключа методом Касиски"""
        clean = self.clean_text(ciphertext)
        repeats = {}
        
        # Поиск повторяющихся фрагментов
        for length in range(min_repeat, min(len(clean)//2, 8)):
            for i in range(len(clean) - length):
                fragment = clean[i:i+length]
                if fragment not in repeats:
                    repeats[fragment] = []
                repeats[fragment].append(i)
        
        # Анализ расстояний между повторами
        distances = []
        for fragment, positions in repeats.items():
            if len(positions) > 1:
                for i in range(len(positions)-1):
                    distance = positions[i+1] - positions[i]
                    distances.append(distance)
        
        if not distances:
            return []
        
        # Поиск общих делителей
        factors = set()
        for distance in distances:
            factors.update(self._get_factors(distance))
        
        # Фильтрация разумных длин ключа
        return sorted([f for f in factors if 2 <= f <= 20])
    
    def _get_factors(self, n):
        """Получение всех делителей числа"""
        factors = []
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                factors.extend([i, n // i])
        return list(set(factors))
    
    def test_key_length_ic(self, ciphertext, length):
        """Тест длины ключа по индексу совпадений"""
        clean = self.clean_text(ciphertext)
        groups = [''] * length
        
        for i, char in enumerate(clean):
            groups[i % length] += char
        
        average_ic = sum(self.calculate_ic(group) 
                        for group in groups) / length
        return average_ic
    
    def break_vigenere(self, ciphertext):
        """Полный взлом шифра Виженера"""
        # Этап 1: Поиск длины ключа
        candidates = self.find_key_length_kasiski(ciphertext)
        
        if not candidates:
            candidates = range(2, 21)  # Перебор по умолчанию
        
        # Тестирование кандидатов по IC
        best_length = 0
        best_ic = 0
        
        for length in candidates:
            ic = self.test_key_length_ic(ciphertext, length)
            if ic > best_ic and ic > 0.045:  # Порог для русского
                best_ic = ic
                best_length = length
        
        if best_length == 0:
            return None
        
        # Этап 2: Восстановление ключа
        clean = self.clean_text(ciphertext)
        key = ""
        
        for i in range(best_length):
            # Группа символов для i-й позиции ключа
            group = clean[i::best_length]
            
            # Взлом группы как шифра Цезаря
            result = self.break_caesar(group)
            key += self.ALPHABET[result['shift']]
        
        # Этап 3: Расшифровка полного текста
        decrypted = self._vigenere_decrypt(clean, key)
        
        return {
            'text': decrypted,
            'key': key,
            'key_length': best_length,
            'ic': best_ic
        }
    
    def _vigenere_decrypt(self, text, key):
        """Расшифровка Виженера"""
        result = ""
        key_length = len(key)
        
        for i, char in enumerate(text):
            char_pos = self.ALPHABET.index(char)
            key_pos = self.ALPHABET.index(key[i % key_length])
            decrypted_pos = (char_pos - key_pos) % self.alphabet_size
            result += self.ALPHABET[decrypted_pos]
        
        return result

# Пример использования
if __name__ == "__main__":
    analyzer = FrequencyAnalyzer()
    
    # Тест на шифре Цезаря
    caesar_cipher = "ДФХСЦЦУГЩУЦФКУ ГЩДУДЪУЖКЦСУЦЪСЙ"
    result = analyzer.break_caesar(caesar_cipher)
    print(f"Цезарь взломан: {result['text']}")
    print(f"Ключ: {result['key']} (сдвиг {result['shift']})")
    
    # Тест на шифре Виженера
    vigenere_cipher = """ЧОПЬЖЕМЫЕЧИЭЕГЩДЛВПДЯЙВЮЧБТЬМОЩФФЦБЛЛСЪВ
                        ЙЩКНМЪЮРЫБЕСНСУСКБЗФПФЮЩЗЭИЖТНЙИЬЩЮЪЩКДЪ
                        ИОЦЩЩВЪЧУАГКНХНЫЙЯКОЪИРЙФКЛМЪЪЖЬТЬЬФЮЧЫЁ
                        ЙФНЫЙЫЁЙЧЧСЙЮЧХМСУЙЮПВИНСЦЬТДМКПДЭЫЕЧЩПЦ
                        ЫЮЮЧИАЧЦШУЫМЭУПЫЕЩНЭТЬШАЮЧБТНАИФЗИТЬЛЛСЪ
                        ВЙЩУПЫЮЮЛЦПНМЗЭЧНЫЬЧИЯРЦЬМЫФК"""
    
    result = analyzer.break_vigenere(vigenere_cipher)
    if result:
        print(f"Виженер взломан!")
        print(f"Ключ: {result['key']}")
        print(f"Длина ключа: {result['key_length']}")
        print(f"Текст: {result['text'][:100]}...")

import matplotlib.pyplot as plt
import numpy as np

class CryptographyVisualizer:
    
    def __init__(self, analyzer):
        self.analyzer = analyzer
        plt.rcParams['font.family'] = ['DejaVu Sans']
    
    def plot_frequency_comparison(self, text, title="Частотный анализ"):
        """Сравнение частот текста с эталонными"""
        frequencies = self.analyzer.calculate_frequencies(text)
        
        # Подготовка данных
        letters = list(self.analyzer.ALPHABET)
        observed = [frequencies.get(letter, 0) for letter in letters]
        expected = [self.analyzer.RUSSIAN_FREQ.get(letter, 0) 
                   for letter in letters]
        
        x = np.arange(len(letters))
        width = 0.35
        
        fig, ax = plt.subplots(figsize=(15, 8))
        bars1 = ax.bar(x - width/2, observed, width, 
                      label='Наблюдаемые', alpha=0.8, color='steelblue')
        bars2 = ax.bar(x + width/2, expected, width, 
                      label='Эталонные (русский)', alpha=0.8, color='coral')
        
        ax.set_xlabel('Буквы')
        ax.set_ylabel('Частота (%)')
        ax.set_title(title)
        ax.set_xticks(x)
        ax.set_xticklabels(letters)
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        plt.xticks(rotation=0)
        plt.tight_layout()
        plt.show()
    
    def plot_ic_analysis(self, ciphertext, max_length=20):
        """График индекса совпадений для разных длин ключа"""
        lengths = list(range(1, max_length + 1))
        ic_values = [self.analyzer.test_key_length_ic(ciphertext, l) 
                    for l in lengths]
        
        plt.figure(figsize=(12, 6))
        plt.plot(lengths, ic_values, 'bo-', linewidth=2, markersize=8)
        plt.axhline(y=self.analyzer.RUSSIAN_IC, color='red', 
                   linestyle='--', label=f'Эталон (русский): {self.analyzer.RUSSIAN_IC}')
        plt.axhline(y=1/33, color='gray', linestyle=':', 
                   label='Случайный текст: 0.030')
        
        plt.xlabel('Длина ключа')
        plt.ylabel('Индекс совпадений')
        plt.title('Определение длины ключа по индексу совпадений')
        plt.legend()
        plt.grid(True, alpha=0.3)
        plt.show()
        
        # Возврат наиболее вероятной длины
        best_length = lengths[np.argmax(ic_values)]
        return best_length
    
    def plot_caesar_bruteforce(self, ciphertext):
        """Визуализация перебора всех сдвигов для Цезаря"""
        clean = self.analyzer.clean_text(ciphertext)
        shifts = list(range(33))
        scores = []
        
        for shift in shifts:
            decrypted = self.analyzer._caesar_decrypt(clean, shift)
            freq = self.analyzer.calculate_frequencies(decrypted)
            score = self.analyzer.chi_squared_score(freq)
            scores.append(score)
        
        plt.figure(figsize=(12, 6))
        plt.plot(shifts, scores, 'ro-', linewidth=2, markersize=6)
        
        best_shift = shifts[np.argmin(scores)]
        plt.axvline(x=best_shift, color='green', linestyle='--', 
                   label=f'Лучший сдвиг: {best_shift}')
        
        plt.xlabel('Сдвиг')
        plt.ylabel('Хи-квадрат оценка (меньше = лучше)')
        plt.title('Поиск оптимального сдвига для шифра Цезаря')
        plt.legend()
        plt.grid(True, alpha=0.3)
        plt.show()
        
        return best_shift

H(X) = -Σ p(x) log₂ p(x)

ЩМЗЖЗЖМЛТЗМЪЩЖЗЩЖТЗЗЩМЪЛЩМТЗЛЩМЪМЩЖМЪЛТЗМЪМТ

ЯЮНЩЖФЦОФЖЮУЗЖОГНЧЛФЦЩЧЖНЦТЛХЫНЦЖФЙЖОЧЪЖЦХН
ТЛФЙЧЛФЦЗЛЩКГНЧОЪЦХНФЙЧЖУЫЩКЖФЩЧЖФЙЖЪЮЖБХ

новый_ключ = f(старый_ключ, позиция_в_тексте)

ЕЛЛПЦФЗЖЩУРЪОЪЛФЙЮШЭЬЙЯЧЁЦЩЖЗГЙЮЩШЖОЪТЦШЭЖ

ЖЕЧЕЫПЕ СЛШЕЧЛУЕ ТЕДУГЧМЧ

МЮТЪЖЧНУСЛЧЖГЧНТЛФЩЖУРЪОХЭНУСЛБТЧЖГЧЖТЗЩБТЧЖ
ЖГЧЖТЗЧЖУРЪОЪЖЭНЦЮЛЦЖЧЖГЧЖТЗНЬЗЮЛЦЖЧЖГЧЖТЗ

pip install matplotlib numpy scipy cryptography