From 669913418bbce819197c12d5bab66e62307e112e Mon Sep 17 00:00:00 2001 From: Peter Taoussanis Date: Fri, 24 Jul 2020 20:40:46 +0200 Subject: [PATCH] v2.15.0 --- index.html | 3 +- taoensso.nippy.benchmarks.html | 2 +- taoensso.nippy.compression.html | 2 +- taoensso.nippy.crypto.html | 39 +++----- taoensso.nippy.encryption.html | 7 +- taoensso.nippy.html | 164 +++++++++++++++++++++++++------- taoensso.nippy.tools.html | 10 +- taoensso.nippy.utils.html | 2 +- 8 files changed, 156 insertions(+), 73 deletions(-) diff --git a/index.html b/index.html index 39efe00..ce90648 100644 --- a/index.html +++ b/index.html @@ -1,4 +1,5 @@ -Nippy 2.13.0

Project

Namespaces

Nippy 2.13.0

Released under the Eclipse Public License

High-performance serialization library for Clojure.

Installation

To install, add the following dependency to your project or build file:

[com.taoensso/nippy "2.13.0"]

Namespaces

taoensso.nippy

High-performance serialization library for Clojure

Public variables and functions:

taoensso.nippy.benchmarks

Public variables and functions:
taoensso.nippy.compression
Public variables and functions:
taoensso.nippy.encryption
Simple no-nonsense crypto with reasonable defaults
Public variables and functions:
taoensso.nippy.tools
Utils for 3rd-party tools that want to add user-configurable Nippy support.
+Nippy 2.15.0
Project
Namespaces
Nippy 2.15.0
Released under the Eclipse Public License
High-performance serialization library for Clojure.
Installation
To install, add the following dependency to your project or build file:
[com.taoensso/nippy "2.15.0"]
Namespaces
taoensso.nippy
High-performance serialization library for Clojure
Public variables and functions:
taoensso.nippy.benchmarks
Public variables and functions:
taoensso.nippy.compression
Public variables and functions:
taoensso.nippy.crypto
Low-level crypto utils.
+Private & alpha, very likely to change!
Public variables and functions:
taoensso.nippy.encryption
Simple no-nonsense crypto with reasonable defaults
Public variables and functions:
taoensso.nippy.tools
Utils for 3rd-party tools that want to add user-configurable Nippy support.
 Used by Carmine, Faraday, etc.
Public variables and functions:
taoensso.nippy.utils
Public variables and functions:

\ No newline at end of file
diff --git a/taoensso.nippy.benchmarks.html b/taoensso.nippy.benchmarks.html
index 9f96d8c..38b8d78 100644
--- a/taoensso.nippy.benchmarks.html
+++ b/taoensso.nippy.benchmarks.html
@@ -1,3 +1,3 @@
 
-taoensso.nippy.benchmarks documentation
Project
Namespaces
Public Vars
taoensso.nippy.benchmarks
bench
(bench {:keys [reader? lzma2? fressian? laps], :or {laps 1}})
view source
bench*
macro
(bench* & body)
view source
bench1
(bench1 freezer thawer & [sizer])
view source
fressian-freeze
(fressian-freeze value)
view source
fressian-thaw
(fressian-thaw value)
view source

\ No newline at end of file
+taoensso.nippy.benchmarks documentation
Project
Namespaces
Public Vars
taoensso.nippy.benchmarks
bench
(bench {:keys [reader? lzma2? fressian? laps], :or {laps 1}})
view source
bench*
macro
(bench* & body)
view source
bench1
(bench1 freezer thawer & [sizer])
view source
fressian-freeze
(fressian-freeze value)
view source
fressian-thaw
(fressian-thaw value)
view source

\ No newline at end of file
diff --git a/taoensso.nippy.compression.html b/taoensso.nippy.compression.html
index c52b48a..7d61352 100644
--- a/taoensso.nippy.compression.html
+++ b/taoensso.nippy.compression.html
@@ -1,6 +1,6 @@
 
