Title: | Create Compact Hash Digests of R Objects |
---|---|
Description: | Implementation of a function 'digest()' for the creation of hash digests of arbitrary R objects (using the 'md5', 'sha-1', 'sha-256', 'crc32', 'xxhash', 'murmurhash', 'spookyhash', 'blake3', 'crc32c', 'xxh3_64', and 'xxh3_128' algorithms) permitting easy comparison of R language objects, as well as functions such as'hmac()' to create hash-based message authentication code. Please note that this package is not meant to be deployed for cryptographic purposes for which more comprehensive (and widely tested) libraries such as 'OpenSSL' should be used. |
Authors: | Dirk Eddelbuettel [aut, cre] , Antoine Lucas [ctb], Jarek Tuszynski [ctb], Henrik Bengtsson [ctb] , Simon Urbanek [ctb] , Mario Frasca [ctb], Bryan Lewis [ctb], Murray Stokely [ctb], Hannes Muehleisen [ctb] , Duncan Murdoch [ctb], Jim Hester [ctb] , Wush Wu [ctb] , Qiang Kou [ctb] , Thierry Onkelinx [ctb] , Michel Lang [ctb] , Viliam Simko [ctb], Kurt Hornik [ctb] , Radford Neal [ctb] , Kendon Bell [ctb] , Matthew de Queljoe [ctb], Dmitry Selivanov [ctb] , Ion Suruceanu [ctb] , Bill Denney [ctb] , Dirk Schumacher [ctb], András Svraka [ctb] , Sergey Fedorov [ctb] , Will Landau [ctb] , Floris Vanderhaeghe [ctb] , Kevin Tappe [ctb], Harris McGehee [ctb], Tim Mastny [ctb], Aaron Peikert [ctb] , Mark van der Loo [ctb] , Chris Muir [ctb] , Moritz Beller [ctb] , Sebastian Campbell [ctb] , Winston Chang [ctb] , Dean Attali [ctb] , Michael Chirico [ctb] , Kevin Ushey [ctb] , Carl Pearson [ctb] |
Maintainer: | Dirk Eddelbuettel <[email protected]> |
License: | GPL (>= 2) |
Version: | 0.6.37.1 |
Built: | 2024-11-27 05:40:28 UTC |
Source: | https://github.com/eddelbuettel/digest |
This creates an object that can perform the Advanced Encryption Standard (AES) block cipher.
AES(key, mode=c("ECB", "CBC", "CFB", "CTR"), IV=NULL, padding=FALSE)
AES(key, mode=c("ECB", "CBC", "CFB", "CTR"), IV=NULL, padding=FALSE)
key |
The key as a 16, 24 or 32 byte raw vector for AES-128, AES-192 or AES-256 respectively. |
mode |
The encryption mode to use. Currently only “electronic codebook” (ECB), “cipher-block chaining” (CBC), “cipher feedback” (CFB) and “counter” (CTR) modes are supported. |
IV |
The initial vector for CBC and CFB mode or initial counter for CTR mode. |
padding |
Whether or not PKCS#7 padding is used during encryption and decryption in CBC mode. |
The standard NIST definition of CTR mode doesn't define how the counter is updated, it just requires that it be updated with each block and not repeat itself for a long time. This implementation treats it as a 128 bit integer and adds 1 with each successive block.
An object of class "AES"
. This is a list containing the
following component functions:
encrypt(text) |
A function to encrypt a text vector. The text may be a single element character vector or a raw vector. It returns the ciphertext as a raw vector. |
decrypt(ciphertext , raw = FALSE)
|
A function to decrypt the
ciphertext. In ECB mode, the same AES
object can be used for both encryption and decryption, but in
CBC, CFB and CTR modes a new object needs to be
created, using the same initial |
IV() |
Report on the current state of the initialization vector. As blocks are encrypted or decrypted in CBC, CFB or CTR mode, the initialization vector is updated, so both operations can be performed sequentially on subsets of the text or ciphertext. |
block_size() , key_size() , mode()
|
Report on these aspects of the AES object. |
The R interface was written by Duncan Murdoch. The design is loosely based on the Python Crypto implementation. The underlying AES implementation is by Christophe Devine.
United States National Institute of Standards and Technology (2001). "Announcing the ADVANCED ENCRYPTION STANDARD (AES)". Federal Information Processing Standards Publication 197. https://csrc.nist.gov/publications/fips/fips197/fips-197.pdf.
Morris Dworkin (2001). "Recommendation for Block Cipher Modes of Operation". NIST Special Publication 800-38A 2001 Edition.
# First in ECB mode: the repeated block is coded the same way each time msg <- as.raw(c(1:16, 1:16)) key <- as.raw(1:16) aes <- AES(key, mode="ECB") aes$encrypt(msg) aes$decrypt(aes$encrypt(msg), raw=TRUE) # Now in CBC mode: each encoding is different iv <- sample(0:255, 16, replace=TRUE) aes <- AES(key, mode="CBC", iv) code <- aes$encrypt(msg) code # Need a new object for decryption in CBC mode aes <- AES(key, mode="CBC", iv) aes$decrypt(code, raw=TRUE) # In CBC mode, the input length must be a multiple of 16 bytes. # You can use `padding = TRUE` to ensure the input length is always valid. AES(key, mode="CBC", iv, padding = TRUE)$encrypt(as.raw(1:15)) # CFB mode: IV must be the same length as the Block's block size # Two different instances of AES are required for encryption and decryption iv <- sample(0:255, 16, replace=TRUE) aes <- AES(key, mode="CFB", iv) code <- aes$encrypt(msg) code #decrypt aes <- AES(key, mode="CFB", iv) aes$decrypt(code) # FIPS-197 examples hextextToRaw <- function(text) { vals <- matrix(as.integer(as.hexmode(strsplit(text, "")[[1]])), ncol=2, byrow=TRUE) vals <- vals %*% c(16, 1) as.raw(vals) } plaintext <- hextextToRaw("00112233445566778899aabbccddeeff") aes128key <- hextextToRaw("000102030405060708090a0b0c0d0e0f") aes128output <- hextextToRaw("69c4e0d86a7b0430d8cdb78070b4c55a") aes <- AES(aes128key) aes128 <- aes$encrypt(plaintext) stopifnot(identical(aes128, aes128output)) stopifnot(identical(plaintext, aes$decrypt(aes128, raw=TRUE))) aes192key <- hextextToRaw("000102030405060708090a0b0c0d0e0f1011121314151617") aes192output <- hextextToRaw("dda97ca4864cdfe06eaf70a0ec0d7191") aes <- AES(aes192key) aes192 <- aes$encrypt(plaintext) stopifnot(identical(aes192, aes192output)) stopifnot(identical(plaintext, aes$decrypt(aes192, raw=TRUE))) aes256key <- hextextToRaw("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f") aes256output <- hextextToRaw("8ea2b7ca516745bfeafc49904b496089") aes <- AES(aes256key) aes256 <- aes$encrypt(plaintext) stopifnot(identical(aes256, aes256output)) stopifnot(identical(plaintext, aes$decrypt(aes256, raw=TRUE))) # SP800-38a examples plaintext <- hextextToRaw(paste("6bc1bee22e409f96e93d7e117393172a", "ae2d8a571e03ac9c9eb76fac45af8e51", "30c81c46a35ce411e5fbc1191a0a52ef", "f69f2445df4f9b17ad2b417be66c3710",sep="")) key <- hextextToRaw("2b7e151628aed2a6abf7158809cf4f3c") ecb128output <- hextextToRaw(paste("3ad77bb40d7a3660a89ecaf32466ef97", "f5d3d58503b9699de785895a96fdbaaf", "43b1cd7f598ece23881b00e3ed030688", "7b0c785e27e8ad3f8223207104725dd4",sep="")) aes <- AES(key) ecb128 <- aes$encrypt(plaintext) stopifnot(identical(ecb128, ecb128output)) stopifnot(identical(plaintext, aes$decrypt(ecb128, raw=TRUE))) cbc128output <- hextextToRaw(paste("7649abac8119b246cee98e9b12e9197d", "5086cb9b507219ee95db113a917678b2", "73bed6b8e3c1743b7116e69e22229516", "3ff1caa1681fac09120eca307586e1a7",sep="")) iv <- hextextToRaw("000102030405060708090a0b0c0d0e0f") aes <- AES(key, mode="CBC", IV=iv) cbc128 <- aes$encrypt(plaintext) stopifnot(identical(cbc128, cbc128output)) aes <- AES(key, mode="CBC", IV=iv) stopifnot(identical(plaintext, aes$decrypt(cbc128, raw=TRUE))) cfb128output <- hextextToRaw(paste("3b3fd92eb72dad20333449f8e83cfb4a", "c8a64537a0b3a93fcde3cdad9f1ce58b", "26751f67a3cbb140b1808cf187a4f4df", "c04b05357c5d1c0eeac4c66f9ff7f2e6",sep="")) aes <- AES(key, mode="CFB", IV=iv) cfb128 <- aes$encrypt(plaintext) stopifnot(identical(cfb128, cfb128output)) aes <- AES(key, mode="CFB", IV=iv) stopifnot(identical(plaintext, aes$decrypt(cfb128, raw=TRUE))) ctr128output <- hextextToRaw(paste("874d6191b620e3261bef6864990db6ce", "9806f66b7970fdff8617187bb9fffdff", "5ae4df3edbd5d35e5b4f09020db03eab", "1e031dda2fbe03d1792170a0f3009cee",sep="")) iv <- hextextToRaw("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") aes <- AES(key, mode="CTR", IV=iv) ctr128 <- aes$encrypt(plaintext) stopifnot(identical(ctr128, ctr128output)) aes <- AES(key, mode="CTR", IV=iv) stopifnot(identical(plaintext, aes$decrypt(ctr128, raw=TRUE)))
# First in ECB mode: the repeated block is coded the same way each time msg <- as.raw(c(1:16, 1:16)) key <- as.raw(1:16) aes <- AES(key, mode="ECB") aes$encrypt(msg) aes$decrypt(aes$encrypt(msg), raw=TRUE) # Now in CBC mode: each encoding is different iv <- sample(0:255, 16, replace=TRUE) aes <- AES(key, mode="CBC", iv) code <- aes$encrypt(msg) code # Need a new object for decryption in CBC mode aes <- AES(key, mode="CBC", iv) aes$decrypt(code, raw=TRUE) # In CBC mode, the input length must be a multiple of 16 bytes. # You can use `padding = TRUE` to ensure the input length is always valid. AES(key, mode="CBC", iv, padding = TRUE)$encrypt(as.raw(1:15)) # CFB mode: IV must be the same length as the Block's block size # Two different instances of AES are required for encryption and decryption iv <- sample(0:255, 16, replace=TRUE) aes <- AES(key, mode="CFB", iv) code <- aes$encrypt(msg) code #decrypt aes <- AES(key, mode="CFB", iv) aes$decrypt(code) # FIPS-197 examples hextextToRaw <- function(text) { vals <- matrix(as.integer(as.hexmode(strsplit(text, "")[[1]])), ncol=2, byrow=TRUE) vals <- vals %*% c(16, 1) as.raw(vals) } plaintext <- hextextToRaw("00112233445566778899aabbccddeeff") aes128key <- hextextToRaw("000102030405060708090a0b0c0d0e0f") aes128output <- hextextToRaw("69c4e0d86a7b0430d8cdb78070b4c55a") aes <- AES(aes128key) aes128 <- aes$encrypt(plaintext) stopifnot(identical(aes128, aes128output)) stopifnot(identical(plaintext, aes$decrypt(aes128, raw=TRUE))) aes192key <- hextextToRaw("000102030405060708090a0b0c0d0e0f1011121314151617") aes192output <- hextextToRaw("dda97ca4864cdfe06eaf70a0ec0d7191") aes <- AES(aes192key) aes192 <- aes$encrypt(plaintext) stopifnot(identical(aes192, aes192output)) stopifnot(identical(plaintext, aes$decrypt(aes192, raw=TRUE))) aes256key <- hextextToRaw("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f") aes256output <- hextextToRaw("8ea2b7ca516745bfeafc49904b496089") aes <- AES(aes256key) aes256 <- aes$encrypt(plaintext) stopifnot(identical(aes256, aes256output)) stopifnot(identical(plaintext, aes$decrypt(aes256, raw=TRUE))) # SP800-38a examples plaintext <- hextextToRaw(paste("6bc1bee22e409f96e93d7e117393172a", "ae2d8a571e03ac9c9eb76fac45af8e51", "30c81c46a35ce411e5fbc1191a0a52ef", "f69f2445df4f9b17ad2b417be66c3710",sep="")) key <- hextextToRaw("2b7e151628aed2a6abf7158809cf4f3c") ecb128output <- hextextToRaw(paste("3ad77bb40d7a3660a89ecaf32466ef97", "f5d3d58503b9699de785895a96fdbaaf", "43b1cd7f598ece23881b00e3ed030688", "7b0c785e27e8ad3f8223207104725dd4",sep="")) aes <- AES(key) ecb128 <- aes$encrypt(plaintext) stopifnot(identical(ecb128, ecb128output)) stopifnot(identical(plaintext, aes$decrypt(ecb128, raw=TRUE))) cbc128output <- hextextToRaw(paste("7649abac8119b246cee98e9b12e9197d", "5086cb9b507219ee95db113a917678b2", "73bed6b8e3c1743b7116e69e22229516", "3ff1caa1681fac09120eca307586e1a7",sep="")) iv <- hextextToRaw("000102030405060708090a0b0c0d0e0f") aes <- AES(key, mode="CBC", IV=iv) cbc128 <- aes$encrypt(plaintext) stopifnot(identical(cbc128, cbc128output)) aes <- AES(key, mode="CBC", IV=iv) stopifnot(identical(plaintext, aes$decrypt(cbc128, raw=TRUE))) cfb128output <- hextextToRaw(paste("3b3fd92eb72dad20333449f8e83cfb4a", "c8a64537a0b3a93fcde3cdad9f1ce58b", "26751f67a3cbb140b1808cf187a4f4df", "c04b05357c5d1c0eeac4c66f9ff7f2e6",sep="")) aes <- AES(key, mode="CFB", IV=iv) cfb128 <- aes$encrypt(plaintext) stopifnot(identical(cfb128, cfb128output)) aes <- AES(key, mode="CFB", IV=iv) stopifnot(identical(plaintext, aes$decrypt(cfb128, raw=TRUE))) ctr128output <- hextextToRaw(paste("874d6191b620e3261bef6864990db6ce", "9806f66b7970fdff8617187bb9fffdff", "5ae4df3edbd5d35e5b4f09020db03eab", "1e031dda2fbe03d1792170a0f3009cee",sep="")) iv <- hextextToRaw("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff") aes <- AES(key, mode="CTR", IV=iv) ctr128 <- aes$encrypt(plaintext) stopifnot(identical(ctr128, ctr128output)) aes <- AES(key, mode="CTR", IV=iv) stopifnot(identical(plaintext, aes$decrypt(ctr128, raw=TRUE)))
The digest
function applies one of several cryptographic or
non-cryptographics hash function to arbitrary R objects or files. By
default, the objects are internally serialized, and the selected hash
functions algorithms can be used to compute a compact digest of the
serialized object.
In order to compare this implementation with others, serialization of the input argument can also be turned off in which the input argument must be a character string for which its digest is returned.
digest(object, algo=c("md5", "sha1", "crc32", "sha256", "sha512", "xxhash32", "xxhash64", "murmur32", "spookyhash", "blake3", "crc32c", "xxh3_64", "xxh3_128"), serialize=TRUE, file=FALSE, length=Inf, skip="auto", ascii=FALSE, raw=FALSE, seed=0, errormode=c("stop","warn","silent"), serializeVersion=.getSerializeVersion())
digest(object, algo=c("md5", "sha1", "crc32", "sha256", "sha512", "xxhash32", "xxhash64", "murmur32", "spookyhash", "blake3", "crc32c", "xxh3_64", "xxh3_128"), serialize=TRUE, file=FALSE, length=Inf, skip="auto", ascii=FALSE, raw=FALSE, seed=0, errormode=c("stop","warn","silent"), serializeVersion=.getSerializeVersion())
object |
An arbitrary R object which will then be passed to the
|
algo |
The algorithms to be used; currently available choices are
|
serialize |
A logical variable indicating whether the object
should be serialized using |
file |
A logical variable indicating whether the object is a file
name or a file name if |
length |
Number of characters to process. By default, when
|
skip |
Number of input bytes to skip before calculating the
digest. Negative values are invalid and currently treated as zero.
Special value |
ascii |
This flag is passed to the |
raw |
A logical variable with a default value of FALSE, implying
|
seed |
an integer to seed the random number generator. This is only
used in the |
errormode |
A character value denoting a choice for the behaviour in
the case of error: ‘stop’ aborts (and is the default value),
‘warn’ emits a warning and returns |
serializeVersion |
An integer value specifying the internal
version of the serialization format, with 2 being the default;
see |
Cryptographic hash functions are well researched and documented. The MD5 algorithm by Ron Rivest is specified in RFC 1321. The SHA-1 algorithm is specified in FIPS-180-1, SHA-2 is described in FIPS-180-2.
For md5, sha-1 and sha-256, this R implementation relies on standalone implementations in C by Christophe Devine. For crc32, code from the zlib library by Jean-loup Gailly and Mark Adler is used.
For sha-512, a standalone implementation from Aaron Gifford is used.
For xxhash32, xxhash64, xxh3_64 and xxh3_128 the reference implementation by Yann Collet is used.
For murmur32, the progressive implementation by Shane Day is used.
For spookyhash, the original source code by Bob Jenkins is used. The R implementation that integrates R's serialization directly with the algorithm allowing for memory-efficient incremental calculation of the hash is by Gabe Becker.
For blake3, the C implementation by Samuel Neves and Jack O'Connor is used.
For crc32c, the portable (i.e. non-hardware accelerated) version from Google is used.
Please note that this package is not meant to be used for cryptographic purposes for which more comprehensive (and widely tested) libraries such as OpenSSL should be used. Also, it is known that crc32 is not collision-proof. For sha-1, recent results indicate certain cryptographic weaknesses as well. For more details, see for example https://www.schneier.com/blog/archives/2005/02/cryptanalysis_o.html.
The digest
function returns a character string of a fixed
length containing the requested digest of the supplied R object. This
string is of length 32 for MD5; of length 40 for SHA-1; of length 8
for CRC32 a string; of length 8 for for xxhash32; of length 16 for
xxhash64; and of length 8 for murmur32.
Version 0.6.16 of digest corrects an error in which crc32
was not
guaranteeing an eight-character return. We now pad with zero to always
return eight characters. Should the previous behaviour be required,
set option("digestOldCRC32Format"=TRUE)
and the output will be
consistent with prior version (but not be consistentnly eight characters).
Dirk Eddelbuettel [email protected] for the R interface; Antoine Lucas for the integration of crc32; Jarek Tuszynski for the file-based operations; Henrik Bengtsson and Simon Urbanek for improved serialization patches; Christophe Devine for the hash function implementations for sha-1, sha-256 and md5; Jean-Loup Gailly and Mark Adler for crc32; Hannes Muehleisen for the integration of sha-512; Jim Hester for the integration of xxhash32, xxhash64 and murmur32; Kendon Bell for the integration of spookyhash using Gabe Becker's R package fastdigest.
MD5: https://www.ietf.org/rfc/rfc1321.txt.
SHA-1: https://en.wikipedia.org/wiki/SHA-1.
SHA-256: https://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf.
CRC32: The original reference webpage at rocksoft.com
has
vanished from the web; see
https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
general information on CRC algorithms.
https://aarongifford.com/computers/sha.html for the integrated C implementation of sha-512.
The page for the code underlying the C functions used here for sha-1 and md5, and further references, is no longer accessible. Please see https://en.wikipedia.org/wiki/SHA-1 and https://en.wikipedia.org/wiki/MD5.
https://zlib.net for documentation on the zlib library which supplied the code for crc32.
https://en.wikipedia.org/wiki/SHA_hash_functions for documentation on the sha functions.
https://github.com/Cyan4973/xxHash for documentation on the xxHash functions.
https://github.com/aappleby/smhasher for documentation on MurmurHash.
https://burtleburtle.net/bob/hash/spooky.html for the original source code of SpookyHash.
https://github.com/BLAKE3-team/BLAKE3/ for the original source code of blake3.
https://github.com/google/crc32c for the (non-hardware-accelerated) crc32c code.
## Standard RFC 1321 test vectors md5Input <- c("", "a", "abc", "message digest", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", paste("12345678901234567890123456789012345678901234567890123456789012", "345678901234567890", sep="")) md5Output <- c("d41d8cd98f00b204e9800998ecf8427e", "0cc175b9c0f1b6a831c399e269772661", "900150983cd24fb0d6963f7d28e17f72", "f96b697d7cb7938d525a2f31aaf161d0", "c3fcd3d76192e4007dfb496cca67e13b", "d174ab98d277d9f5a5611c2c9f419d9f", "57edf4a22be3c955ac49da2e2107b67a") for (i in seq(along=md5Input)) { md5 <- digest(md5Input[i], serialize=FALSE) stopifnot(identical(md5, md5Output[i])) } sha1Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha1Output <- c("a9993e364706816aba3e25717850c26c9cd0d89d", "84983e441c3bd26ebaae4aa1f95129e5e54670f1") for (i in seq(along=sha1Input)) { sha1 <- digest(sha1Input[i], algo="sha1", serialize=FALSE) stopifnot(identical(sha1, sha1Output[i])) } crc32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") crc32Output <- c("352441c2", "171a3f5f") for (i in seq(along=crc32Input)) { crc32 <- digest(crc32Input[i], algo="crc32", serialize=FALSE) stopifnot(identical(crc32, crc32Output[i])) } sha256Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha256Output <- c("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1") for (i in seq(along=sha256Input)) { sha256 <- digest(sha256Input[i], algo="sha256", serialize=FALSE) stopifnot(identical(sha256, sha256Output[i])) } # SHA 512 example sha512Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha512Output <- c(paste("ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a", "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f", sep=""), paste("204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335", "96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445", sep="")) for (i in seq(along=sha512Input)) { sha512 <- digest(sha512Input[i], algo="sha512", serialize=FALSE) stopifnot(identical(sha512, sha512Output[i])) } ## xxhash32 example xxhash32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") xxhash32Output <- c("32d153ff", "89ea60c3", "02cc5d05") for (i in seq(along=xxhash32Input)) { xxhash32 <- digest(xxhash32Input[i], algo="xxhash32", serialize=FALSE) cat(xxhash32, "\n") stopifnot(identical(xxhash32, xxhash32Output[i])) } ## xxhash64 example xxhash64Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") xxhash64Output <- c("44bc2cf5ad770999", "f06103773e8585df", "ef46db3751d8e999") for (i in seq(along=xxhash64Input)) { xxhash64 <- digest(xxhash64Input[i], algo="xxhash64", serialize=FALSE) cat(xxhash64, "\n") stopifnot(identical(xxhash64, xxhash64Output[i])) } ## these outputs were calculated using mmh3 python package murmur32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") murmur32Output <- c("b3dd93fa", "ee925b90", "00000000") for (i in seq(along=murmur32Input)) { murmur32 <- digest(murmur32Input[i], algo="murmur32", serialize=FALSE) cat(murmur32, "\n") stopifnot(identical(murmur32, murmur32Output[i])) } ## these outputs were calculated using spooky python package spookyInput <- c("a", "abc", "message digest") spookyOutput <- c("bdc9bba09181101a922a4161f0584275", "67c93775f715ab8ab01178caf86713c6", "9630c2a55c0987a0db44434f9d67a192") for (i in seq(along=spookyInput)) { # skip = 30 skips the serialization header and just hashes the strings spooky <- digest(spookyInput[i], algo="spookyhash", skip = 30) cat(spooky, "\n") ## we can only compare to reference output on little-endian systems if (isTRUE(.Call(digest:::is_little_endian))) stopifnot(identical(spooky, spookyOutput[i])) } ## blake3 example blake3Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") blake3Output <- c("6437b3ac38465133ffb63b75273a8db548c558465d79db03fd359c6cd5bd9d85", "c19012cc2aaf0dc3d8e5c45a1b79114d2df42abb2a410bf54be09e891af06ff8", "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262") for (i in seq(along=blake3Input)) { blake3 <- digest(blake3Input[i], algo="blake3", serialize=FALSE) cat(blake3, "\n") stopifnot(identical(blake3, blake3Output[i])) } ## crc32c crc32cInput <- c("123456789", "The quick brown fox jumps over the lazy dog") crc32cOutput <- c("e3069283", "22620404") for (i in seq_along(crc32cInput)) { crc32c <- digest(crc32cInput[i], algo="crc32c", serialize=FALSE) cat(crc32c, "\n") stopifnot(identical(crc32c, crc32cOutput[i])) } # example of a digest of a standard R list structure digest(list(LETTERS, data.frame(a=letters[1:5], b=matrix(1:10,ncol=2)))) # test 'length' parameter and file input fname <- file.path(R.home(),"COPYING") x <- readChar(fname, file.info(fname)$size) # read file for (alg in c("sha1", "md5", "crc32")) { # partial file h1 <- digest(x , length=18000, algo=alg, serialize=FALSE) h2 <- digest(fname, length=18000, algo=alg, serialize=FALSE, file=TRUE) h3 <- digest( substr(x,1,18000) , algo=alg, serialize=FALSE) stopifnot( identical(h1,h2), identical(h1,h3) ) # whole file h1 <- digest(x , algo=alg, serialize=FALSE) h2 <- digest(fname, algo=alg, serialize=FALSE, file=TRUE) stopifnot( identical(h1,h2) ) } # compare md5 algorithm to other tools library(tools) fname <- file.path(R.home(),"COPYING") h1 <- as.character(md5sum(fname)) h2 <- digest(fname, algo="md5", file=TRUE) stopifnot( identical(h1,h2) ) ## digest is _designed_ to return one has summary per object to for a desired ## For vectorised output see digest::getVDigest() which provides ## better performance than base::Vectorize() md5 <- getVDigest() v <- md5(1:5) # digest integers 1 to 5 stopifnot(identical(v[1], digest(1L)), # check first and third result identical(v[3], digest(3L)))
## Standard RFC 1321 test vectors md5Input <- c("", "a", "abc", "message digest", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", paste("12345678901234567890123456789012345678901234567890123456789012", "345678901234567890", sep="")) md5Output <- c("d41d8cd98f00b204e9800998ecf8427e", "0cc175b9c0f1b6a831c399e269772661", "900150983cd24fb0d6963f7d28e17f72", "f96b697d7cb7938d525a2f31aaf161d0", "c3fcd3d76192e4007dfb496cca67e13b", "d174ab98d277d9f5a5611c2c9f419d9f", "57edf4a22be3c955ac49da2e2107b67a") for (i in seq(along=md5Input)) { md5 <- digest(md5Input[i], serialize=FALSE) stopifnot(identical(md5, md5Output[i])) } sha1Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha1Output <- c("a9993e364706816aba3e25717850c26c9cd0d89d", "84983e441c3bd26ebaae4aa1f95129e5e54670f1") for (i in seq(along=sha1Input)) { sha1 <- digest(sha1Input[i], algo="sha1", serialize=FALSE) stopifnot(identical(sha1, sha1Output[i])) } crc32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") crc32Output <- c("352441c2", "171a3f5f") for (i in seq(along=crc32Input)) { crc32 <- digest(crc32Input[i], algo="crc32", serialize=FALSE) stopifnot(identical(crc32, crc32Output[i])) } sha256Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha256Output <- c("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1") for (i in seq(along=sha256Input)) { sha256 <- digest(sha256Input[i], algo="sha256", serialize=FALSE) stopifnot(identical(sha256, sha256Output[i])) } # SHA 512 example sha512Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") sha512Output <- c(paste("ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a", "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f", sep=""), paste("204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335", "96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445", sep="")) for (i in seq(along=sha512Input)) { sha512 <- digest(sha512Input[i], algo="sha512", serialize=FALSE) stopifnot(identical(sha512, sha512Output[i])) } ## xxhash32 example xxhash32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") xxhash32Output <- c("32d153ff", "89ea60c3", "02cc5d05") for (i in seq(along=xxhash32Input)) { xxhash32 <- digest(xxhash32Input[i], algo="xxhash32", serialize=FALSE) cat(xxhash32, "\n") stopifnot(identical(xxhash32, xxhash32Output[i])) } ## xxhash64 example xxhash64Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") xxhash64Output <- c("44bc2cf5ad770999", "f06103773e8585df", "ef46db3751d8e999") for (i in seq(along=xxhash64Input)) { xxhash64 <- digest(xxhash64Input[i], algo="xxhash64", serialize=FALSE) cat(xxhash64, "\n") stopifnot(identical(xxhash64, xxhash64Output[i])) } ## these outputs were calculated using mmh3 python package murmur32Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") murmur32Output <- c("b3dd93fa", "ee925b90", "00000000") for (i in seq(along=murmur32Input)) { murmur32 <- digest(murmur32Input[i], algo="murmur32", serialize=FALSE) cat(murmur32, "\n") stopifnot(identical(murmur32, murmur32Output[i])) } ## these outputs were calculated using spooky python package spookyInput <- c("a", "abc", "message digest") spookyOutput <- c("bdc9bba09181101a922a4161f0584275", "67c93775f715ab8ab01178caf86713c6", "9630c2a55c0987a0db44434f9d67a192") for (i in seq(along=spookyInput)) { # skip = 30 skips the serialization header and just hashes the strings spooky <- digest(spookyInput[i], algo="spookyhash", skip = 30) cat(spooky, "\n") ## we can only compare to reference output on little-endian systems if (isTRUE(.Call(digest:::is_little_endian))) stopifnot(identical(spooky, spookyOutput[i])) } ## blake3 example blake3Input <- c("abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "") blake3Output <- c("6437b3ac38465133ffb63b75273a8db548c558465d79db03fd359c6cd5bd9d85", "c19012cc2aaf0dc3d8e5c45a1b79114d2df42abb2a410bf54be09e891af06ff8", "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262") for (i in seq(along=blake3Input)) { blake3 <- digest(blake3Input[i], algo="blake3", serialize=FALSE) cat(blake3, "\n") stopifnot(identical(blake3, blake3Output[i])) } ## crc32c crc32cInput <- c("123456789", "The quick brown fox jumps over the lazy dog") crc32cOutput <- c("e3069283", "22620404") for (i in seq_along(crc32cInput)) { crc32c <- digest(crc32cInput[i], algo="crc32c", serialize=FALSE) cat(crc32c, "\n") stopifnot(identical(crc32c, crc32cOutput[i])) } # example of a digest of a standard R list structure digest(list(LETTERS, data.frame(a=letters[1:5], b=matrix(1:10,ncol=2)))) # test 'length' parameter and file input fname <- file.path(R.home(),"COPYING") x <- readChar(fname, file.info(fname)$size) # read file for (alg in c("sha1", "md5", "crc32")) { # partial file h1 <- digest(x , length=18000, algo=alg, serialize=FALSE) h2 <- digest(fname, length=18000, algo=alg, serialize=FALSE, file=TRUE) h3 <- digest( substr(x,1,18000) , algo=alg, serialize=FALSE) stopifnot( identical(h1,h2), identical(h1,h3) ) # whole file h1 <- digest(x , algo=alg, serialize=FALSE) h2 <- digest(fname, algo=alg, serialize=FALSE, file=TRUE) stopifnot( identical(h1,h2) ) } # compare md5 algorithm to other tools library(tools) fname <- file.path(R.home(),"COPYING") h1 <- as.character(md5sum(fname)) h2 <- digest(fname, algo="md5", file=TRUE) stopifnot( identical(h1,h2) ) ## digest is _designed_ to return one has summary per object to for a desired ## For vectorised output see digest::getVDigest() which provides ## better performance than base::Vectorize() md5 <- getVDigest() v <- md5(1:5) # digest integers 1 to 5 stopifnot(identical(v[1], digest(1L)), # check first and third result identical(v[3], digest(3L)))
The digest2int
function calculates integer hash of an arbitrary string.
This is useful for randomized experiments, feature hashing, etc.
digest2int(x, seed = 0L)
digest2int(x, seed = 0L)
x |
An arbitrary character vector. |
seed |
an integer for algorithm initial state. Function will produce different hashes for same input and different seed values. |
The digest2int
function returns integer vector of the same length
as input vector x
.
Dmitriy Selivanov [email protected] for the R interface; Bob Jenkins for original implementation http://www.burtleburtle.net/bob/hash/doobs.html
Jenkins's one_at_a_time
hash:
https://en.wikipedia.org/wiki/Jenkins_hash_function#one_at_a_time.
current <- digest2int("The quick brown fox jumps over the lazy dog", 0L) target <- 1369346549L stopifnot(identical(target, current))
current <- digest2int("The quick brown fox jumps over the lazy dog", 0L) target <- 1369346549L stopifnot(identical(target, current))
The getVDigest
function extends digest
by allowing one to
set a function that returns hash summaries as a character vector of the same length as the input. It also provides a performance advantage
when repeated calls are necessary (e.g. applying a hash function repeatedly to an object). The returned function contains the same arguments as digest
with the exception of the raw
argument (see digest
for more details).
getVDigest(algo=c("md5", "sha1", "crc32", "sha256", "sha512", "xxhash32", "xxhash64", "murmur32", "spookyhash", "blake3", "crc32c", "xxh3_64", "xxh3_128"), errormode=c("stop","warn","silent"))
getVDigest(algo=c("md5", "sha1", "crc32", "sha256", "sha512", "xxhash32", "xxhash64", "murmur32", "spookyhash", "blake3", "crc32c", "xxh3_64", "xxh3_128"), errormode=c("stop","warn","silent"))
algo |
The algorithms to be used; currently available choices are
|
errormode |
A character value denoting a choice for the behaviour in
the case of error: ‘stop’ aborts (and is the default value),
‘warn’ emits a warning and returns |
Note that since one hash summary will be returned for each element passed as input, care must be taken when determining whether or not to include the data structure as part of the object. For instance, to return the equivalent output of
digest(list("a"))
it would be necessary to wrap the list object itself
getVDigest()(list(list("a")))
The getVDigest
function returns a function for a given
algorithm and error-mode.
stretch_key <- function(d, n) { md5 <- getVDigest() for (i in seq_len(n)) d <- md5(d, serialize = FALSE) d } stretch_key('abc123', 65e3) sha1 <- getVDigest(algo = 'sha1') sha1(letters) md5Input <- c("", "a", "abc", "message digest", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", paste("12345678901234567890123456789012345678901234567890123456789012", "345678901234567890", sep="")) md5Output <- c("d41d8cd98f00b204e9800998ecf8427e", "0cc175b9c0f1b6a831c399e269772661", "900150983cd24fb0d6963f7d28e17f72", "f96b697d7cb7938d525a2f31aaf161d0", "c3fcd3d76192e4007dfb496cca67e13b", "d174ab98d277d9f5a5611c2c9f419d9f", "57edf4a22be3c955ac49da2e2107b67a") md5 <- getVDigest() stopifnot(identical(md5(md5Input, serialize = FALSE), md5Output)) stopifnot(identical(digest(list("abc")), md5(list(list("abc"))))) sha512Input <-c( "", "The quick brown fox jumps over the lazy dog." ) sha512Output <- c( paste0("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce", "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), paste0("91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bb", "c6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed") ) sha512 <- getVDigest(algo = 'sha512') stopifnot(identical(sha512(sha512Input, serialize = FALSE), sha512Output))
stretch_key <- function(d, n) { md5 <- getVDigest() for (i in seq_len(n)) d <- md5(d, serialize = FALSE) d } stretch_key('abc123', 65e3) sha1 <- getVDigest(algo = 'sha1') sha1(letters) md5Input <- c("", "a", "abc", "message digest", "abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", paste("12345678901234567890123456789012345678901234567890123456789012", "345678901234567890", sep="")) md5Output <- c("d41d8cd98f00b204e9800998ecf8427e", "0cc175b9c0f1b6a831c399e269772661", "900150983cd24fb0d6963f7d28e17f72", "f96b697d7cb7938d525a2f31aaf161d0", "c3fcd3d76192e4007dfb496cca67e13b", "d174ab98d277d9f5a5611c2c9f419d9f", "57edf4a22be3c955ac49da2e2107b67a") md5 <- getVDigest() stopifnot(identical(md5(md5Input, serialize = FALSE), md5Output)) stopifnot(identical(digest(list("abc")), md5(list(list("abc"))))) sha512Input <-c( "", "The quick brown fox jumps over the lazy dog." ) sha512Output <- c( paste0("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce", "47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), paste0("91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bb", "c6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed") ) sha512 <- getVDigest(algo = 'sha512') stopifnot(identical(sha512(sha512Input, serialize = FALSE), sha512Output))
The hmac
function calculates a message authentication code
(MAC) involving the specified cryptographic hash function in
combination with a given secret key.
hmac(key, object, algo = c("md5", "sha1", "crc32", "sha256", "sha512"), serialize = FALSE, raw = FALSE, ...)
hmac(key, object, algo = c("md5", "sha1", "crc32", "sha256", "sha512"), serialize = FALSE, raw = FALSE, ...)
key |
An arbitrary character or numeric vector, to use as pre-shared secret key. |
object |
An arbitrary R object which will then be passed to the
|
algo |
The algorithms to be used; currently available choices are
|
serialize |
default value of |
raw |
This flag alters the type of the output. Setting this to
|
... |
All remaining arguments are passed to |
The hmac
function uses the digest
to return a hash
digest as specified in the RFC 2104.
Mario Frasca [email protected].
MD5: https://www.ietf.org/rfc/rfc1321.txt.
SHA-1: https://en.wikipedia.org/wiki/SHA-1.
SHA-256: https://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf.
CRC32: The original reference webpage at rocksoft.com
has
vanished from the web; see
https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
general information on CRC algorithms.
https://aarongifford.com/computers/sha.html for the integrated C implementation of sha-512.
The page for the code underlying the C functions used here for sha-1 and md5, and further references, is no longer accessible. Please see https://en.wikipedia.org/wiki/SHA-1 and https://en.wikipedia.org/wiki/MD5.
https://zlib.net for documentation on the zlib library which supplied the code for crc32.
https://en.wikipedia.org/wiki/SHA_hash_functions for documentation on the sha functions.
## Standard RFC 2104 test vectors current <- hmac('Jefe', 'what do ya want for nothing?', "md5") target <- '750c783e6ab0b503eaa86e310a5db738' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0x0b, 16), 'Hi There', "md5") target <- '9294727a3638bb1c13f48ef8158bfc9d' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0xaa, 16), rep(0xdd, 50), "md5") target <- '56be34521d144c88dbb8c733f0e8b3f6' stopifnot(identical(target, as.character(current))) ## SHA1 tests inspired to the RFC 2104 and checked against the python ## hmac implementation. current <- hmac('Jefe', 'what do ya want for nothing?', "sha1") target <- 'effcdf6ae5eb2fa2d27416d5f184df9c259a7c79' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0x0b, 16), 'Hi There', "sha1") target <- '675b0b3a1b4ddf4e124872da6c2f632bfed957e9' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0xaa, 16), rep(0xdd, 50), "sha1") target <- 'd730594d167e35d5956fd8003d0db3d3f46dc7bb' stopifnot(identical(target, as.character(current)))
## Standard RFC 2104 test vectors current <- hmac('Jefe', 'what do ya want for nothing?', "md5") target <- '750c783e6ab0b503eaa86e310a5db738' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0x0b, 16), 'Hi There', "md5") target <- '9294727a3638bb1c13f48ef8158bfc9d' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0xaa, 16), rep(0xdd, 50), "md5") target <- '56be34521d144c88dbb8c733f0e8b3f6' stopifnot(identical(target, as.character(current))) ## SHA1 tests inspired to the RFC 2104 and checked against the python ## hmac implementation. current <- hmac('Jefe', 'what do ya want for nothing?', "sha1") target <- 'effcdf6ae5eb2fa2d27416d5f184df9c259a7c79' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0x0b, 16), 'Hi There', "sha1") target <- '675b0b3a1b4ddf4e124872da6c2f632bfed957e9' stopifnot(identical(target, as.character(current))) current <- hmac(rep(0xaa, 16), rep(0xdd, 50), "sha1") target <- 'd730594d167e35d5956fd8003d0db3d3f46dc7bb' stopifnot(identical(target, as.character(current)))
A helper function used to create raw
methods.
makeRaw(object) ## S3 method for class 'raw' makeRaw(object) ## S3 method for class 'character' makeRaw(object) ## S3 method for class 'digest' makeRaw(object) ## S3 method for class 'raw' makeRaw(object)
makeRaw(object) ## S3 method for class 'raw' makeRaw(object) ## S3 method for class 'character' makeRaw(object) ## S3 method for class 'digest' makeRaw(object) ## S3 method for class 'raw' makeRaw(object)
object |
The object to convert into a |
A raw
vector is returned.
Dirk Eddelbuettel
makeRaw("1234567890ABCDE")
makeRaw("1234567890ABCDE")
Calculate a SHA1 hash of an object. The main difference with
digest(x, algo = "sha1")
is that sha1()
will give the same hash on
32-bit and 64-bit systems. Note that the results depends on the setting of
digits
and zapsmall
when handling floating point numbers. The
current defaults keep digits
and zapsmall
as large as possible
while maintaining the same hash on 32 bit and 64 bit systems.
sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'numeric' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'complex' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'Date' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'matrix' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'data.frame' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'array' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'list' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'pairlist' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'POSIXlt' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'POSIXct' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'anova' sha1(x, digits = 4, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'function' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'formula' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class ''('' sha1(...) sha1_digest(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'NULL' sha1(...) ## S3 method for class 'name' sha1(...) sha1_attr_digest(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'call' sha1(...) ## S3 method for class 'character' sha1(...) ## S3 method for class 'factor' sha1(...) ## S3 method for class 'integer' sha1(...) ## S3 method for class 'logical' sha1(...) ## S3 method for class 'raw' sha1(...)
sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'numeric' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'complex' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'Date' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'matrix' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'data.frame' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'array' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'list' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'pairlist' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'POSIXlt' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'POSIXct' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'anova' sha1(x, digits = 4, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'function' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'formula' sha1(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class ''('' sha1(...) sha1_digest(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'NULL' sha1(...) ## S3 method for class 'name' sha1(...) sha1_attr_digest(x, digits = 14, zapsmall = 7, ..., algo = "sha1") ## S3 method for class 'call' sha1(...) ## S3 method for class 'character' sha1(...) ## S3 method for class 'factor' sha1(...) ## S3 method for class 'integer' sha1(...) ## S3 method for class 'logical' sha1(...) ## S3 method for class 'raw' sha1(...)
x |
the object to calculate the SHA1 |
digits |
the approximate number of significant digits in base 10. Will
be converted to a base 16 equivalent. Defaults to |
zapsmall |
the approximate negative magnitude of the smallest relevant
digit. Will be converted to a base 2 equivalent. Values smaller than this
number are equivalent to 0. Defaults to |
... |
If it is the only defined argument, passed to another |
algo |
The hashing algoritm to be used by |
sha1_digest()
is a convenience function for objects where attributes
cannot be added to apply the digest()
function to its arguments.
sha1_attr_digest()
is a convenience function for objects where objects
can be added to generate the hash. If generating hashes for objects in other
packages, one of these two functions is recommended for use (typically,
sha1_attr_digest()
).
Extra arguments:
environment: An optional extra argument for sha1.function
and
sha1.formula
should be TRUE, FALSE or missing. sha1.function
and
sha1.formula
will ignore the enviroment of the function only when
environment = FALSE
.
sha1
gained an algo
argument since version 0.6.15. This allows
sha1()
to use all hashing algoritms available in digest()
. The
hashes created with sha1(x)
from digest >= 0.6.15 are identical to
sha1(x)
from digest <= 0.6.14. The only exceptions are hashes created
with sha1(x, algo = "sha1")
, they will be different starting from digest
0.6.15
Until version 0.6.22, sha1
ignored the attributes of the object for
some classes. This was fixed in version 0.6.23. Use
options(sha1PackageVersion = "0.6.22")
to get the old behaviour.
Version 0.6.24 and later ignore attributes named srcref
.
Thierry Onkelinx