encrypth 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f9079e1bb667c0dc79fda0fd7e3997ab5529dd33cc62f6725ced36913d236868
+  data.tar.gz: 831220a4dbffbb5deac197e876f58ad77b6c4ce80dac9caeb501013b21ff86ff
+SHA512:
+  metadata.gz: 71f8b94819558abbc1fb261a5a77829e50fb4069f2514dd598200db81afd76667be3d11de6110be71c711d35ac15d8ccc29203d7d017824a535f34244313c728
+  data.tar.gz: b5bfa2ca6e5d919b52596a2cf4db15a8a9a76bdc1b0e5030dcefc81d6f0857f8de500d92eac701990656df232c1ef17b1aa70bda07800190f36ea629986f2661

data/README.md

@@ -0,0 +1,70 @@
+# Encrypth
+
+`Encrypth` — это простой Ruby gem для безопасного архивирования и шифрования файлов с помощью AES-256-GCM. Gem был создан в качестве учебного проекта, и в дальнейшем можно ожидать расширение функционала.
+
+## Что делает
+
+- создает зашифрованный tar-архив из файлов и директорий
+- использует надежный режим шифрования AES-256-GCM
+- генерирует ключ по паролю через PBKDF2-HMAC-SHA256
+- сохраняет соль отдельно в файле `archive.salt`
+- извлекает и расшифровывает содержимое обратно в указанную директорию
+
+## Установка
+
+```sh
+bundle install
+```
+
+## Использование CLI
+
+Синтаксис:
+
+```sh
+ruby lib/encrypth.rb <archive> <-e|-d> <...files|destination>
+```
+
+### Шифрование
+
+```sh
+ruby lib/encrypth.rb secret.enc -e file1.txt folder2 file3.jpg
+```
+
+- `secret.enc` — имя выходного зашифрованного архива
+- `-e` — флаг шифрования
+- перечислите файлы и/или директории для архивации
+- пароль вводится скрыто
+- создается файл соли `secret.enc.salt`
+
+### Дешифрование
+
+```sh
+ruby lib/encrypth.rb secret.enc -d output_folder
+```
+
+- `secret.enc` — существующий зашифрованный архив
+- `-d` — флаг дешифрования
+- `output_folder` — папка для извлечения файлов
+- если папка не указана, используется текущая директория
+
+## API
+
+`Encrypth` предоставляет базовый API для шифрования и дешифрования данных:
+
+- `Encrypth.generate_key` — создает случайный 32-байтовый ключ
+- `Encrypth.from_password(password, salt = nil)` — создает ключ из пароля и соли
+- `Encrypth.new(key).encrypt(data)` — шифрует строку
+- `Encrypth.new(key).decrypt(encrypted_string)` — расшифровывает строку
+
+## Структура проекта
+
+- `lib/encrypth.rb` — точка входа
+- `lib/encrypth/cli.rb` — CLI-интерфейс
+- `lib/encrypth/cipher.rb` — шифрование AES-256-GCM и PBKDF2
+- `lib/encrypth/archiver.rb` — создание и извлечение tar-архива
+- `demo/encrypthdemo.rb` — демонстрация базового шифрования
+- `test/encrypth_test.rb` — набор тестов на Minitest
+
+## Лицензия
+
+Проект распространяется под лицензией MIT.

data/Rakefile

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/encrypth/archiver.rb