-taoensso.nippy.compression documentation
Project
Namespaces
Public Vars
taoensso.nippy.compression
ICompressor
protocol
members
compress
(compress compressor ba)
decompress
(decompress compressor ba)
header-id
(header-id compressor)
view source
lz4-compressor
Default net.jpountz.lz4 compressor:
+taoensso.nippy.compression documentation
Project
Namespaces
Public Vars
taoensso.nippy.compression
ICompressor
protocol
members
compress
(compress compressor ba)
decompress
(decompress compressor ba)
header-id
(header-id compressor)
view source
lz4-compressor
Default net.jpountz.lz4 compressor:
       Ratio: low.
 Write speed: very high.
  Read speed: very high.
diff --git a/taoensso.nippy.crypto.html b/taoensso.nippy.crypto.html
index a6eb284..beb9355 100644
--- a/taoensso.nippy.crypto.html
+++ b/taoensso.nippy.crypto.html
@@ -1,28 +1,11 @@
-
-taoensso.nippy.crypto documentation
taoensso.nippy.crypto documentation
Alpha - subject to change.
-Simple no-nonsense crypto with reasonable defaults. Because your Clojure data
-deserves some privacy.
aes128-cached
USE CASE: You want only a small, finite number of passwords (e.g. a limited
-           number of staff/admins, or you'll be using a single password to
-           encrypt many items).
-
-IMPLEMENTATION: Uses a _very_ expensive (but cached) key hash, and no salt.
-
-PROS: Great amortized encryption/decryption speed. Expensive key hash makes
-      attacking any particular key very difficult.
-CONS: Using a small number of keys for many encrypted items means that if any
-      key _is_ somehow compromised, _all_ items encrypted with that key are
-      compromised.
-
-Faster than `aes128-salted`, and harder to attack any particular key - but
-increased danger if a key is somehow compromised.
aes128-salted
USE CASE: You want more than a small, finite number of passwords (e.g. each
-           item encrypted will use a unique user-provided password).
-
-IMPLEMENTATION: Uses a relatively cheap key hash, but automatically salts
-                every key.
-
-PROS: Each key is independent so would need to be attacked independently.
-CONS: Key caching impossible, so there's an inherent trade-off between
-      encryption/decryption speed and the difficulty of attacking any
-      particular key.
-
-Slower than `aes128-cached`, and easier to attack any particular key.

\ No newline at end of file
+
+taoensso.nippy.crypto documentation
Project
Namespaces
Public Vars
taoensso.nippy.crypto
Low-level crypto utils.
+Private & alpha, very likely to change!
cbc-cipher
(cbc-cipher)
view source
cipher-kit-aes-cbc
Default CipherKit for AES CBC
+
view source
cipher-kit-aes-gcm
Default CipherKit for AES GCM
+
view source
decrypt
(decrypt {:keys [cipher-kit salt-size salt->key-fn enc-ba], :or {cipher-kit cipher-kit-aes-gcm}})
view source
encrypt
(encrypt {:keys [cipher-kit ?salt-ba key-ba plain-ba rand-bytes-fn], :or {cipher-kit cipher-kit-aes-gcm, rand-bytes-fn rand-bytes}})
view source
gcm-cipher
(gcm-cipher)
view source
ICipherKit
protocol
members
get-cipher
(get-cipher _)
Returns a thread-safe `javax.crypto.Cipher` instance.
+
get-iv-size
(get-iv-size _)
Returns necessary iv-ba length.
+
get-key-spec
(get-key-spec _ ba)
Returns a `javax.crypto.spec.SecretKeySpec`.
+
get-param-spec
(get-param-spec _ iv-ba)
Returns a `java.security.spec.AlgorithmParameters`.
+
view source
murmur3
(murmur3 s)
view source
pwd-as-ba
(pwd-as-ba utf8-or-ba)
view source
rand-bool
(rand-bool)
view source
rand-bytes
(rand-bytes size)
view source
rand-double
(rand-double)
view source
rand-gauss
(rand-gauss)
view source
rand-long
(rand-long)(rand-long n)
view source
rand-nth
(rand-nth coll)
view source
sha256-ba
(sha256-ba ba)
view source
sha256-md
(sha256-md)
view source
sha512-ba
(sha512-ba ba)
view source
sha512-key-ba
(sha512-key-ba ?salt-ba utf8-or-ba)(sha512-key-ba ?salt-ba utf8-or-ba n-rounds)
SHA512-based key generator. Good JVM availability without extra dependencies
+(PBKDF2, bcrypt, scrypt, etc.). Decent security when using many rounds.
view source
sha512-md
(sha512-md)
view source
take-ba
(take-ba n ba)
view source
utf8->ba
(utf8->ba s)
view source

