LIBREOFFICE BASE: Открытие баз данных - Полное руководство 2026

Пуск > LibreOffice > LibreOffice Base

sudo apt-get update

sudo apt-get install libreoffice-base



<h2 id="s-dopolnitelnymi-komponentami">С дополнительными компонентами</h2>

sudo apt-get install libreoffice-base libreoffice-java-common

<h2 id="fedora">Fedora</h2>

sudo dnf install libreoffice-base



<h2 id="centos-rhel">CentOS/RHEL</h2>

sudo yum install libreoffice-base

libreoffice --version

<h2 id="ispolzuya-homebrew">Используя Homebrew</h2>

brew install --cask libreoffice



<h2 id="ili-skachayte-s-ofitsialnogo-sayta">Или скачайте с официального сайта</h2>

> Справка > О программе > Информация

<h2 id="skachayte-oracle-jre-ili-openjdk">Скачайте Oracle JRE или OpenJDK</h2>

<h2 id="dobavte-v-path">Добавьте в PATH</h2>




<h2 id="proverka">Проверка:</h2>

java -version

<h2 id="sozdayte-otdelnuyu-papku-dlya-baz-dannyh-rassledovaniy">Создайте отдельную папку для баз данных расследований</h2>

mkdir C:\Forensics\Cases

mkdir C:\Forensics\Temp



<h2 id="v-libreoffice-base">В LibreOffice Base:</h2>

<h2 id="servis-parametry-puti-moi-dokumenty">Сервис &gt; Параметры &gt; Пути &gt; Мои документы</h2>

<h2 id="ukazhite-put-k-papke-rassledovaniy">Укажите путь к папке расследований</h2>

Файл > Создать > База данных

Тип: "Создать новую базу данных"

[Далее]

Сохранить базу данных: [ОК]

База данных

├── Таблицы (Tables)

├── Запросы (Queries)

├── Формы (Forms)

├── Отчеты (Reports)

└── Макросы (Macros)

Файл > Открыть > выберите database.odb

Файл > Новый > База данных

Тип: "Подключиться к существующей базе данных"

Выберите тип:

- MySQL

- PostgreSQL

- Oracle JDBC

- MS Access

Тип: MySQL (native)

Host: localhost

Port: 3306

Database: forensics_db

Username: forensics_user

Password: *******

Таблицы > [ПКМ] > Создать таблицу в режиме мастера

Источник данных: Текстовый файл

[Далее]

Выберите файл > Открыть

Настройте разделители и кодировку

[Далее]

Назначьте типы данных для полей

[Создать]

Таблицы > [ПКМ] > Создать таблицу в режиме мастера

Источник: Список Microsoft Excel

[Далее]

Выберите файл и лист

[Создать]

Файл > Новый > База данных

Тип: "Подключиться к существующей базе данных"

Тип: SQLite

Файл: выберите *.db файл

[Далее]

Сохранить базу данных: [ОК]

<h2 id="ustanovite-sqlite-odbc-drayver">Установите SQLite ODBC драйвер</h2>

<h2 id="windows-sqliteodbc-exe">Windows: sqliteodbc.exe</h2>

<h2 id="linux-sudo-apt-get-install-libsqliteodbc">Linux: sudo apt-get install libsqliteodbc</h2>




<h2 id="v-libreoffice-base">В LibreOffice Base:</h2>

<h2 id="servis-parametry-libreoffice-podklyucheniya">Сервис &gt; Параметры &gt; LibreOffice &gt; Подключения</h2>

<h2 id="dobavte-sqlite-istochnik-dannyh">Добавьте SQLite источник данных</h2>

Файл > Открыть > Выберите *.mdb или *.accdb



<h2 id="esli-ne-otkryvaetsya">Если не открывается:</h2>

<h2 id="ustanovite-microsoft-access-database-engine">Установите Microsoft Access Database Engine</h2>

Файл > Открыть > Access файл

Файл > Экспортировать базу данных > ODB формат

Файл > Новый > База данных

Тип: MySQL (native)



Параметры подключения:

Host name: 192.168.1.100

Port: 3306

Database name: forensics_db

User name: forensics_user



[Проверить подключение]

[Далее]

Сохранить базу: [ОК]

Тип: PostgreSQL (native)

Host: localhost

Port: 5432

Database: forensics_db

Username: postgres

Password: *******

timestamp,ip_address,user,action,status

2026-01-15 10:23:45,192.168.1.100,admin,login,success

2026-01-15 10:24:12,192.168.1.101,user,login,failed

2026-01-15 10:25:33,192.168.1.100,admin,logout,success

Таблицы > Создать таблицу в режиме мастера

Источник: Текстовый файл

Файл: logs.csv



Настройки:

- Разделитель: Запятая

- Кодировка: UTF-8

- Первая строка содержит заголовки



Предпросмотр и назначение типов:

- timestamp → VARCHAR

- ip_address → VARCHAR

- user → VARCHAR

- action → VARCHAR

- status → VARCHAR



[Создать]

<h2 id="json-to-csv-py">json_to_csv.py</h2>

import json

import csv



with open('data.json', 'r') as f:

    data = json.load(f)



with open('data.csv', 'w', newline='') as f:

    writer = csv.DictWriter(f, fieldnames=data[0].keys())

    writer.writeheader()

    writer.writerows(data)

#!/usr/bin/env python3

<h2 id="batch-import-py">batch_import.py</h2>




import os

import subprocess

import uno



def connect_to_base():

    """Подключение к LibreOffice Base через UNO"""

    local_context = uno.getComponentContext()

    resolver = local_context.ServiceManager.createInstance(

        "com.sun.star.bridge.UnoUrlResolver")

    ctx = resolver.resolve("uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")

    service_manager = ctx.getServiceManager()

    return service_manager



def import_csv_to_table(csv_file, table_name):

    """Импорт CSV файла в таблицу"""

    base_connection = connect_to_base()

    # Импортируем CSV в таблицу

    print(f"Importing {csv_file} to {table_name}")



def main():

    csv_files = [f for f in os.listdir('.') if f.endswith('.csv')]

    

    for csv_file in csv_files:

        table_name = csv_file.replace('.csv', '')

        import_csv_to_table(csv_file, table_name)

        print(f"Imported {csv_file}")



if __name__ == '__main__':

    main()

Сервис > SQL > выполните:



DESCRIBE table_name;



<h2 id="ili">или</h2>




SHOW COLUMNS FROM table_name;

редактор:



SELECT 

    tc.constraint_name,

    tc.table_name,

    kcu.column_name,

    ccu.table_name AS foreign_table_name

FROM information_schema.table_constraints AS tc

JOIN information_schema.key_column_usage AS kcu

    ON tc.constraint_name = kcu.constraint_name

JOIN information_schema.constraint_column_usage AS ccu

    ON ccu.constraint_name = tc.constraint_name

WHERE tc.constraint_type = 'FOREIGN KEY';

Инструменты > Показывать связь

Выберите таблицы и связи

Таблицы > [Введите имя в поле поиска]

SELECT table_name, column_name

FROM information_schema.columns

WHERE column_name LIKE '%username%';

SELECT 

    index_name,

    column_name,

    non_unique

FROM information_schema.statistics

WHERE table_name = 'users';

CREATE INDEX idx_timestamp ON logs(timestamp);

CREATE INDEX idx_ip ON logs(ip_address);

SELECT 

    table_name,

    table_rows AS approximate_rows,

    ROUND((data_length + index_length) / 1024 / 1024, 2) AS size_mb

FROM information_schema.tables

WHERE table_schema = 'forensics_db'

ORDER BY (data_length + index_length) DESC;

SELECT 

    COUNT(*) as total_records,

    COUNT(DISTINCT ip_address) as unique_ips,

    MIN(timestamp) as first_record,

    MAX(timestamp) as last_record

FROM logs;

-- Выбрать все записи

SELECT * FROM users;



-- Выбрать конкретные поля

SELECT username, email FROM users;



-- Выбрать первые 10 записей

SELECT * FROM users LIMIT 10;

-- Фильтр по значению

SELECT * FROM logs WHERE ip_address = '192.168.1.100';



-- Фильтр по дате

SELECT * FROM logs 

WHERE timestamp >= '2026-01-15' 

AND timestamp < '2026-01-16';



-- Несколько условий

SELECT * FROM logs 

WHERE status = 'failed' 

AND ip_address LIKE '192.168.1.%';

Таблицы: logs

Поля: timestamp, ip_address, user, status

Условие: status = 'failed'

Сортировка: timestamp DESC

-- Выборка пользователей с их логинами

SELECT 

    u.username,

    l.timestamp,

    l.ip_address,

    l.status

FROM users u

INNER JOIN logs l ON u.user_id = l.user_id

WHERE l.status = 'failed'

ORDER BY l.timestamp DESC;

-- Количество попыток входа по IP

SELECT 

    ip_address,

    COUNT(*) as login_attempts,

    SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful

FROM logs

GROUP BY ip_address

HAVING login_attempts > 10

ORDER BY login_attempts DESC;

-- IP адреса с множественными неудачными попытки

SELECT 

    ip_address,

    COUNT(*) as failed_logins,

    MIN(timestamp) as first_attempt,

    MAX(timestamp) as last_attempt

FROM logs

WHERE status = 'failed'

GROUP BY ip_address

HAVING failed_logins >= 5

ORDER BY failed_logins DESC;

SELECT DISTINCT ip_address

FROM logs

WHERE timestamp >= CURRENT_TIMESTAMP - INTERVAL '24' HOUR