@@ -0,0 +1,77 @@
+require "fileutils"
+require "stringio"
+require "find"
+require "rubygems/package"
+
+module Encrypth
+  class Archiver
+    def initialize(cipher)
+      @cipher = cipher
+    end
+
+    # Шифрует содержимое файлов и сохраняет его в виде зашифрованного архива
+    def encrypt_files(files, archive_path)
+      tar_content = create_tar_archive(files, archive_path)
+      encrypted = @cipher.encrypt(tar_content)
+      File.binwrite(archive_path, encrypted)
+    end
+
+    # Дешифрует архив и извлекает файлы в указанную директорию
+    def decrypt_to_directory(archive_path, destination)
+      encrypted = File.binread(archive_path)
+      tar_content = @cipher.decrypt(encrypted)
+      extract_tar_archive(tar_content, destination)
+    end
+
+    private
+
+    # Создает tar-архив из списка файлов и возвращает его содержимое в виде строки
+    def create_tar_archive(files, archive_path)
+      io = StringIO.new.tap { |s| s.set_encoding("binary") }
+      Gem::Package::TarWriter.new(io) do |tar|
+        files.each do |file|
+          if File.directory?(file)
+            add_directory_to_archive(tar, file)
+          else
+            add_file_to_archive(tar, file)
+          end
+        end
+      end
+      io.string
+    end
+
+    def add_directory_to_archive(archive, directory)
+      Find.find(directory) do |path|
+        next if File.directory?(path)
+        tar_path = path.sub("#{directory}/", "")
+        archive.add_file(tar_path, File.stat(path).mode) do |f|
+          f.write(File.binread(path))
+        end
+      end
+    end
+
+    def add_file_to_archive(archive, file)
+      tar_path = File.basename(file)
+      archive.add_file(tar_path, File.stat(file).mode) do |f|
+        f.write(File.binread(file))
+      end
+    end
+
+    # Извлекает файлы из tar-архива, который передается в виде строки
+    def extract_tar_archive(archive_content, destination) 
+      io = StringIO.new(archive_content).tap { |s| s.set_encoding("binary") }
+      Gem::Package::TarReader.new(io) do |tar|
+        tar.each do |entry|
+          path = File.join(destination, entry.full_name)
+          if entry.directory?
+            FileUtils.mkdir_p(path)
+          else
+            FileUtils.mkdir_p(File.dirname(path))
+            File.write(path, entry.read)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/encrypth/cipher.rb

@@ -0,0 +1,75 @@
+require "openssl"
+require "base64"
+require "securerandom"
+
+module Encrypth
+    class Cipher
+      def initialize(key)
+        @key = key
+        validate_key!
+      end
+
+    # Шифрует данные и возвращает строку для хранения
+    def encrypt(data)
+      cipher = OpenSSL::Cipher.new("aes-256-gcm")
+      cipher.encrypt
+      cipher.key = @key
+      
+      iv = cipher.random_iv
+      encrypted = cipher.update(data) + cipher.final
+      auth_tag = cipher.auth_tag
+
+      package(iv, encrypted, auth_tag)
+    end
+
+    # Дешифрует данные из строки, созданной методом encrypt
+    def decrypt(string)
+      iv, encrypted, auth_tag = unpack(string)
+      
+      cipher = OpenSSL::Cipher.new("aes-256-gcm")
+      cipher.decrypt
+      cipher.key = @key
+      cipher.iv = iv
+      cipher.auth_tag = auth_tag
+      
+      cipher.update(encrypted) + cipher.final
+    end
+    
+    # Генерирует случайный ключ (32 байта)
+    def self.generate_key
+      SecureRandom.random_bytes(32)
+    end
+    
+    # Создает ключ из пароля (с солью)
+    def self.from_password(password, salt = nil)
+      salt ||= SecureRandom.random_bytes(16)
+      key = OpenSSL::PKCS5.pbkdf2_hmac(password, salt, 20000, 32, "SHA256")
+      { key: key, salt: salt }
+    end
+    
+    private
+    
+    def validate_key!
+      if @key.bytesize != 32
+        raise Error, "Ключ должен быть 32 байта (получено #{@key.bytesize})"
+      end
+    end
+
+    def package(iv, encrypted, auth_tag)
+    [
+      Base64.strict_encode64(iv),
+      Base64.strict_encode64(encrypted),
+      Base64.strict_encode64(auth_tag)
+    ].join("--")
+    end
+    
+    def unpack(string)
+      parts = string.split("--", 3)
+      [
+        Base64.decode64(parts[0]),
+        Base64.decode64(parts[1]),
+        Base64.decode64(parts[2])
+      ]
+    end
+  end
+end