\ No newline at end of file
diff --git a/taoensso.nippy.encryption.html b/taoensso.nippy.encryption.html
index 35bdecc..6fddd25 100644
--- a/taoensso.nippy.encryption.html
+++ b/taoensso.nippy.encryption.html
@@ -1,7 +1,8 @@
 
-taoensso.nippy.encryption documentation
Project
Namespaces
Public Vars
taoensso.nippy.encryption
Simple no-nonsense crypto with reasonable defaults
-
aes128-encryptor
Default 128bit AES encryptor with many-round SHA-512 key-gen.
+taoensso.nippy.encryption documentation
Project
Namespaces
Public Vars
taoensso.nippy.encryption
Simple no-nonsense crypto with reasonable defaults
+
aes128-cbc-encryptor
Default 128bit AES-CBC encryptor with many-round SHA-512 key-gen.
+See also `aes-128-cbc-encryptor`.
view source
aes128-gcm-encryptor
Default 128bit AES-GCM encryptor with many-round SHA-512 key-gen.
 
 Password form [:salted "my-password"]
 ---------------------------------------
@@ -34,5 +35,5 @@ CONS: Using a small number of keys for many encrypted items means that if any
       compromised.
 
 Faster than `aes128-salted`, and harder to attack any particular key - but
-increased danger if a key is somehow compromised.
view source
IEncryptor
protocol
members
decrypt
(decrypt encryptor pwd ba)
encrypt
(encrypt encryptor pwd ba)
header-id
(header-id encryptor)
view source
standard-header-ids
These'll support :auto thaw
+increased danger if a key is somehow compromised.
view source
IEncryptor
protocol
members
decrypt
(decrypt encryptor pwd ba)
encrypt
(encrypt encryptor pwd ba)
header-id
(header-id encryptor)
view source
standard-header-ids
These'll support :auto thaw
 
view source

\ No newline at end of file
diff --git a/taoensso.nippy.html b/taoensso.nippy.html
index ad2ab4c..2734130 100644
--- a/taoensso.nippy.html
+++ b/taoensso.nippy.html
@@ -1,12 +1,69 @@
 
-taoensso.nippy documentation
Project
Namespaces
Public Vars
taoensso.nippy
High-performance serialization library for Clojure
+taoensso.nippy documentation
Project
Namespaces
Public Vars
taoensso.nippy
High-performance serialization library for Clojure
 