AND ip_address IN (

    SELECT ip_address

    FROM logs

    WHERE status = 'failed'

    GROUP BY ip_address

    HAVING COUNT(*) > 5

)

ORDER BY ip_address;

-- IP адреса из определенной подсети

SELECT * FROM logs

WHERE ip_address LIKE '10.10.%.%';



-- Поиск пользователей с определенным паттерном в имени

SELECT * FROM users

WHERE username LIKE 'admin%';



-- Email адреса от определенного домена

SELECT * FROM users

WHERE email LIKE '%@example.com';

-- Email валидация

SELECT * FROM users

WHERE email REGEXP '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$';

import uno

from com.sun.star.sdbc import XResultSet



def export_query_to_csv(query_result, filename):

    """Экспорт результатов запроса в CSV"""

    with open(filename, 'w') as f:

        # Записи заголовка

        # ...



        # Записи данных

        while query_result.next():

            # ...

            pass

-- Стандартное удаление

DELETE FROM users WHERE user_id = 123;



-- Физически запись не удаляется,

-- из сектора данных базы

<h2 id="izvlechenie-dannyh-iz-sqlite-wal">Извлечение данных из SQLite WAL</h2>

sqlite3 database.db ".dump" > backup.sql



<h2 id="poisk-udalennyh-zapisey">Поиск удаленных записей</h2>

grep -i "DELETE\|DROP\|TRUNCATE" backup.sql

<h2 id="extract-from-backup-py">extract_from_backup.py</h2>

import sqlite3



def extract_deleted_records(backup_file, original_db):

    """Сравнение backup и текущей базы для поиска удаленных записей"""

    

    # Подключение к backup

    backup_conn = sqlite3.connect(backup_file)

    backup_cur = backup_conn.cursor()

    backup_cur.execute("SELECT * FROM users")

    backup_records = set(backup_cur.fetchall())

    

    # Подключение к текущей базе

    current_conn = sqlite3.connect(original_db)

    current_cur = current_conn.cursor()

    current_cur.execute("SELECT * FROM users")

    current_records = set(current_cur.fetchall())

    

    # Найти удаленные записи

    deleted = backup_records - current_records

    

    return deleted



<h2 id="ispolzovanie">Использование</h2>

deleted_users = extract_deleted_records('backup.db', 'current.db')

for user in deleted_users:

    print(f"Deleted: {user}")

<h2 id="izvlechenie-neraspredelennogo-prostranstva-sqlite">Извлечение нераспределенного пространства SQLite</h2>

python3 hexdump -C database.db | grep -A 10 "deleted"



<h2 id="ispolzuya-sqlite3">Используя sqlite3</h2>

sqlite3 database.db ".mode hex" ".dump"

<h2 id="ischite-udalennye-dannye-v-hex-dump">Ищите удаленные данные в hex dump</h2>

-- SQLite имеет встроенную команду восстановления

sqlite3 corrupt.db ".recover" > recovered.sql



<h2 id="zatem-importiruyte-v-novuyu-bazu">Затем импортируйте в новую базу</h2>

sqlite3 new.db < recovered.sql

#!/usr/bin/env python3

<h2 id="find-deleted-records-py">find_deleted_records.py</h2>




import sqlite3

import re

from datetime import datetime



def find_deleted_strings(db_file):

    """Поиск удаленных строк в базе данных"""

    

    conn = sqlite3.connect(db_file)

    cursor = conn.cursor()

    

    # Читаем необработанные данные из базы

    with open(db_file, 'rb') as f:

        raw_data = f.read()

    

    # Ищем потенциальные удаленные данные

    # Паттерн для email

    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

    emails = re.findall(email_pattern, raw_data.decode('utf-8', errors='ignore'))

    

    # Паттерн для username

    username_pattern = r'\buser[a-z0-9_]{3,}\b'

    usernames = re.findall(username_pattern, raw_data.decode('utf-8', errors='ignore'))

    

    return {

        'emails': set(emails),

        'usernames': set(usernames)

    }



<h2 id="ispolzovanie">Использование</h2>

results = find_deleted_strings('suspicious.db')

print("Found deleted emails:", results['emails'])

print("Found deleted usernames:", results['usernames'])

<h2 id="detect-encryption-py">detect_encryption.py</h2>

import hashlib



def detect_encryption(db_file):

    """Определение типа шифрования"""

    

    with open(db_file, 'rb') as f:

        header = f.read(16)

    

    # Проверка магических байтов

    if header.startswith(b'SQLite'):

        return "Not encrypted"

    elif header.startswith(b'\x00\x00\x00'):  # Возможный шифр

        return "Possibly encrypted"

    else:

        return "Unknown format"



<h2 id="proverka-tselostnosti">Проверка целостности</h2>