data/lib/encrypth/cli.rb

@@ -0,0 +1,85 @@
+require "io/console"
+require "base64"
+
+module Encrypth
+  class CLI
+    def self.run(args)
+      if args.length < 1
+        puts "Использование: encrypth.rb <archive> <flag (-e/-d)> <...files/destination?>"
+        exit(1)
+      end
+
+      archive = args[0]
+      flag = args[1]
+      
+      if flag == "-e"
+        if File.exist?(archive)
+          puts "Архив #{archive} уже существует. Пожалуйста, выберите другое имя или удалите существующий архив."
+          exit(1)
+        end
+        files = args[2..-1]
+        encrypt_files(files, archive)
+      elsif flag == "-d"
+        if !File.exist?(archive)
+          puts "Архив #{archive} не существует."
+          exit(1)
+        end
+        destination = args[2]
+        if destination && File.exist?(destination) && !File.directory?(destination)
+          puts "Указанный путь #{destination} не является директорией."
+          exit(1)
+        end
+        destination = "." if destination.nil? || destination.empty?
+        decrypt_to_directory(archive, destination)
+      else
+        puts "Неверный флаг. Используйте -e для шифрования или -d для дешифрования."
+        exit(1)
+      end
+    end
+
+    def self.encrypt_files(files, archive)
+      password = read_password("Задайте пароль: ")
+      cipher_data = Encrypth::Cipher.from_password(password)
+      save_salt(archive, cipher_data[:salt])
+      cipher = Encrypth::Cipher.new(cipher_data[:key])
+      archiver = Encrypth::Archiver.new(cipher)
+      archiver.encrypt_files(files, archive)
+    end
+
+    def self.decrypt_to_directory(archive, destination)
+      password = read_password("Введите пароль: ")
+      salt = load_salt(archive)
+      cipher_data = Encrypth::Cipher.from_password(password, salt)
+      cipher = Encrypth::Cipher.new(cipher_data[:key])
+      archiver = Encrypth::Archiver.new(cipher)
+      archiver.decrypt_to_directory(archive, destination)
+    end
+
+    private
+
+    def self.salt_path(archive)
+      "#{archive}.salt"
+    end
+
+    def self.save_salt(archive, salt)
+      File.binwrite(salt_path(archive), Base64.strict_encode64(salt))
+    end
+
+    def self.load_salt(archive)
+      salt_file = salt_path(archive)
+      unless File.exist?(salt_file)
+        raise "Файл соли не найден. Невозможно восстановить ключ для архива #{archive}."
+      end
+
+      Base64.decode64(File.read(salt_file))
+    end
+
+    def self.read_password(prompt)
+      print prompt
+      $stdout.flush
+      password = STDIN.noecho { |io| io.gets }&.chomp || ""
+      puts
+      password
+    end
+  end
+end

data/lib/encrypth/version.rb

@@ -0,0 +1,3 @@
+module Encrypth
+  VERSION = "0.2.0"
+end

data/lib/encrypth/web_archiver.rb