*auto-freeze-compressor*
dynamic
(fn [byte-array])->compressor used by `(freeze <x> {:compressor :auto}),
-nil => default
view source
*custom-readers*
dynamic
{<hash-or-byte-id> (fn [data-input])}
-
view source
*final-freeze-fallback*
dynamic
DEPRECATED
-
view source
*freeze-fallback*
dynamic
(fn [data-output x]), nil => default
-
view source
-cache-proxy
{[<x> <meta>] <idx>} for freezing, {<idx> <x-with-meta>} for thawing.
-
view source
aes128-encryptor
Default 128bit AES encryptor with many-round SHA-512 key-gen.
+nil => default
view source
*custom-readers*
dynamic
{<hash-or-byte-id> (fn [data-input])->read}
+
view source
*final-freeze-fallback*
dynamic
DEPRECATED: prefer `*freeze-fallback`.
+
view source
*freeze-fallback*
dynamic
(fn [data-output x])->freeze, nil => default
+
view source
*serializable-whitelist*
dynamic
Used when attempting to freeze or thaw an object that:
+  - Does not implement Nippy's Freezable    protocol.
+  - Does     implement Java's  Serializable interface.
+
+In this case, Java's Serializable interface will be permitted iff
+the predicate (*serializable-whitelist* <class-name>) returns true.
+
+I.e. this is a predicate (fn [class-name]) that specifies whether
+Nippy may use a given class's Serializable implementation as
+fallback when its own protocol is unfamiliar with the type.
+
+This is a security measure to prevent Remote Code Execution (RCE).
+
+Context:
+
+  Reading arbitrary Serializable classes can be dangerous if they
+  come from an untrusted source.
+
+  Specifically: if your classpath contains a vulnerable ("gadget")
+  class - it is possible for an attacker to produce an object that
+  can run arbitrary code when read via Serializable.
+
+  Note that Clojure <= 1.8 itself contains such a class [1].
+
+What to use as a whitelist?
+
+  1. If you DO NOT wish to support Serializable: `#{}` is safest,
+     and just entirely disallows its use.
+
+  2. If you DO with to support Serializable:
+
+    2a. If you might serialize data from an untrusted source, or
+        if you'll only be serializing a limited number of known
+        classes: enumerate those class names, e.g.:
+          `#{"java.lang.Throwable", ...}`.
+
+    2b. If you're CERTAIN to NEVER serialize data from an untrusted
+        source, you can use `(constantly true)` as predicate. This
+        will whitelist everything, allowing Serializable for ANY class.
+
+Default value as of v2.15.0 is: #{}.
+
+PRs welcome for additional known-safe classes to be added to default
+whitelist.
+
+Note: if `thaw` encounters an unwhitelisted Serialized class:
+
+  - `thaw` will throw if it's not possible to safely quarantine.
+  - Otherwise the object will be thawed as:
+    `{:nippy/unthawable {:class-name _ :content <quarantined-ba> ...}}`.
+
+Thanks to Timo Mihaljov (@solita-timo-mihaljov) for an excellent report
+identifying this vulnerability.
+
+See also `swap-serializable-whitelist!`.
+
+[1] https://groups.google.com/forum/#!msg/clojure/WaL3hHzsevI/7zHU-L7LBQAJ
view source
-cache-proxy
{[<x> <meta>] <idx>} for freezing, {<idx> <x-with-meta>} for thawing.
+
view source
aes128-cbc-encryptor
Default 128bit AES-CBC encryptor with many-round SHA-512 key-gen.
+See also `aes-128-cbc-encryptor`.
view source
aes128-encryptor
Default 128bit AES-GCM encryptor with many-round SHA-512 key-gen.
 
 Password form [:salted "my-password"]
 ---------------------------------------
@@ -39,13 +96,46 @@ CONS: Using a small number of keys for many encrypted items means that if any
       compromised.
 
 Faster than `aes128-salted`, and harder to attack any particular key - but
-increased danger if a key is somehow compromised.
view source
cache
(cache x)
Experimental, subject to change.
+increased danger if a key is somehow compromised.
view source
aes128-gcm-encryptor
Default 128bit AES-GCM encryptor with many-round SHA-512 key-gen.
+
+Password form [:salted "my-password"]
+---------------------------------------
+USE CASE: You want more than a small, finite number of passwords (e.g. each
+          item encrypted will use a unique user-provided password).
+
+IMPLEMENTATION: Uses a relatively cheap key hash, but automatically salts
+                every key.
+
+PROS: Each key is independent so would need to be attacked independently.
+CONS: Key caching impossible, so there's an inherent trade-off between
+      encryption/decryption speed and the difficulty of attacking any
+      particular key.
+
+Slower than `aes128-cached`, and easier to attack any particular key - but
+keys are independent.
+
+Password form [:cached "my-password"]
+---------------------------------------
+USE CASE: You want only a small, finite number of passwords (e.g. a limited
+          number of staff/admins, or you'll be using a single password to
+          encrypt many items).
+
+IMPLEMENTATION: Uses a _very_ expensive (but cached) key hash, and no salt.
+
+PROS: Great amortized encryption/decryption speed. Expensive key hash makes
+      attacking any particular key very difficult.
+CONS: Using a small number of keys for many encrypted items means that if any
+      key _is_ somehow compromised, _all_ items encrypted with that key are
+      compromised.
+
+Faster than `aes128-salted`, and harder to attack any particular key - but
+increased danger if a key is somehow compromised.
view source
cache
(cache x)
Experimental, subject to change.
 
 Wraps value so that future writes of the same wrapped value with same
 metadata will be efficiently encoded as references to this one.
 
 (freeze [(cache "foo") (cache "foo") (cache "foo")])