def check_integrity(db_file):

    """Проверка целостности зашифрованного файла"""

    with open(db_file, 'rb') as f:

        data = f.read()

    

    # Проверка на известные алгоритмы

    # AES-CBC, AES-GCM, ChaCha20

    return detect_algorithm(data)

<h2 id="find-keys-py">find_keys.py</h2>

import re

import sqlite3



def find_keys_in_app_files(app_directory):

    """Поиск ключей в файлах приложения"""

    

    potential_keys = []

    

    # Поиск в config файлах

    for root, dirs, files in os.walk(app_directory):

        for file in files:

            if file.endswith(('.xml', '.json', '.plist', '.properties')):

                path = os.path.join(root, file)

                try:

                    with open(path, 'r') as f:

                        content = f.read()

                        

                        # Поиск ключей

                        keys = re.findall(r'(?:key|password|secret)=([A-Za-z0-9]{16,})', content, re.IGNORECASE)

                        potential_keys.extend(keys)

                except:

                    pass

    

    return potential_keys

<h2 id="sqlcipher-populyarnaya-biblioteka-shifrovaniya-dlya-sqlite">SQLCipher - популярная библиотека шифрования для SQLite</h2>




<h2 id="popytka-otkrytiya-s-parolem">Попытка открытия с паролем</h2>

sqlcipher database.db

<h2 id="sqlcipher-pragma-key-password">SQLCipher &gt; PRAGMA key = &#039;password&#039;;</h2>




<h2 id="avtomaticheskiy-podbor-parolya">Автоматический подбор пароля</h2>

sqlite3key brute_force.py database.db

<h2 id="poisk-v-dekompilirovannom-kode">Поиск в декомпилированном коде</h2>

<h2 id="stroki-v-mainactivity-smali">Строки в MainActivity.smali</h2>




const-string v0, "database_password"

const-string v0, "encryption_key"



<h2 id="naydite-i-izvlekite-klyuch">Найдите и извлеките ключ</h2>

// Поиск в исходниках

let dbPassword = "secret123"

let encryptionKey = "AES128_KEY_HERE"



// Извлеките ключи

# Декриптируйте вне Base

   python3 decrypt.py encrypted.db decrypted.db



   # Затем откройте в Base

   libreoffice --base decrypted.db

<h2 id="analyze-encrypted-structure-py">analyze_encrypted_structure.py</h2>

import struct



def analyze_encrypted_db(db_file):

    """Анализ структуры зашифрованной базы"""

    

    with open(db_file, 'rb') as f:

        # Читаем header

        header = f.read(100)

        

        # SQLite header начинается с "SQLite format 3"

        # Если зашифрован, ищем другие признаки

        

        # Проверка на SQLCipher

        if header[0:16] == b'SQLite format 3\000':

            return "SQLite (possibly SQLCipher encrypted)"

        

        # Проверка на другие форматы

        # ...

    

    return "Unknown format"

Таблица > Файл > Экспорт

Формат: Текст CSV

Выберите разделитель: Запятая

Кодировка: UTF-8

[ОК]

Таблица > Файл > Экспорт

Формат: Microsoft Excel 2007-365 (.xlsx)

[ОК]

Таблица > Файл > Экспорт как PDF

Настройки:

- Размер страницы: A4

- Ориентация: Книжная

- Поля: Стандартные

[Экспорт]

Заголовок: Подозрительная IP активность

Группировка: По IP адресу

Поля: 

- IP адрес

- Количество попыток

- Первая попытка

- Последняя попытка

- Статус

Итоги: Общее количество попыток

. Введение

   - Описание инцидента

   - Цели анализа

   - Методология



2. База данных

   - Источник данных

   - Структура базы

   - Извлечение данных



3. Анализ

   - Обнаруженные паттерны

   - Подозрительная активность

   - Связи и корреляции



4. Результаты

   - Ключевые находки

   - Доказательства

   - Визуализации



5. Заключение

   - Выводы

   - Рекомендации

Файл > Создать > Текстовый документ



<h2 id="vstavka-dannyh-iz-base">Вставка данных из Base</h2>

Вставка > Объект > Таблица > Выберите запрос



<h2 id="avtomaticheskaya-generatsiya-otcheta">Автоматическая генерация отчета</h2>

Файл > Печать в файл > PDF

<h2 id="tsepochka-hraneniya-dokazatelstv-dlya-analiza-baz-dannyh">Цепочка хранения доказательств для анализа баз данных</h2>




<h2 id="1-izvlechenie-istochnika">1. Извлечение источника</h2>

- Дата и время: 2026-01-15 10:23:45

- Источник: smartphone_backup.db

- Метод извлечения: ADB pull

- Хэш SHA256: abc123...

- Сотрудник: John Doe



<h2 id="2-sozdanie-kopii">2. Создание копии</h2>

- Дата создания: 2026-01-15 10:25:00

- Имя файла: smartphone_backup_copy.db

- Хэш оригинал: abc123...

