safe safely stores all your user IDs and passwords, encrypted by a password of your choosing.
Sidekiq middleware that encrypts your job data into and out of Redis.
Easy Contacts Syncing over API with encrypted contacts email and phone numbers
String open classed with AES-256 and RSA encryption and zipping methods for easy, secure, encryption of strings. The string_encryption gem was started with the intention of being compatible with the RSA and AES algorithms used in a javascript library on http://www.pidder.com/pidcrypt . Usage and testing against the pidcrypt library hasn't been done yet, but is scheduled for the future. The intent of this library is to make encryption and decryption of a string as straight forward as capitalizing or reversing is. To encrypt a string: encrypted_secret = "Super Secret Text".encrypt("Super Secret Password") To decrypt a string: decrypted_secret = encrypted_secret.encrypt("Super Secret Password") Branden Giacoletto
A command-line tool for easy encryption and decryption of data.
Simple encryption and decryption with asymmetric (or public-key) cryptography.
Encrypted and easy to use personal storage for user passwords
Backup is a Ruby Gem written for Unix and Ruby on Rails (2 and 3) environments. It can be used both with and without the Ruby on Rails framework! This gem offers a quick and simple solution to backing up databases such as MySQL/PostgreSQL/SQLite and Files/Folders. All backups can be transferred to Amazon S3, Rackspace Cloud Files, Dropbox Web Service, any remote server you have access to (using either SCP, SFTP or regular FTP), or a Local server. Backup handles Compression, Archiving, Encryption (OpenSSL or GPG), Backup Cleaning (Cycling) and supports Email Notifications.
Generates attr_accessors that encrypt and decrypt attributes transparently
A quick and easy encryption wrapper. using the built in openssl functions. Usable in String, Text, or Binary fields. (Encodes in Base 64 before saving)
Symmetric encryption and decryption with OpenSSL
Simple Ruby wrapper around "gpg" command for file encryption
Easily encrypt data at rest with minimal changes to existing ripple models.
Library for Mastercard API compliant payload encryption/decryption.
Tool for working with encrypted secrets in repositories
A Ruby client for simple-secrets, the simple, opinionated library for encrypting small packets of data securely.
ECIES is a public-key encryption scheme based on ECC. It can be used to encrypt messages to bitcoin addresses with keys published on the blockchain, and subsequently to decrypt messages by the holders of the address's private key.
Underlock makes it dead simple to encrypt and decrypt files using public/private keys.
Selectively encrypt fields in Sidekiq
Decrypt AES256GCM-encrypted data in Apple Pay Payment Tokens
Unsakini is an open source encrypted bulletin board created with the aim of evading global information surveillance and spying, preventing data leaks and promoting information confidentiality and integrity.
CLI tool for encrypting Chef data bag items
triple DES encryption implemented in C using openssl
This is a fork of nokogiri-xmlsec. This fork uses mini_portile to improve code predictiveness and allow heroku deploys. This gem adds support to Ruby for encrypting, decrypting, signing and validating the signatures of XML documents, according to the [XML Encryption Syntax and Processing](http://www.w3.org/TR/xmlenc-core/) standard, by wrapping around the [xmlsec1](http://www.aleksey.com/xmlsec) C library and adding relevant methods to `Nokogiri::XML::Document`.
A gem used by the LegionIO framework for encryption
Sequel plugins to handle encrypted attributes
Gem to integrate with Bank Neon's API and its encrypted authentication process
Ciphr is a CLI tool for performing and composing encoding, decoding, encryption, decryption, hashing, and other various operations on streams of data. It takes provided data, file data, or data from stdin, and executes a pipeline of functions on the data stream, writing the resulting data to stdout. It was designed primarily for use in the information security domain, mostly for quick or casual data manipulation for forensics, penetration testing, or capture-the-flag events; it likely could have other unforseen uses, but should be presumed to be an experimental toy as no effort was made to make included cryptographic functions robust against attacks (timing attacks, etc), and it is recommended not to use any included functions in any on-line security mechanisms.
A simple gem to encrypt cookies for ruby applications.
Acra helps you easily secure your databases in distributed, microservice-rich environments. It allows you to selectively encrypt sensitive records with strong multi-layer cryptography, detect potential intrusions and SQL injections and cryptographically compartmentalise data stored in large sharded schemes.
Implements a special case (k = 2) of Adi Shamir's secret sharing algorithm. This allows secret files to be encrypted on disk and require two secret holders to decrypt it.
Encrypted form fields for Rails
Ruby/Password is a suite of password handling methods for Ruby. It supports the manual entry of passwords from the keyboard in both buffered and unbuffered modes, password strength checking, random password generation, phonemic password generation (for easy memorisation by human-beings) and the encryption of passwords.
Simple tool to backup MySQL databases and filesystem locally or to Amazon S3 (with optional encryption)
Hiera backend for decrypting gosecret-encrypted values
Encrypt data in mass with Active Record Encryption
Merge your yaml to rails secrets, and it encrypted only leaf
Encryption providers for crypt_keeper
Encrypt attributes using AES-256-CBC (or your custom encryption strategy). Works with and without ActiveRecord.
Decrypt environment variables encrypted with Amazon's KMS service
# SecureDataBag / Knife Secure Bag Knife Secure Bag provides a consistent interface to DataBagItem, EncryptedDataBagItem as well as the custom created SecureDataBagItem while also providing a few extra handy features to help in your DataBag workflows. SecureDataBagItem, can not only manage your existing DataBagItems and EncryptedDataBagItems, but it also provides you with a DataBag type which enables you to selectively encrypt only some of the fields in your DataBag thus allowing you to be able to search for the remaining fields. ## Installation To build and install the plugin add it your Gemfile or run: ```shell gem install secure_data_bag ``` ## Configuration #### Knife Secure Bag Defaults for the Knife command may be provided in your _knife.rb_ file. ```ruby knife[:secure_data_bag][:encrypted_keys] = %w( password ssh_keys ssh_ids public_keys private_keys keys secret ) knife[:secure_data_bag][:secret_file] = "#{local_dir}/secret.pem" knife[:secure_data_bag][:export_root] = "#{kitchen_dir}/data_bags" knife[:secure_data_bag][:export_on_upload] = true knife[:secure_data_bag][:defaults][:secrets][:export_format] = 'plain' ``` To break this up: `knife[:secure_data_bag][:encrypted_keys] = []` When Knife Secure Bag encrypts a hash with an _encryption format_ of *nested*, it will recursively walk through the hash from the bottom up and encrypt any key found within this array. `knife[:secure_data_bag][:secret_file]` When encryption is required, the shared secret found at this location will be loaded. `knife[:secure_data_bag][:export_root]` When exporting a data\_bag\_item, files will be created in below this root directory. Typically this would be the data\_bag folder located within your kitchen. `knife[:secure_data_bag][:export_on_upload]` When a data\_bag\_item is edited using `knife secure bag edit`, it may be automatically exported to the _export\_root_. `knife[:secure_data_bag][:defaults][:secrets][:export_format]` The configuration file additionally supports the _defaults_ hash which provides default values for all _command line arguments_ that one might use. Of all of them only the _export\_format_ key is likely to be of much use. ## Examples #### Chef cookbook recipe ```ruby metadata = {} # Define the keys we wish to encrypt metadata[:encrypted_keys] = %w(encoded) # Optionally load a specific shared secret. Otherwise, the global # encrypted\_data\_bag\_secret will be automatically used. secret_key = SecureDataBagItem.load_key("/path/to/secret") # Create a hash of data to use as an exampe raw_data = { id: "item", data_bag: "data_bag", encoded: "my string", unencoded: "other string" } # Instantiate a SecureDataBagItem from a hash item = SecureDataBagItem.from_hash(data, metadata) # Or more explicitely item = SecureDataBagItem.from_hash(data, encrypted_keys: %w(encoded)) # Or load from server item = SecureDataBagItem.load("data_bag", "item") # Print the un-encrypted raw data pp item.raw_data # Print the un-encrypted `encoded` key pp item['encoded'] # Print the encrypted hash as a data_bag_item hash pp item.to_hash =begin { id: "item", data_bag: "data_bag", encoded: { encrypted_data: "encoded", cipher: aes-256-cbc, iv: 13453453dkgfefg== version: 1 } unencoded: "other string", } =end ``` ## Usage #### Knife commands Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as plain text. ```shell knife secure bag show -F js secrets secret_item ``` Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as a SecureDataBagItem in encrypted format. ```shell knife secure bag show -F js secrets secret_item --enc-format nested ``` Edit an EncryptedDataBagItem, preserve it's encryption type, and export a copy to the _data\_bag_ folder in your kitchen. ```shell knife secure bag edit secrets secret_item --export ``` ## Knife SubCommands Most of the SubCommands support the following command-line options: `--enc-format [plain,encrypted,nested]` Ensure that, when displaying or uploading the data\_bag\_item, we forcibly encrypt the data\_bag\_item using the specified format instead of preserving the existing format. In this case: - plain: refers to a DataBagItem - encrypted: refers to an EnrytpedDataBagItem - nested: refers to a SecureDataBagItem `--dec-format [plain,encrypted,nested]` Attempt to decrypt the data\_bag\_item using the given format rather than the auto-detected one. The only real reason to use this is when you wish to specifically select _plain_ as the format so as to not decrypt the item. `--enc-keys key1,key2,key3` Provide a comma delimited list of hash keys which should be encrypted when encrypting the data\_bag\_item. This list will be concatenated with any key names listed in the configuration file or which were previously encrypted. `--export` Export the data\_bag\_item to json file in either of _export-format_ or _enc-format_. `--export-format` Overrides the encryption format only for the _export_ feature. `--export-root` Root directly under which a folder should exist for each _data_bag_ into which to export _data_bag_items_ as json files. When displaying the content of the _data\_bag\_item_, an additional key of *_secure_metadata* will be added to the output which contains gem specific metadata such as the encryption formats and any encrypted keys found. This key will _not_ be saved with the item, however it may be manipulated to alter the behavior of the _edit_ or _export_ commands. #### knife secure bag show DATA_BAG ITEM This command functions just like `knife data bag show` and is used to print out the content of either a DataBagItem, EncryptedDataBagItem or SecureDataBagItem. By default, it will auto-detect the Item type, and print it's unencrypted version to the terminal. This behavior, however, may be altered using the previously mentioned command line options. #### knife secure bag open PATH This commands functions much like `knife secure bag show`, however it is designed to load a _data\_bag\_item_ from disk as opposed to loading it from Chef server. This may be of use when view the content of an exported encrypted file. #### knife secure bag edit DATA_BAG DATA_BAG_ITEM This command functions just like `knife data bag edit` and is used to edit either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`. #### knife secure bag from file DATA_BAG PATH This command functions just like `knife data bag from file` and is used to upload either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`. ## Recipe DSL The gem additionally provides a few Recipe DSL methods which may be useful. ```ruby load_secure_item = secure_data_bag_item( data_bag_name, data_bag_item, cache: false ) load_plain_item = data_bag_item(data_bag_name, data_bag_item) convert_plain_to_secure = secure_data_bag_item!(load_plain_item) ```
Secret management by encrypting values in a JSON or YAML file with a public/private keypair
Strong public-key encryption for arbitrary length data.
Tokenifier is a Gibberish gem wrapper. It provides an aproach to encrypt and decrypt structures like Strings, Hashes.
File Encryption Manager
Removes, digests or encrypts selected values in a ruby hash
ActiveSupport::MessageEncryptor encryption wrapper for PORO objects and ActiveModel attributes
Easily encrypt columns in your app conditionally and with hashed values for searching
Encrypts and decrypts data of arbitrary length using RSA cyphers. Fixed and much faster fork of "crypto64" gem.
Wrapper encryption gem