-  will incl. a single "foo", plus 2x single-byte references to "foo".
view source
compress
(compress compressor ba)
view source
decompress
(decompress compressor ba)
view source
decrypt
(decrypt encryptor pwd ba)
view source
encrypt
(encrypt encryptor pwd ba)
view source
extend-freeze
macro
(extend-freeze type custom-type-id [x out] & body)
Extends Nippy to support freezing of a custom type (ideally concrete) with
+  will incl. a single "foo", plus 2x single-byte references to "foo".
view source
compress
(compress compressor ba)
view source
decompress
(decompress compressor ba)
view source
decrypt
(decrypt encryptor pwd ba)
view source
encrypt
(encrypt encryptor pwd ba)
view source
extend-freeze
macro
(extend-freeze type custom-type-id [x out] & body)
Extends Nippy to support freezing of a custom type (ideally concrete) with
 given id of form:
   * Keyword           - 2 byte overhead, resistent to id collisions
   * Integer ∈[1, 128] - no overhead, subject to id collisions
@@ -57,37 +147,37 @@ NB: be careful about extending to interfaces, Ref. view source
extend-thaw
macro
(extend-thaw custom-type-id [in] & body)
Extends Nippy to support thawing of a custom type with given id:
+  (.writeUTF [data-output] (:data x)))
view source
extend-thaw
macro
(extend-thaw custom-type-id [in] & body)
Extends Nippy to support thawing of a custom type with given id:
 (extend-thaw :foo/my-type [data-input] ; Keyword id
   (MyRec. (.readUTF data-input)))
 ;; or
 (extend-thaw 1 [data-input] ; Byte id
-  (MyRec. (.readUTF data-input)))
view source
fast-freeze
(fast-freeze x)
Like `freeze` but:
+  (MyRec. (.readUTF data-input)))
view source
fast-freeze
(fast-freeze x)
Like `freeze` but:
   - Writes data without a Nippy header
   - Drops all support for compression and encryption
   - Must be thawed with `fast-thaw`
 
 Equivalent to (but a little faster than):
-  `(freeze x {:compressor nil :encryptor nil :no-header? true})
view source
fast-thaw
(fast-thaw ba)
Like `thaw` but:
+  `(freeze x {:compressor nil :encryptor nil :no-header? true})
view source
fast-thaw
(fast-thaw ba)
Like `thaw` but:
   - Drops all support for compression and encryption
   - Supports only data frozen with `fast-freeze`
 
 Equivalent to (but a little faster than):
