Chiffrement Simple en Ruby externes sans gemmes

Vous pouvez utiliser OpenSSL::Cypher

# for more info, see http://ruby-doc.org/stdlib-1.9.3/libdoc/openssl/rdoc/OpenSSL/Cipher.html

require 'openssl'
require 'digest/sha1'

# create the cipher for encrypting
cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
cipher.encrypt

# you will need to store these for later, in order to decrypt your data
key = Digest::SHA1.hexdigest("yourpass")
iv = cipher.random_iv

# load them into the cipher
cipher.key = key
cipher.iv = iv

# encrypt the message
encrypted = cipher.update('This is a secure message, meet at the clock-tower at dawn.')
encrypted << cipher.final
puts "encrypted: #{encrypted}\n"

# now we create a sipher for decrypting
cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
cipher.decrypt
cipher.key = key
cipher.iv = iv

# and decrypt it
decrypted = cipher.update(encrypted)
decrypted << cipher.final
puts "decrypted: #{decrypted}\n"

Mais la forme intermédiaire ne se prêtent pas bien à l'impression

---

Donné votre pensé que ce serait bien si la forme intermédiaire était de la même longueur, vous pouvez simplement utiliser une simple carte d'un char à l'autre.

S'IL VOUS PLAÎT COMPRENDRE QUE CE N'EST PAS SÛR

Vous pouvez facilement la force brute de la clé, mais il semble être en harmonie avec vos besoins.

class Cipher
def initialize(shuffled)
normal = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a + [' ']
@map = normal.zip(shuffled).inject(:encrypt => {} , :decrypt => {}) do |hash,(a,b)|
hash[:encrypt][a] = b
hash[:decrypt][b] = a
hash
end
end
def encrypt(str)
str.split(//).map { |char| @map[:encrypt][char] }.join
end
def decrypt(str)
str.split(//).map { |char| @map[:decrypt][char] }.join
end
end
# pass the shuffled version to the cipher
cipher = Cipher.new ["K", "D", "w", "X", "H", "3", "e", "1", "S", "B", "g", "a", "y", "v", "I", "6", "u", "W", "C", "0", "9", "b", "z", "T", "A", "q", "U", "4", "O", "o", "E", "N", "r", "n", "m", "d", "k", "x", "P", "t", "R", "s", "J", "L", "f", "h", "Z", "j", "Y", "5", "7", "l", "p", "c", "2", "8", "M", "V", "G", "i", " ", "Q", "F"]
msg = "howdy pardner"
crypted = cipher.encrypt msg
crypted # => "1IzXAF6KWXvHW"
decrypted = cipher.decrypt crypted
decrypted # => "howdy pardner"

OriginalL'auteur Joshua Cheek

De base de codage/décodage but je suppose que ruby intégré Base64 bibliothèque peuvent être à portée de main:

2.2.1 :001 > require 'base64'
=> true 
2.2.1 :002 > str = "[email protected]"
=> "[email protected]" 
2.2.1 :003 > Base64.encode64(str)
=> "YWJjQGV4YW1wbGUuY29t\n" 

Il a aussi la urlsafe version de méthodes dans le cas où les chaînes codées doivent être utilisés dans les url.

Référence: http://ruby-doc.org/stdlib-2.3.0/libdoc/base64/rdoc/Base64.html

OriginalL'auteur Jignesh Gohel

Méthode facultative pour le chiffrement et le déchiffrement

gem 'activesupport'
require 'active_support'
key = SecureRandom.random_bytes(32)
crypt = ActiveSupport::MessageEncryptor.new(key)
encrypted_data = crypt.encrypt_and_sign("your password")
password = crypt.decrypt_and_verify(encrypted_data)

OriginalL'auteur Prashanth Sams

Je suppose que le plus simple est a * x + b (mod 2^n)

Noter que vous avez besoin pour calculer l'inverse d'une sur 2^n, vous pouvez avec Wolfram Alpha à l'aide de PGCD étendu.

OriginalL'auteur Philip