- Хэш копия: abc123... (проверено)

- Сотрудник: John Doe



<h2 id="3-analiz-v-libreoffice-base">3. Анализ в LibreOffice Base</h2>

- Дата начала: 2026-01-15 10:30:00

- Инструменты: LibreOffice Base 7.x

- Выполненные запросы: 15

- Экспортировано результатов: 5 файлов

- Логи работы: base_analysis.log



<h2 id="4-eksport-rezultatov">4. Экспорт результатов</h2>

- Таблица 1: contacts_export.csv

- Таблица 2: messages_export.csv

- Отчет: analysis_report.pdf

- Хэш экспорта: def456...

#!/usr/bin/env python3

<h2 id="generate-report-py">generate_report.py</h2>




from reportlab.lib.pagesizes import letter

from reportlab.lib.units import inch

from reportlab.pdfgen import canvas

import sqlite3

from datetime import datetime



def generate_report(db_file, output_pdf):

    """Генерация PDF отчета об анализе базы данных"""

    

    conn = sqlite3.connect(db_file)

    cursor = conn.cursor()

    

    # Создание PDF

    c = canvas.Canvas(output_pdf, pagesize=letter)

    

    # Заголовок

    c.setFont("Helvetica-Bold", 16)

    c.drawString(1*inch, 10*inch, "Database Analysis Report")

    

    c.setFont("Helvetica", 10)

    c.drawString(1*inch, 9.5*inch, f"Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    c.drawString(1*inch, 9*inch, f"Database: {db_file}")

    

    # Статистика

    c.setFont("Helvetica-Bold", 12)

    c.drawString(1*inch, 8*inch, "Database Statistics")

    

    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")

    tables = cursor.fetchall()

    

    y_position = 7.5*inch

    for table in tables:

        table_name = table[0]

        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")

        count = cursor.fetchone()[0]

        c.drawString(1.5*inch, y_position, f"{table_name}: {count} records")

        y_position -= 0.25*inch

    

    # Заключение

    c.setFont("Helvetica-Bold", 12)

    c.drawString(1*inch, y_position - 0.5*inch, "Analysis Conclusion")

    c.setFont("Helvetica", 10)

    c.drawString(1*inch, y_position - 0.75*inch, "Database analyzed successfully. All findings documented.")

    

    c.save()

    conn.close()



<h2 id="ispolzovanie">Использование</h2>

generate_report('suspicious.db', 'analysis_report.pdf')

> Данные > Импорт данных

Тип: База данных

Выберите подключение к базе

Выберите таблицу или запрос

[ОК]

> Данные > Сводная таблица

Источник данных: База данных

Выберите поля для анализа

[Создать]

Данные > Фильтр > Стандартный фильтр

Условия:

- IP адрес содержит "192.168.1."

- Дата между 2026-01-01 и 2026-01-31

[ОК]

> Вставка > Объект > Таблица

Выберите подключение и таблицу

Настройте форматирование

[ОК]

<h2 id="automate-report-py">automate_report.py</h2>

from uno import ConnectionException



def generate_document_from_base(query, template, output):

    """Создание документа из данных базы"""

    

    # Открыть шаблон

    doc = desktop.loadComponentFromURL(

        f"file:///{template}", "_blank", 0, ())

    

    # Выполнить запрос

    results = execute_query(query)

    

    # Вставить данные

    insert_data_into_template(doc, results)

    

    # Сохранить

    doc.storeAsURL(f"file:///{output}", ())

<h2 id="connect-base-py">connect_base.py</h2>

import uno

from com.sun.star.beans import PropertyValue



def connect_to_base_file(base_file):

    """Подключение к файлу базы данных через UNO"""

    

    localContext = uno.getComponentContext()

    resolver = localContext.ServiceManager.createInstance(

        "com.sun.star.bridge.UnoUrlResolver")

    

    # Подключение к LibreOffice

    ctx = resolver.resolve("uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")

    desktop = ctx.getServiceManager().createInstanceWithContext(

        "com.sun.star.frame.Desktop", ctx)

    

    # Открыть базу данных

    prop = PropertyValue("Hidden", 0, True, 0)

    doc = desktop.loadComponentFromURL(

        f"file:///{base_file}", "_blank", 0, (prop,))

    

    return doc



<h2 id="ispolzovanie">Использование</h2>

base_doc = connect_to_base_file('/path/to/database.odb')

> Экспорт > CSV

Импортировать CSV в Autopsy:

Autopsy > Data Sources > Add Data Source

Тип: CSV

Выберите CSV файл

Настроить колонки

[OK]

<h2 id="eksport-registratsionnyh-dannyh-dlya-volatility">Экспорт регистрационных данных для Volatility</h2>

<h2 id="iz-base-eksportiruyte-v-csv">Из Base экспортируйте в CSV</h2>

<h2 id="zatem-importiruyte-v-volatility">Затем импортируйте в Volatility</h2>




volatility -f memory.dump windows.registry.hivelist

volatility -f memory.dump windows.registry.printkey -o <extracted_key> | grep -i "password"

<h2 id="eksport-setevyh-logov-v-pcap-format">Экспорт сетевых логов в PCAP формат</h2>

<h2 id="1-iz-base-eksportiruyte-v-csv">1. Из Base экспортируйте в CSV</h2>

<h2 id="2-konvertiruyte-csv-v-pcap">2. Конвертируйте CSV в PCAP:</h2>

python csv_to_pcap.py network_logs.csv network_logs.pcap



<h2 id="3-otkroyte-v-wireshark">3. Откройте в Wireshark</h2>

wireshark network_logs.pcap

<h2 id="export-to-cloud-py">export_to_cloud.py</h2>

from pydrive.auth import GoogleAuth

from pydrive.drive import GoogleDrive



def upload_report_to_cloud(report_file):

    """Загрузка отчета в Google Drive"""

    

    gauth = GoogleAuth()

    gauth.LocalWebserverAuth()

    drive = GoogleDrive(gauth)

    

    file_drive = drive.CreateFile({'title': 'Analysis Report'})

    file_drive.SetContentFile(report_file)

    file_drive.Upload()

    

    print(f"Uploaded: {file_drive['alternateLink']}")



<h2 id="ispolzovanie">Использование</h2>

upload_report_to_cloud('analysis_report.pdf')

#!/bin/bash

<h2 id="daily-analysis-sh">daily_analysis.sh</h2>




DATABASE="/path/to/daily.db"

OUTPUT_DIR="/reports/$(date +%Y%m%d)"



<h2 id="sozdat-direktoriyu">Создать директорию</h2>

mkdir -p "$OUTPUT_DIR"



<h2 id="import-dannyh">Импорт данных</h2>

sqlite3 "$DATABASE" <<EOF

.import logs.csv logs

.quit

EOF



<h2 id="analiz-v-base-cherez-uno">Анализ в Base (через UNO)</h2>

python3 analyze_base.py "$DATABASE" "$OUTPUT_DIR"



<h2 id="sozdanie-otcheta">Создание отчета</h2>

python3 generate_report.py "$OUTPUT_DIR"



echo "Analysis complete: $OUTPUT_DIR"

-- Поиск аномальной активности в ночное время

SELECT 

    HOUR(timestamp) as hour,

    COUNT(*) as activity_count

FROM logs

WHERE timestamp >= DATE_SUB(NOW(), INTERVAL 7 DAY)

GROUP BY hour

HAVING activity_count > 100

ORDER BY activity_count DESC;



-- Пиковые часы активности

SELECT 

    HOUR(timestamp) as peak_hour,

    COUNT(*) as logins

FROM logs

WHERE action = 'login'

GROUP BY peak_hour

ORDER BY logins DESC

LIMIT 3;

-- Корреляция между IP адресами и пользователями

SELECT 

    l.ip_address,

    u.username,

    COUNT(*) as interaction_count

FROM logs l

INNER JOIN users u ON l.user_id = u.user_id

GROUP BY l.ip_address, u.username

HAVING interaction_count > 50

ORDER BY interaction_count DESC;

<h2 id="visualize-connections-py">visualize_connections.py</h2>

import networkx as nx

import matplotlib.pyplot as plt



def create_network_graph(db_file):

    """Создание графа связей из базы данных"""

    

    conn = sqlite3.connect(db_file)

    cursor = conn.cursor()

    

    # Получить связи

    cursor.execute("""

        SELECT ip_address, username, COUNT(*) as weight

        FROM logs l

        JOIN users u ON l.user_id = u.user_id

        GROUP BY ip_address, username

        HAVING weight > 10

    """)

    

    # Создать граф

    G = nx.Graph()

    

    for row in cursor.fetchall():

        ip, username, weight = row

        G.add_edge(ip, username, weight=weight)

    

    # Визуализация

    pos = nx.spring_layout(G)

    nx.draw(G, pos, with_labels=True, node_size=500, font_size=8)

    plt.savefig('network_graph.png')

    

    conn.close()



create_network_graph('forensics_db.db')

<h2 id="anomaly-detection-py">anomaly_detection.py</h2>

from sklearn.ensemble import IsolationForest

import pandas as pd



def detect_anomalies(db_file):

    """Детекция аномалий в логах"""

    

    # Загрузить данные

    conn = sqlite3.connect(db_file)

    df = pd.read_sql_query("SELECT * FROM logs", conn)

    

    # Подготовка данных

    features = df[['hour', 'day_of_week', 'ip_frequency', 'action_count']]

    

    # Обучение модели

    clf = IsolationForest(contamination=0.1)

    df['anomaly'] = clf.fit_predict(features)

    

    # Аномальные записи

    anomalies = df[df['anomaly'] == -1]

    

    # Сохранение результатов

    anomalies.to_csv('detected_anomalies.csv', index=False)

    

    return anomalies



anomalies = detect_anomalies('forensics_db.db')

print(f"Found {len(anomalies)} anomalies")

-- Поиск последовательностей действий

WITH ranked_logs AS (

    SELECT 

        timestamp,

        user_id,

        action,

        LAG(action) OVER (PARTITION BY user_id ORDER BY timestamp) as prev_action,

        LEAD(action) OVER (PARTITION BY user_id ORDER BY timestamp) as next_action

    FROM logs

)

SELECT 

    user_id,

    CONCAT(prev_action, ' -> ', action, ' -> ', next_action) as pattern,

    COUNT(*) as frequency

FROM ranked_logs

WHERE prev_action IS NOT NULL AND next_action IS NOT NULL

GROUP BY user_id, pattern

HAVING frequency > 5

ORDER BY frequency DESC;

<h2 id="geo-analysis-py">geo_analysis.py</h2>

import geopy.distance

from geopy.geocoders import Nominatim



def analyze_geographic_patterns(db_file):

    """Анализ географических паттернов"""

    

    conn = sqlite3.connect(db_file)

    

    # Получить IP адреса с локациями

    cursor = conn.cursor()

    cursor.execute("""

        SELECT ip_address, COUNT(*) as occurrences

        FROM logs

        GROUP BY ip_address

        ORDER BY occurrences DESC

    """)

    

    # Определить локации IP

    geolocator = Nominatim(user_agent="forensics_app")

    

    locations = {}

    for ip, count in cursor.fetchall():

        try:

            # Здесь нужен сервис для определения локации IP

            # например, ip-api.com или maxmind

            location = get_location_from_ip(ip)

            locations[ip] = location

        except:

            pass

    

    # Визуализация на карте

    # ... (использование folium или matplotlib)

    

    conn.close()



analyze_geographic_patterns('forensics_db.db')

#!/usr/bin/env python3

<h2 id="daily-monitoring-py">daily_monitoring.py</h2>




import sqlite3

from datetime import datetime, timedelta

import smtplib

from email.mime.text import MIMEText



def monitor_database(base_file):

    """Мониторинг базы данных на подозрительную активность"""

    

    conn = sqlite3.connect(base_file)

    cursor = conn.cursor()

    

    # Критерии аномалий

    yesterday = datetime.now() - timedelta(days=1)

    

    # Проверка 1: Неудачные попытки входа

    cursor.execute("""

        SELECT ip_address, COUNT(*) as failed_logins

        FROM logs

        WHERE status = 'failed'

        AND timestamp >= ?

        GROUP BY ip_address

        HAVING failed_logins > 10

    """, (yesterday,))

    

    failed_logins = cursor.fetchall()

    

    # Проверка 2: Необычная активность в ночное время

    cursor.execute("""

        SELECT ip_address, COUNT(*) as nighttime_activity

        FROM logs

        WHERE HOUR(timestamp) BETWEEN 0 AND 6

        AND timestamp >= ?

        GROUP BY ip_address

        HAVING nighttime_activity > 50

    """, (yesterday,))

    

    nighttime_activity = cursor.fetchall()

    

    # Проверка 3: Новые IP адреса

    cursor.execute("""

        SELECT DISTINCT ip_address

        FROM logs

        WHERE ip_address NOT IN (

            SELECT DISTINCT ip_address 

            FROM logs 

            WHERE timestamp < ?

        )

        AND timestamp >= ?

    """, (yesterday, yesterday))

    

    new_ips = cursor.fetchall()

    

    # Генерация отчета

    report = f"""

Daily Monitoring Report - {datetime.now().strftime('%Y-%m-%d')}



FAILED LOGIN ATTEMPTS (>10):

{failed_logins}



NIGHTTIME ACTIVITY (>50):

{nighttime_activity}



NEW IP ADDRESSES:

{new_ips}

"""

    

    # Отправка отчета

    if failed_logins or nighttime_activity or new_ips:

        send_alert(report)

    

    conn.close()



def send_alert(report):

    """Отправка уведомления"""

    msg = MIMEText(report)

    msg['Subject'] = 'Security Alert: Anomalous Database Activity'

    msg['From'] = 'forensics@example.com'

    msg['To'] = 'security@example.com'

    

    server = smtplib.SMTP('smtp.example.com')

    server.sendmail(msg['From'], msg['To'], msg.as_string())

    server.quit()



<h2 id="zapusk-monitoringa">Запуск мониторинга</h2>

monitor_database('monitoring.db')

<h2 id="batch-process-py">batch_process.py</h2>

import os

import sqlite3



def process_multiple_databases(base_dir, output_dir):

    """Обработка множества баз данных"""

    

    results = []

    

    for filename in os.listdir(base_dir):

        if filename.endswith(('.db', '.sqlite', '.sqlite3')):

            base_path = os.path.join(base_dir, filename)

            

            print(f"Processing {filename}...")

            

            # Анализ базы

            analysis = analyze_database(base_path)

            

            # Экспорт результатов

            export_results(base_path, analysis, output_dir)

            

            results.append({

                'file': filename,

                'analysis': analysis

            })

    

    # Сводный отчет

    generate_summary_report(results, output_dir)



def analyze_database(db_file):

    """Анализ одной базы данных"""

    

    conn = sqlite3.connect(db_file)

    cursor = conn.cursor()

    

    analysis = {

        'tables': [],

        'record_counts': {},

        'suspicious_patterns': []

    }

    

    # Получить список таблиц

    cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")

    tables = cursor.fetchall()

    

    for table in tables:

        table_name = table[0]

        analysis['tables'].append(table_name)

        

        # Подсчет записей

        cursor.execute(f"SELECT COUNT(*) FROM {table_name}")

        count = cursor.fetchone()[0]

        analysis['record_counts'][table_name] = count

        

        # Поиск подозрительных паттернов

        suspicious = find_suspicious_patterns(cursor, table_name)

        analysis['suspicious_patterns'].extend(suspicious)

    

    conn.close()

    return analysis



<h2 id="ispolzovanie">Использование</h2>

process_multiple_databases('/databases/', '/output/')

<h2 id="dashboard-py">dashboard.py</h2>

from flask import Flask, render_template_string

import sqlite3

from datetime import datetime



app = Flask(__name__)



@app.route('/dashboard')

def dashboard():

    """Дашборд для отображения статистики"""

    

    conn = sqlite3.connect('monitoring.db')

    cursor = conn.cursor()

    

    # Статистика за сегодня

    cursor.execute("""

        SELECT 

            COUNT(*) as total_logs,

            COUNT(DISTINCT ip_address) as unique_ips,

            SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_logins

        FROM logs

        WHERE DATE(timestamp) = DATE('now')

    """)

    

    stats = cursor.fetchone()

    

    # Топ IP адресов

    cursor.execute("""

        SELECT ip_address, COUNT(*) as count

        FROM logs

        WHERE DATE(timestamp) = DATE('now')

        GROUP BY ip_address

        ORDER BY count DESC

        LIMIT 10

    """)

    

    top_ips = cursor.fetchall()

    

    # График активности по часам

    cursor.execute("""

        SELECT HOUR(timestamp) as hour, COUNT(*) as count

        FROM logs

        WHERE DATE(timestamp) = DATE('now')

        GROUP BY hour

        ORDER BY hour

    """)

    

    hourly_data = cursor.fetchall()

    

    conn.close()

    

    template = '''

    <html>

        <head>

            <title>Forensics Dashboard</title>

        </head>

        <body>

            <h1>Database Monitoring Dashboard</h1>

            <h2>Today's Statistics</h2>

            <p>Total Logs: {{ stats[0] }}</p>

            <p>Unique IPs: {{ stats[1] }}</p>

            <p>Failed Logins: {{ stats[2] }}</p>

            

            <h2>Top IP Addresses</h2>

            <ul>

            {% for ip, count in top_ips %}

                <li>{{ ip }}: {{ count }}</li>

            {% endfor %}

            </ul>

        </body>

    </html>

    '''

    

    return render_template_string(template, stats=stats, top_ips=top_ips)



if __name__ == '__main__':

    app.run(debug=True, host='0.0.0.0', port=5000)

libreoffice --base users.db

.tables

.schema users

SELECT COUNT(*) FROM users;  -- 500,000 записей

-- Найти пользователей без шифрования паролей

SELECT username, email, password

FROM users

WHERE password NOT LIKE '$2y$%'  -- bcrypt хеш

LIMIT 10;

-- Поиск подозрительной активности

SELECT ip_address, COUNT(DISTINCT user_id) as affected_users

FROM access_logs

WHERE action = 'data_export'

GROUP BY ip_address

ORDER BY affected_users DESC;

> Файл > Открыть > Contacts2.db

SELECT 

    datetime(date/1000, 'unixepoch') as message_date,

    address,

    body

FROM sms

WHERE body LIKE '%keyword%'

ORDER BY date DESC;

-- Сообщения от сохраненных контактов

SELECT 

    c.display_name,

    s.address,

    COUNT(*) as message_count

FROM sms s

JOIN contacts c ON s.address = c.phone_number

GROUP BY c.display_name, s.address

ORDER BY message_count DESC;

-- Активность по часам

SELECT 

    HOUR(datetime(date/1000, 'unixepoch')) as hour,

    COUNT(*) as message_count

FROM sms

WHERE date >= (SELECT MIN(date) FROM sms)

GROUP BY hour

ORDER BY hour;