-  `(thaw x {:compressor nil :encryptor nil :no-header? true})
view source
freezable?
(freezable? x)(freezable? x {:keys [allow-clojure-reader? allow-java-serializable?]})
Alpha - subject to change.
+  `(thaw x {:compressor nil :encryptor nil :no-header? true})
view source
freezable?
(freezable? x)(freezable? x {:keys [allow-clojure-reader? allow-java-serializable?]})
Alpha - subject to change.
 Returns truthy iff Nippy *appears* to support freezing the given argument.
 
 `:allow-clojure-reader?` and `:allow-java-serializable?` options may be
 used to enable the relevant roundtrip fallback test(s). These tests are
 only **moderately reliable** since they're cached by arg type and don't
 test for pre/post serialization value equality (there's no good general
-way of doing so).
view source
freeze
(freeze x)(freeze x {:keys [compressor encryptor password], :or {compressor :auto, encryptor aes128-encryptor}, :as opts})
Serializes arg (any Clojure data type) to a byte array. To freeze custom
-types, extend the Clojure reader or see `extend-freeze`.
view source
freeze-fallback-as-str
DEPRECATED
-
view source
freeze-to-file
(freeze-to-file file x)(freeze-to-file file x freeze-opts)
Convenience util: writes `(freeze x freeze-opts)` byte array to
-`(clojure.java.io/file file)` and returns the byte array.
-
-(freeze-to-file "my-filename.npy" my-val) => Serialized byte array
view source
freeze-to-out!
(freeze-to-out! data-output x)
Serializes arg (any Clojure data type) to a DataOutput.
-This is a low-level util: in most cases you'll want `freeze` instead.
view source
IFreezable1
protocol
members
-freeze-without-meta!
(-freeze-without-meta! x data-output)
view source
IFreezable2
protocol
members
-freeze-with-meta!
(-freeze-with-meta! x data-output)
view source
inspect-ba
(inspect-ba ba)(inspect-ba ba thaw-opts)
Alpha - subject to change
-
view source
lz4-compressor
Default net.jpountz.lz4 compressor:
+way of doing so).
view source
freeze
(freeze x)(freeze x {:as opts, :keys [compressor encryptor password], :or {compressor :auto, encryptor aes128-gcm-encryptor}})
Serializes arg (any Clojure data type) to a byte array. To freeze custom
+types, extend the Clojure reader or see `extend-freeze`.
view source
freeze-fallback-as-str
DEPRECATED
+
view source
freeze-to-file
(freeze-to-file file x)(freeze-to-file file x freeze-opts)
Convenience util: like `freeze`, but writes to `(clojure.java.io/file <file>)`
+and returns the byte array written.
+See also `thaw-from-file`.
view source
freeze-to-out!
(freeze-to-out! data-output x)
Serializes arg (any Clojure data type) to a DataOutput.
+This is a low-level util: in most cases you'll want `freeze` instead.
view source
freeze-to-string
(freeze-to-string x)(freeze-to-string x freeze-opts)
Convenience util: like `freeze`, but returns a Base64-encoded string.
+See also `thaw-from-string`.
view source
IFreezable1
protocol
members
-freeze-without-meta!
(-freeze-without-meta! x data-output)
view source
IFreezable2
protocol
members
-freeze-with-meta!
(-freeze-with-meta! x data-output)
view source
inspect-ba
(inspect-ba ba)(inspect-ba ba thaw-opts)
Alpha - subject to change
+
view source
lz4-compressor
Default net.jpountz.lz4 compressor:
       Ratio: low.
 Write speed: very high.
  Read speed: very high.
@@ -95,22 +185,30 @@ Write speed: very high.
 A good general-purpose compressor, competitive with Snappy.
 
 Thanks to Max Penet (@mpenet) for our first implementation,
-Ref. https://github.com/mpenet/nippy-lz4
view source
lz4hc-compressor
Like `lz4-compressor` but trades some write speed for ratio.
-
view source
lzma2-compressor
Default org.tukaani.xz.LZMA2 compressor:
+Ref. https://github.com/mpenet/nippy-lz4
view source
lz4hc-compressor
Like `lz4-compressor` but trades some write speed for ratio.
+
view source
lzma2-compressor
Default org.tukaani.xz.LZMA2 compressor:
       Ratio: high.
 Write speed: _very_ slow (also currently single-threaded).
  Read speed: slow.
 
 A specialized compressor for large, low-write data in space-sensitive
-environments.
view source
set-auto-freeze-compressor!
(set-auto-freeze-compressor! x)
view source
set-freeze-fallback!
(set-freeze-fallback! x)
view source
snappy-compressor
Default org.iq80.snappy.Snappy compressor:
+environments.
view source
set-auto-freeze-compressor!
(set-auto-freeze-compressor! x)
view source
set-freeze-fallback!
(set-freeze-fallback! x)
view source
snappy-compressor
Default org.iq80.snappy.Snappy compressor:
       Ratio: low.
 Write speed: very high.
  Read speed: very high.
 
