Prévia do material em texto
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 1/9
PROJECT
a�r_encrypted
3.59
Generates a�r_accessors that encrypt and decrypt a�ributes transparently
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018
2019 2020 2021
Encryp�on
No release in over 3 years Low commit ac�vity in last 3 years There's a lot of open issues
a�r_encrypted a�r-encrypted/a�r_encrypted Homepage Documenta�on Source Code Bug Tracker
Wiki
Popularity
DOWNLOADS
34,844,686
STARS
1,904
FORKS
276
WATCHERS
42
Releases
CURRENT VERSION
3.1.0
TOTAL RELEASES
20
FIRST RELEASE
2009-01-13
LATEST RELEASE
2018-02-11
Issues
OPEN ISSUES
70
CLOSED ISSUES
174
TOTAL ISSUES
244
ISSUE CLOSURE RATE
71%
Pull Requests
OPEN PULL REQUESTS
24
CLOSED PULL REQUESTS
58
MERGED PULL REQUESTS
67
PULL REQUEST
ACCEPTANCE RATE
44%
Development
PRIMARY LANGUAGE
Ruby
LICENSES
MIT
AVERAGE DATE OF LAST 50
COMMITS
2017-09-13
REVERSE DEPENDENCIES
25
https://www.ruby-toolbox.com/projects/attr_encrypted
https://www.ruby-toolbox.com/categories/encryption
https://rubygems.org/gems/attr_encrypted
https://github.com/attr-encrypted/attr_encrypted
http://github.com/attr-encrypted/attr_encrypted
https://www.rubydoc.info/gems/attr_encrypted/3.1.0
https://github.com/attr-encrypted/attr_encrypted
https://github.com/attr-encrypted/attr_encrypted/issues
https://github.com/attr-encrypted/attr_encrypted/wiki
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_downloads
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_downloads
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_stargazers_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_stargazers_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_forks_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_forks_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_watchers_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_watchers_count
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_current_version
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_current_version
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_releases_count
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_releases_count
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_first_release_on
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_first_release_on
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_latest_release_on
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_latest_release_on
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_open_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_open_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_closed_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_closed_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_total_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_total_issues_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_issue_closure_rate
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_issue_closure_rate
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_open_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_open_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_closed_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_closed_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_merged_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_merged_pull_requests_count
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_pull_request_acceptance_rate
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_pull_request_acceptance_rate
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_average_recent_committed_at
https://www.ruby-toolbox.com/pages/docs/metrics/github_repo_average_recent_committed_at
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_reverse_dependencies_count
https://www.ruby-toolbox.com/pages/docs/metrics/rubygem_reverse_dependencies_count
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 2/9
Development
ac�onpack
~> 4.1.16
ac�verecord
~> 4.1.16
codeclimate-test-
reporter
<= 0.6.0
datamapper
>= 0
dm-sqlite-adapter
>= 0
minitest
>= 0
rake
>= 0
sequel
>= 0
simplecov
>= 0
simplecov-rcov
>= 0
sqlite3
>= 0
Run�me
encryptor
~> 3.0.0
Dependencies
Maintainer(s) wanted!!!
If you have an interest in maintaining this project... please see h�ps://github.com/a�r-encrypted/a�r_encrypted/issues/379
a�r_encrypted
buildbuild failingfailing securitysecurity no warningsno warnings
Generates a�r_accessors that transparently encrypt and decrypt a�ributes.
It works with ANY class, however, you get a few extra features when you're using it with ActiveRecord , DataMapper , or Sequel .
Installa�on
Add a�r_encrypted to your gemfile:
gem "attr_encrypted", "~> 3.1.0"
Then install the gem:
bundle install
Usage
If you're using an ORM like ActiveRecord , DataMapper , or Sequel , using a�r_encrypted is easy:
class User
attr_encrypted :ssn, key: 'This is a key that is 256 bits!!'
end
If you're using a PORO, you have to do a li�le bit more work by extending the class:
Project Readme
https://www.ruby-toolbox.com/projects/actionpack
https://www.ruby-toolbox.com/projects/activerecord
https://www.ruby-toolbox.com/projects/codeclimate-test-reporter
https://www.ruby-toolbox.com/projects/datamapper
https://www.ruby-toolbox.com/projects/dm-sqlite-adapter
https://www.ruby-toolbox.com/projects/minitest
https://www.ruby-toolbox.com/projects/rake
https://www.ruby-toolbox.com/projects/sequel
https://www.ruby-toolbox.com/projects/simplecov
https://www.ruby-toolbox.com/projects/simplecov-rcov
https://www.ruby-toolbox.com/projects/sqlite3
https://www.ruby-toolbox.com/projects/encryptor
https://www.ruby-toolbox.com/projects/actionpack
https://www.ruby-toolbox.com/projects/activerecord
https://www.ruby-toolbox.com/projects/codeclimate-test-reporter
https://www.ruby-toolbox.com/projects/datamapper
https://www.ruby-toolbox.com/projects/dm-sqlite-adapter
https://www.ruby-toolbox.com/projects/minitest
https://www.ruby-toolbox.com/projects/rake
https://www.ruby-toolbox.com/projects/sequel
https://www.ruby-toolbox.com/projects/simplecov
https://www.ruby-toolbox.com/projects/simplecov-rcov
https://www.ruby-toolbox.com/projects/sqlite3
https://www.ruby-toolbox.com/projects/encryptor
https://github.com/attr-encrypted/attr_encrypted/issues/379
https://travis-ci.org/attr-encrypted/attr_encrypted
https://codeclimate.com/github/attr-encrypted/attr_encrypted/coverage
https://codeclimate.com/github/attr-encrypted/attr_encrypted
https://badge.fury.io/rb/attr_encrypted
https://hakiri.io/github/attr-encrypted/attr_encrypted/master
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 3/9
class User
extend AttrEncrypted
attr_accessor :name
attr_encrypted :ssn, key: 'This is a key that is 256 bits!!'
def load
# loads the stored data
end
def save
# saves the :name and :encrypted_ssn attributes somewhere (e.g. filesystem, database, etc)
end
end
user = User.new
user.ssn = '123-45-6789'
user.ssn # returns the unencrypted object ie. '123-45-6789'
user.encrypted_ssn # returns the encrypted version of :ssn
user.save
user = User.load
user.ssn # decrypts :encrypted_ssn and returns '123-45-6789'Encrypt/decrypt a�ribute class methods
Two class methods are available for each a�ribute: User.encrypt_email and User.decrypt_email . They accept as arguments the same op�ons th
example:
key = SecureRandom.random_bytes(32)
iv = SecureRandom.random_bytes(12)
encrypted_email = User.encrypt_email('test@test.com', iv: iv, key: key)
email = User.decrypt_email(encrypted_email, iv: iv, key: key)
The attr_encrypted class method is also aliased as attr_encryptor to conform to Ruby's attr_ naming conven�ons. I should have called this p
realized it ='(.
a�r_encrypted with database persistence
By default, attr_encrypted uses the :per_attribute_iv encryp�on mode. This mode requires a column to store your cipher text and a column to
Create or modify the table that your model uses to add a column with the encrypted_ prefix (which can be modified, see below), e.g. encrypted_ss
create_table :users do |t|
t.string :name
t.string :encrypted_ssn
t.string :encrypted_ssn_iv
t.timestamps
end
You can use a string or binary column type. (See the encode op�on sec�on below for more info)
If you use the same key for each record, add a unique index on the IV. Repeated IVs with AES-GCM (the default algorithm) allow an a�acker to recover
add_index :users, :encrypted_ssn_iv, unique: true
Specifying the encrypted a�ribute name
By default, the encrypted a�ribute name is encrypted_#{attribute} (e.g. attr_encrypted :email would create an a�ribute named encrypted_
in the database, you need to make sure the encrypted_#{attribute} field exists in your table. You have a couple of op�ons if you want to name you
for more details.
a�r_encrypted op�ons
Op�ons are evaluated
All op�ons will be evaluated at the instance level. If you pass in a symbol it will be passed as a message to the instance of your class. If you pass a proc o
called. You can pass in the instance of your class as an argument to the proc. Anything else will be returned. For example:
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 4/9
Symbols represen�ng instance methods
Here is an example class that uses an instance method to determines the encryp�on key to use.
class User
attr_encrypted :email, key: :encryption_key
def encryption_key
# does some fancy logic and returns an encryption key
end
end
Procs
Here is an example of passing a proc/lambda object as the :key op�on as well:
class User
attr_encrypted :email, key: proc { |user| user.key }
end
Default op�ons
The following are the default op�ons used by attr_encrypted :
prefix: 'encrypted_',
suffix: '',
if: true,
unless: false,
encode: false,
encode_iv: true,
encode_salt: true,
default_encoding: 'm',
marshal: false,
marshaler: Marshal,
dump_method: 'dump',
load_method: 'load',
encryptor: Encryptor,
encrypt_method: 'encrypt',
decrypt_method: 'decrypt',
mode: :per_attribute_iv,
algorithm: 'aes-256-gcm',
allow_empty_value: false
All of the aforemen�oned op�ons are explained in depth below.
Addi�onally, you can specify default op�ons for all encrypted a�ributes in your class. Instead of having to define your class like this:
class User
attr_encrypted :email, key: 'This is a key that is 256 bits!!', prefix: '', suffix: '_crypted'
attr_encrypted :ssn, key: 'a different secret key', prefix: '', suffix: '_crypted'
attr_encrypted :credit_card, key: 'another secret key', prefix: '', suffix: '_crypted'
end
You can simply define some default op�ons like so:
class User
attr_encrypted_options.merge!(prefix: '', :suffix => '_crypted')
attr_encrypted :email, key: 'This is a key that is 256 bits!!'
attr_encrypted :ssn, key: 'a different secret key'
attr_encrypted :credit_card, key: 'another secret key'
end
This should help keep your classes clean and DRY.
The :attribute op�on
You can simply pass the name of the encrypted a�ribute as the :attribute op�on:
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 5/9
class User
attr_encrypted :email, key: 'This is a key that is 256 bits!!', attribute: 'email_encrypted'
end
This would generate an a�ribute named email_encrypted
The :prefix and :suffix op�ons
If you don't like the encrypted_#{attribute} naming conven�on then you can specify your own:
class User
attr_encrypted :email, key: 'This is a key that is 256 bits!!', prefix: 'secret_', suffix: '_crypted'
end
This would generate the following a�ribute: secret_email_crypted .
The :key op�on
The :key op�on is used to pass in a data encryp�on key to be used with whatever encryp�on class you use. If you're using Encryptor , the key mus
the algorithm that you use; aes-256 requires a 256 bit key, etc. The :key op�on is not required (see custom encryptor below).
Unique keys for each a�ribute
You can specify unique keys for each a�ribute if you'd like:
class User
attr_encrypted :email, key: 'This is a key that is 256 bits!!'
attr_encrypted :ssn, key: 'a different secret key'
end
It is recommended to use a symbol or a proc for the key and to store informa�on regarding what key was used to encrypt your data. (See below for mor
The :if and :unless op�ons
There may be �mes that you want to only encrypt when certain condi�ons are met. For example maybe you're using rails and you don't want to encryp
can specify condi�ons like this:
class User < ActiveRecord::Base
attr_encrypted :email, key: 'This is a key that is 256 bits!!', unless: Rails.env.development?
attr_encrypted :ssn, key: 'This is a key that is 256 bits!!', if: Rails.env.development?
end
You can specify both :if and :unless op�ons.
The :encryptor , :encrypt_method , and :decrypt_method op�ons
The Encryptor class is used by default. You may use your own custom encryptor by specifying the :encryptor , :encrypt_method , and :decryp
Lets suppose you'd like to use this custom encryptor class:
class SillyEncryptor
def self.silly_encrypt(options)
(options[:value] + options[:secret_key]).reverse
end
def self.silly_decrypt(options)
options[:value].reverse.gsub(/#{options[:secret_key]}$/, '')
end
end
Simply set up your class like so:
class User
attr_encrypted :email, secret_key: 'This is a key that is 256 bits!!', encryptor: SillyEncryptor, encrypt_method: :sill
end
Any op�ons that you pass to attr_encrypted will be passed to the encryptor class along with the :value op�on which contains the string to encry
:secret_key instead of :key . See encryptor for more info regarding the default encryptor class.
https://github.com/attr-encrypted/encryptor
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 6/9
The :mode op�on
The mode op�ons allows you to specify in what mode your data will be encrypted. There are currently three modes: :per_attribute_iv , :per_att
:single_iv_and_salt .
NOTE: :per_attribute_iv_and_salt and :single_iv_and_salt modes are deprecated and will be removed in the next major release.
The :algorithm op�on
The default Encryptor class uses the standard ruby OpenSSL library. Its default algorithm is aes-256-gcm . You can modify this by passing the :alg
so:
class User
attr_encrypted :email, key: 'This is a key that is 256 bits!!', algorithm: 'aes-256-cbc'
end
To view a list of all cipher algorithms that are supported on your pla�orm, runthe following code in your favorite Ruby REPL:
require 'openssl'
puts OpenSSL::Cipher.ciphers
See Encryptor for more informa�on.
The :encode , :encode_iv , :encode_salt , and :default_encoding op�ons
You're probably going to be storing your encrypted a�ributes somehow (e.g. filesystem, database, etc). You can simply pass the :encode op�on to aut
encryp�ng/decryp�ng. The default behavior assumes that you're using a string column type and will base64 encode your cipher text. If you choose to u
required, but be sure to pass in false with the :encode op�on.
class User
attr_encrypted :email, key: 'some secret key', encode: true, encode_iv: true, encode_salt: true
end
The default encoding is m (base64). You can change this by se�ng encode: 'some encoding' . See Array#pack for more encoding op�ons.
The :marshal , :dump_method , and :load_method op�ons
You may want to encrypt objects other than strings (e.g. hashes, arrays, etc). If this is the case, simply pass the :marshal op�on to automa�cally mars
class User
attr_encrypted :credentials, key: 'some secret key', marshal: true
end
You may also op�onally specify :marshaler , :dump_method , and :load_method if you want to use something other than the default Marshal o
The :allow_empty_value op�on
You may want to encrypt empty strings or nil so as to not reveal which records are populated and which records are not.
class User
attr_encrypted :credentials, key: 'some secret key', marshal: true, allow_empty_value: true
end
ORMs
Ac�veRecord
If you're using this gem with ActiveRecord , you get a few extra features:
Default op�ons
The :encode op�on is set to true by default.
Dynamic find_by_ and scoped_by_ methods
Let's say you'd like to encrypt your user's email addresses, but you also need a way for them to login. Simply set up your class like so:
https://github.com/attr-encrypted/encryptor#algorithms
http://ruby-doc.org/core-2.3.0/Array.html#method-i-pack
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 7/9
class User < ActiveRecord::Base
attr_encrypted :email, key: 'This is a key that is 256 bits!!'
attr_encrypted :password, key: 'some other secret key'
end
You can now lookup and login users like so:
User.find_by_email_and_password('test@example.com', 'testing')
The call to find_by_email_and_password is intercepted and modified to find_by_encrypted_email_and_encrypted_password('ENCRYPTED EMAI
methods like scoped_by_email_and_password work the same way.
NOTE: This only works if all records are encrypted with the same encryp�on key (per a�ribute).
NOTE: This feature is deprecated and will be removed in the next major release.
DataMapper and Sequel
Default op�ons
The :encode op�on is set to true by default.
Depreca�ons
a�r_encrypted v2.0.0 now depends on encryptor v2.0.0. As part of both major releases many insecure defaults and behaviors have been deprecated. T
Default :mode is now :per_attribute_iv , the default :mode in a�r_encrypted v1.x was :single_iv_and_salt .
Default :algorithm is now 'aes-256-gcm', the default :algorithm in a�r_encrypted v1.x was 'aes-256-cbc'.
The encryp�on key provided must be of appropriate length respec�ve to the algorithm used. Previously, encryptor did not verify minimum key leng
The dynamic finders available in Ac�veRecord will only work with :single_iv_and_salt mode. It is strongly advised that you do not use this mo
encrypted securely. This func�onality will be deprecated in the next major release.
:per_attribute_iv_and_salt and :single_iv_and_salt modes are deprecated and will be removed in the next major release.
Backwards compa�bility is supported by providing a special op�on that is passed to encryptor, namely, :insecure_mode :
class User
attr_encrypted :email, key: 'a secret key', algorithm: 'aes-256-cbc', mode: :single_iv_and_salt, insecure_mode: true
end
The :insecure_mode op�on will allow encryptor to ignore the new security requirements. It is strongly advised that if you use this older insecure beh
behavior.
Upgrading from a�r_encrypted v1.x to v3.x
Modify your gemfile to include the new version of a�r_encrypted:
gem attr_encrypted, "~> 3.0.0"
The update a�r_encrypted:
bundle update attr_encrypted
Then modify your models using a�r_encrypted to account for the changes in default op�ons. Specifically, pass in the :mode and :algorithm op�on
so. If your key is insufficient length rela�ve to the algorithm that you use, you should also pass in insecure_mode: true ; this will prevent Encryptor f
length. Please see the Depreca�ons sec�ons for more details including an example of how to specify your model with default op�ons from a�r_encryp
Upgrading from a�r_encrypted v2.x to v3.x
A bug was discovered in Encryptor v2.0.0 that inccorectly set the IV when using an AES-*-GCM algorithm. Unfornately fixing this major security issue re
using an AES-*-GCM algorithm from Encryptor v2.0.0. Please see Upgrading to Encryptor v3.0.0 for more info.
It is strongly advised that you re-encrypt your data encrypted with Encryptor v2.0.0. However, you'll have to take special care to re-encrypt. To decrypt
*-GCM algorithm you can use the :v2_gcm_iv op�on.
It is recommended that you implement a strategy to insure that you do not mix the encryp�on implementa�ons of Encryptor. One way to do this is to r
offline.Another way is to add a column that keeps track of what implementa�on was used. The path that you choose will depend on your situta�on. Be
https://github.com/attr-encrypted/encryptor#upgrading-from-v200-to-v300
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 8/9
encryp�ng your data.
class User
attr_encrypted :ssn, key: :encryption_key, v2_gcm_iv: is_decrypting?(:ssn)
def is_decrypting?(attribute)
encrypted_attributes[attribute][:operation] == :decrypting
end
end
User.all.each do |user|
old_ssn = user.ssn
user.ssn= old_ssn
user.save
end
Things to consider before using a�r_encrypted
Searching, joining, etc
While choosing to encrypt at the a�ribute level is the most secure solu�on, it is not without drawbacks. Namely, you cannot search the encrypted data
either. You also can't use joins on the encrypted data. Data that is securely encrypted is effec�vely noise. So any opera�ons that rely on the data not be
aforemen�oned opera�ons, please consider using database and file system encryp�on along with transport encryp�on as it moves through your stack.
Data leaks
Please also consider where your data leaks. If you're using a�r_encrypted with Rails, it's highly likely that this data will enter your app as a request param
request params from you logs or else your data is si�ng in the clear in your logs. Parameter Filtering in Rails Please also consider other possible leak po
Storage requirements
When storing your encrypted data, please consider the length requirements of the db column that you're storing the cipher text in. Older versions of M
are too large for the column. When this happens, you will not be able to decrypt your data. MySQL Strict Trans
Metadata regarding your crypto implementa�on
It is advisable to also store metadata regarding the circumstances of your encrypted data. Namely, you should store informa�on about the key used to e
this metadata with every record will make key rota�on and migra�ng to a new algorithm signficantly easier. It will allow you to con�nue to decrypt old d
and new data can be encrypted using your new key and algorithm of choice.
Enforcing the IV as a nonce
On a related note, most algorithms require that your IV be unique for every record and key combina�on. You can enforce this using composite unique in
column. RFC 5084Unique key per record
Lastly, while the :per_attribute_iv_and_salt mode is more secure than :per_attribute_iv mode because it uses a unique key per record, it us
performance hit (175x slower by my benchmarks). There are other ways of deriving a unique key per record that would be much faster.
Note on Patches/Pull Requests
Fork the project.
Make your feature addi�on or bug fix.
Add tests for it. This is important so I don't break it in a future version uninten�onally.
Commit, do not mess with rakefile, version, changelog, or history.
Send me a pull request. Bonus points for topic branches.
NAVIGATION
Home
Categories
Trends
Documenta�on
News
Search
WHO
The Ruby Toolbox is brought to
you from Hamburg since 2009 by
Christoph Olszowka
If you want to personally say hi or
complain, you can do so via mail
CONTRIBUTING
You can find the source code for
this site on github.
The categoriza�on of gems is
handled via the catalog, which
you can also find on Github
LINKS
Code of Conduct
Community Chat Room
RSS Feed
rubytoolbox/rubytoolbox
rubytoolbox/catalog
Produc�on Database Exports
http://apidock.com/rails/ActionDispatch/Http/FilterParameters
http://www.davidpashley.com/2009/02/15/silently-truncated/
https://tools.ietf.org/html/rfc5084#section-1.5
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/categories
https://www.ruby-toolbox.com/trends
https://www.ruby-toolbox.com/pages/docs/index
https://www.ruby-toolbox.com/blog
https://www.ruby-toolbox.com/search
http://www.olszowka.de/
https://github.com/rubytoolbox/rubytoolbox
https://github.com/rubytoolbox/catalog
https://github.com/rubytoolbox/catalog
https://github.com/rubytoolbox/rubytoolbox/blob/main/CODE_OF_CONDUCT.md
https://gitter.im/rubytoolbox/Lobby
https://www.ruby-toolbox.com/blog.rss
https://github.com/rubytoolbox/rubytoolbox
https://github.com/rubytoolbox/catalog
https://data.ruby-toolbox.com/
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search
18/07/2021 Project: attr_encrypted - The Ruby Toolbox
https://www.ruby-toolbox.com/projects/attr_encrypted 9/9
to me at christoph (at) ruby-
toolbox (dot) com
You can also find me on Twi�er as
@thedeadserious and on Github
Contribu�ons welcome !
Sponsors
DEVELOPMENT FUNDED BY HOSTED ON MONITORED WITH
THANK YOU!
https://twitter.com/thedeadserious
https://github.com/colszowka
https://github.com/rubytoolbox
https://rubytogether.org/
https://heroku.com/
https://appsignal.com/
https://www.ruby-toolbox.com/
https://www.ruby-toolbox.com/search