@@ -0,0 +1,111 @@
+module Encrypth
+  class WebArchiver
+    SALT_LEN = 32
+    IV_LEN   = 12
+    TAG_LEN  = 16
+
+    def initialize(password)
+      @password = password
+    end
+    
+    def encrypt(files)
+      out_path = File.join(Dir.tmpdir, "enc_#{SecureRandom.hex(8)}.tar.enc")
+      tar_path = File.join(Dir.tmpdir, "tar_#{SecureRandom.hex(8)}.tar")
+      
+      salt = OpenSSL::Random.random_bytes(SALT_LEN)
+      key = derive_key(@password, salt)
+      
+      begin
+        create_tar(files, tar_path)
+        
+        cipher = OpenSSL::Cipher.new('aes-256-gcm').encrypt
+        cipher.key = key
+        iv = cipher.random_iv
+        cipher.iv_len = IV_LEN
+        cipher.iv = iv
+        
+        File.open(out_path, 'wb') do |out_f|
+          out_f.write(salt)
+          out_f.write(iv)
+          
+          File.open(tar_path, 'rb') do |tar_f|
+            while chunk = tar_f.read(16384)
+              out_f.write(cipher.update(chunk))
+            end
+          end
+          out_f.write(cipher.final)
+          out_f.write(cipher.auth_tag)
+        end
+        
+        { path: out_path, size: File.size(out_path) }
+      ensure
+        File.delete(tar_path) if File.exist?(tar_path)
+      end
+    end
+    
+    def decrypt(archive_path, destination)
+      File.open(archive_path, 'rb') do |file|
+        salt = file.read(SALT_LEN)
+        iv   = file.read(IV_LEN)
+        
+        ciphertext_len = File.size(archive_path) - SALT_LEN - IV_LEN - TAG_LEN
+        key = derive_key(@password, salt)
+        
+        cipher = OpenSSL::Cipher.new('aes-256-gcm').decrypt
+        cipher.key = key
+        cipher.iv = iv
+        
+        ciphertext = file.read(ciphertext_len)
+        auth_tag = file.read(TAG_LEN)
+        cipher.auth_tag = auth_tag
+        
+        decrypted_data = cipher.update(ciphertext) + cipher.final
+        
+        tar_path = File.join(Dir.tmpdir, "dec_#{SecureRandom.hex(8)}.tar")
+        File.binwrite(tar_path, decrypted_data)
+        
+        begin
+          extract_tar(tar_path, destination)
+        ensure
+          File.delete(tar_path) if File.exist?(tar_path)
+        end
+      end
+    end
+
+    private
+
+    def derive_key(password, salt)
+      OpenSSL::PKCS5.pbkdf2_hmac(password, salt, 100000, 32, 'sha256')
+    end
+
+    def create_tar(files, output_path)
+      File.open(output_path, 'wb') do |f|
+        Gem::Package::TarWriter.new(f) do |tar|
+          files.each do |file_path|
+            next unless File.exist?(file_path)
+            stat = File.stat(file_path)
+            tar.add_file_simple(File.basename(file_path), stat.mode, stat.size) do |io|
+              File.open(file_path, 'rb') { |src| io.write(src.read) }
+            end
+          end
+        end
+      end
+    end
+
+    def extract_tar(tar_path, destination)
+      File.open(tar_path, 'rb') do |f|
+        Gem::Package::TarReader.new(f) do |reader|
+          reader.each do |entry|
+            target = File.join(destination, entry.full_name)
+            if entry.directory?
+              FileUtils.mkdir_p(target)
+            elsif entry.file?
+              FileUtils.mkdir_p(File.dirname(target))
+              File.binwrite(target, entry.read)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/encrypth.rb

@@ -0,0 +1,8 @@
+module Encrypth
+  require_relative "encrypth/cipher"
+  require_relative "encrypth/archiver"
+  require_relative "encrypth/cli"
+
+  # раскомментируйте для консольного использования
+  # CLI.run(ARGV)
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: encrypth
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Irina Grigorian
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: a gem with aes-256-gcm standard to make encrypting easy and safe.
+email:
+- irigorian@sfedu.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/encrypth.rb
+- lib/encrypth/archiver.rb
+- lib/encrypth/cipher.rb
+- lib/encrypth/cli.rb
+- lib/encrypth/version.rb
+- lib/encrypth/web_archiver.rb
+homepage: https://github.com/smokinblackdog/encrypth.git
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: a simple wrapper for encryption.
+test_files: []