-A good general-purpose compressor.
view source
stress-data
Reference data used for tests & benchmarks
-
view source
stress-data-benchable
Reference data with stuff removed that breaks reader or other utils we'll
-be benching against
view source
stress-data-comparable
Reference data with stuff removed that breaks roundtrip equality
-
view source
swap-custom-readers!
(swap-custom-readers! f)
view source
thaw
(thaw ba)(thaw ba {:keys [v1-compatibility? compressor encryptor password], :or {compressor :auto, encryptor :auto}, :as opts})
Deserializes a frozen Nippy byte array to its original Clojure data type.
+A good general-purpose compressor.
view source
stress-data
Reference data used for tests & benchmarks
+
view source
stress-data-benchable
Reference data with stuff removed that breaks reader or other utils we'll
+be benching against
view source
stress-data-comparable
Reference data with stuff removed that breaks roundtrip equality
+
view source
swap-custom-readers!
(swap-custom-readers! f)
view source
swap-serializable-whitelist!
(swap-serializable-whitelist! f)
Changes root `*serializable-whitelist*` value to (f old-val).
+Example `f` arguments:
+
+  - (fn [_old] true)                                ; Whitelist everything (allow    all classes)
+  - (fn [_old] #{})                                 ; Whitelist nothing    (disallow all classes)
+  - (fn [_old] #{"java.lang.Throwable"})          ; Reset class    whitelist
+  - (fn [ old] (conj old "java.lang.Throwable"))) ; Add   class to whitelist
+
+See also `*serializable-whitelist*.
view source
thaw
(thaw ba)(thaw ba {:as opts, :keys [v1-compatibility? compressor encryptor password], :or {compressor :auto, encryptor :auto}})
Deserializes a frozen Nippy byte array to its original Clojure data type.
 To thaw custom types, extend the Clojure reader or see `extend-thaw`.
 
 ** By default, supports data frozen with Nippy v2+ ONLY **
@@ -120,13 +218,13 @@ legacy versions of Nippy.
 Options include:
   :v1-compatibility? - support data frozen by legacy versions of Nippy?
   :compressor - :auto (checks header, default)  an ICompressor, or nil
-  :encryptor  - :auto (checks header, default), an IEncryptor,  or nil
view source
thaw-from-file
(thaw-from-file file)(thaw-from-file file thaw-opts)
Convenience util: returns `(thaw ba thaw-opts)` Clojure value for the
-byte array read from `(clojure.java.io/file file)`.
-
-(thaw-from-file "my-filename.npy") => Deserialized Clojure value
+  :encryptor  - :auto (checks header, default), an IEncryptor,  or nil
view source
thaw-from-file
(thaw-from-file file)(thaw-from-file file thaw-opts)
Convenience util: like `thaw`, but reads from `(clojure.java.io/file <file>)`.
 
 To thaw from a resource on classpath (e.g in Leiningen `resources` dir):
-  (thaw-from-file (clojure.java.io/resource "my-resource-name.npy"))
view source
thaw-from-in!
(thaw-from-in! data-input)
Deserializes a frozen object from given DataInput to its original Clojure
+  (thaw-from-file (clojure.java.io/resource "my-resource-name.npy"))
+
+See also `freeze-to-file`.
view source
thaw-from-in!
(thaw-from-in! data-input)
Deserializes a frozen object from given DataInput to its original Clojure
 data type.
 
-This is a low-level util: in most cases you'll want `thaw` instead.
view source
throw-unfreezable
(throw-unfreezable x)
view source
try-write-readable
(try-write-readable out x)
view source
try-write-serializable
(try-write-serializable out x)
view source
write-id
macro
(write-id out id)
view source
write-unfreezable
(write-unfreezable out x)
view source

\ No newline at end of file
+This is a low-level util: in most cases you'll want `thaw` instead.
view source
thaw-from-string
(thaw-from-string s)(thaw-from-string s thaw-opts)
Convenience util: like `thaw`, but takes a Base64-encoded string.
+See also `freeze-to-string`.
view source
throw-unfreezable
(throw-unfreezable x)
view source
try-write-readable
(try-write-readable out x)
view source
try-write-serializable
(try-write-serializable out x)
view source
write-id
macro
(write-id out id)
view source
write-unfreezable
(write-unfreezable out x)
view source

\ No newline at end of file
diff --git a/taoensso.nippy.tools.html b/taoensso.nippy.tools.html
index fdb4e7b..1a737eb 100644
--- a/taoensso.nippy.tools.html
+++ b/taoensso.nippy.tools.html
@@ -1,8 +1,8 @@
 
-taoensso.nippy.tools documentation
Project
Namespaces
Public Vars
taoensso.nippy.tools
Utils for 3rd-party tools that want to add user-configurable Nippy support.
-Used by Carmine, Faraday, etc.
*freeze-opts*
dynamic
view source
*thaw-opts*
dynamic
view source
freeze
(freeze x)(freeze x default-opts)
Like `nippy/freeze` but merges opts from *freeze-opts*, `wrap-for-freezing`.
-
view source
thaw
(thaw ba)(thaw ba default-opts)
Like `nippy/thaw` but merges opts  from `*thaw-opts*`.
-
view source
with-freeze-opts
macro
(with-freeze-opts opts & body)
view source
with-thaw-opts
macro
(with-thaw-opts opts & body)
view source
wrap-for-freezing
(wrap-for-freezing x)(wrap-for-freezing x opts)
Ensures that given arg (any freezable data type) is wrapped so that
+taoensso.nippy.tools documentation
Project
Namespaces
Public Vars
taoensso.nippy.tools
Utils for 3rd-party tools that want to add user-configurable Nippy support.
+Used by Carmine, Faraday, etc.
*freeze-opts*
dynamic
view source
*thaw-opts*
dynamic
view source
freeze
(freeze x)(freeze x default-opts)
Like `nippy/freeze` but merges opts from *freeze-opts*, `wrap-for-freezing`.
+
view source
thaw
(thaw ba)(thaw ba default-opts)
Like `nippy/thaw` but merges opts  from `*thaw-opts*`.
+
view source
with-freeze-opts
macro
(with-freeze-opts opts & body)
view source
with-thaw-opts
macro
(with-thaw-opts opts & body)
view source
wrap-for-freezing
(wrap-for-freezing x)(wrap-for-freezing x opts)
Ensures that given arg (any freezable data type) is wrapped so that
 (tools/freeze <wrapped-arg>) will serialize as
-(nippy/freeze <unwrapped-arg> <opts>).
view source
wrapped-for-freezing?
(wrapped-for-freezing? x)
view source

\ No newline at end of file
+(nippy/freeze <unwrapped-arg> <opts>).
view source
wrapped-for-freezing?
(wrapped-for-freezing? x)
view source

\ No newline at end of file
diff --git a/taoensso.nippy.utils.html b/taoensso.nippy.utils.html
index 684d95f..6d39943 100644
--- a/taoensso.nippy.utils.html
+++ b/taoensso.nippy.utils.html
@@ -1,6 +1,6 @@
 
-taoensso.nippy.utils documentation
Project
Namespaces
Public Vars
taoensso.nippy.utils
freezable?
(freezable? x)(freezable? x {:keys [allow-clojure-reader? allow-java-serializable?]})
Alpha - subject to change.
+taoensso.nippy.utils documentation
Project
Namespaces
Public Vars
taoensso.nippy.utils
freezable?
(freezable? x)(freezable? x {:keys [allow-clojure-reader? allow-java-serializable?]})
Alpha - subject to change.
 Returns truthy iff Nippy *appears* to support freezing the given argument.
 
 `:allow-clojure-reader?` and `:allow-java-serializable?` options may be