diff options
| -rw-r--r-- | LICENSE | 4 | ||||
| -rw-r--r-- | Makefile | 2 | ||||
| -rw-r--r-- | chksum.c | 142 | ||||
| -rw-r--r-- | chksum.h | 32 | ||||
| -rw-r--r-- | chksums/sha256.c | 319 | ||||
| -rw-r--r-- | chksums/sha256.h | 40 | ||||
| -rw-r--r-- | lib.c | 2 | ||||
| -rw-r--r-- | txr.1 | 45 |
8 files changed, 585 insertions, 1 deletions
@@ -10,6 +10,10 @@ Linenoise: Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com> All rights reserved. +SHA-256: + Copyright 2005 Colin Percival + All rights reserved. + MPI: Written Michael Fromberger 1998-2006; assigned into the public domain in, or prior to 2002. @@ -52,7 +52,7 @@ EXTRA_OBJS-y := OBJS := txr.o lex.yy.o y.tab.o match.o lib.o regex.o gc.o unwind.o stream.o OBJS += arith.o hash.o utf8.o filter.o eval.o parser.o rand.o combi.o sysif.o OBJS += args.o lisplib.o cadr.o struct.o itypes.o buf.o jmp.o protsym.o ffi.o -OBJS += strudel.o vm.o +OBJS += strudel.o vm.o chksum.o chksums/sha256.o OBJS-$(debug_support) += debug.o OBJS-$(have_syslog) += syslog.o OBJS-$(have_glob) += glob.o diff --git a/chksum.c b/chksum.c new file mode 100644 index 00000000..78af6b8d --- /dev/null +++ b/chksum.c @@ -0,0 +1,142 @@ +/* Copyright 2019 + * Kaz Kylheku <kaz@kylheku.com> + * Vancouver, Canada + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <stddef.h> +#include <wchar.h> +#include <limits.h> +#include <float.h> +#include <string.h> +#include <stdlib.h> +#include <stdarg.h> +#include <signal.h> +#include <stdio.h> +#include "config.h" +#include "lib.h" +#include "gc.h" +#include "itypes.h" +#include "signal.h" +#include "unwind.h" +#include "eval.h" +#include "stream.h" +#include "arith.h" +#include "utf8.h" +#include "buf.h" +#include "chksums/sha256.h" +#include "chksum.h" + +val sha256_stream(val stream, val nbytes) +{ + SHA256_t s256; + unsigned char *hash = chk_malloc(SHA256_DIGEST_LENGTH); + val bfsz = num_fast(BUFSIZ); + val buf = make_buf(bfsz, nil, nil); + SHA256_init(&s256); + + if (null_or_missing_p(nbytes)) { + for (;;) { + val read = fill_buf(buf, zero, stream); + cnum rd = c_num(read); + + if (!rd) + break; + + SHA256_update(&s256, buf->b.data, rd); + } + } else { + while (ge(nbytes, bfsz)) { + val read = fill_buf(buf, zero, stream); + cnum rd = c_num(read); + + if (zerop(read)) + break; + + SHA256_update(&s256, buf->b.data, rd); + nbytes = minus(nbytes, read); + } + + buf_set_length(buf, nbytes, nil); + + { + val read = fill_buf(buf, zero, stream); + cnum rd = c_num(read); + if (rd) + SHA256_update(&s256, buf->b.data, rd); + } + } + + SHA256_final(&s256, hash); + return make_borrowed_buf(num_fast(SHA256_DIGEST_LENGTH), hash); +} + +static val sha256_buf(val buf, val self) +{ + SHA256_t s256; + unsigned char *hash = chk_malloc(SHA256_DIGEST_LENGTH); + SHA256_init(&s256); + ucnum len = c_unum(buf->b.len); + mem_t *data = buf->b.data; + const size_t szmax = convert(size_t, -1) / 4 + 1; + + while (len >= szmax) { + SHA256_update(&s256, data, szmax); + data += szmax; + len -= szmax; + } + + if (len > 0) + SHA256_update(&s256, data, len); + + SHA256_final(&s256, hash); + return make_borrowed_buf(num_fast(SHA256_DIGEST_LENGTH), hash); +} + +static val sha256_str(val str, val self) +{ + val s = make_byte_input_stream(str); + return sha256_stream(s, nil); +} + +val sha256(val obj) +{ + val self = lit("sha256"); + + switch (type(obj)) { + case STR: + case LSTR: + case LIT: + return sha256_str(obj, self); + case BUF: + return sha256_buf(obj, self); + default: + uw_throwf(error_s, lit("~a: cannot hash ~s, only buffer and strings"), + self, obj, nao); + } +} + +void chksum_init(void) +{ + reg_fun(intern(lit("sha256-stream"), user_package), func_n2o(sha256_stream, 1)); + reg_fun(intern(lit("sha256"), user_package), func_n1(sha256)); +} diff --git a/chksum.h b/chksum.h new file mode 100644 index 00000000..e3516f57 --- /dev/null +++ b/chksum.h @@ -0,0 +1,32 @@ +/* Copyright 2019 + * Kaz Kylheku <kaz@kylheku.com> + * Vancouver, Canada + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +val sha256_stream(val stream, val nbytes); +val sha256(val obj); +val crc32_stream(val stream, val nbytes); +val crc32(val obj); +void chksum_init(void); diff --git a/chksums/sha256.c b/chksums/sha256.c new file mode 100644 index 00000000..7c0cff73 --- /dev/null +++ b/chksums/sha256.c @@ -0,0 +1,319 @@ +/*- + * Copyright 2005 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <string.h> +#include <limits.h> +#include <wchar.h> +#include "config.h" +#include "lib.h" +#include "itypes.h" +#include "sha256.h" + +#if HAVE_LITTLE_ENDIAN + +INLINE void be32enc(unsigned char *dst, u32_t v) +{ + dst[0] = (v >> 24) & 0xff; + dst[1] = (v >> 16) & 0xff; + dst[2] = (v >> 8) & 0xff; + dst[3] = v & 0xff; +} + +INLINE u32_t be32dec(const unsigned char *src) +{ + return (convert(u32_t, src[0]) << 24 | convert(u32_t, src[1]) << 16 | + convert(u32_t, src[2]) << 8 | src[3]); +} + +INLINE void be64enc(unsigned char *dst, u64_t v) +{ + dst[0] = (v >> 56) & 0xff; + dst[1] = (v >> 48) & 0xff; + dst[2] = (v >> 40) & 0xff; + dst[3] = (v >> 32) & 0xff; + dst[4] = (v >> 24) & 0xff; + dst[5] = (v >> 16) & 0xff; + dst[6] = (v >> 8) & 0xff; + dst[7] = v & 0xff; +} + +/* + * Encode a length len/4 vector of (u32_t) into a length len vector of + * (unsigned char) in big-endian form. Assumes len is a multiple of 4. + */ +static void be32enc_vect(unsigned char *dst, const u32_t *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 4; i++) + be32enc(dst + i * 4, src[i]); +} + +/* + * Decode a big-endian length len vector of (unsigned char) into a length + * len/4 vector of (u32_t). Assumes len is a multiple of 4. + */ +static void be32dec_vect(u32_t *dst, const unsigned char *src, size_t len) +{ + size_t i; + + for (i = 0; i < len / 4; i++) + dst[i] = be32dec(src + i * 4); +} + +#else /* BYTE_ORDER != BIG_ENDIAN */ + +/* Copy a vector of big-endian u32_t into a vector of bytes */ +#define be32enc_vect(dst, src, len) \ + memcpy((void *)dst, (const void *)src, (size_t)len) + +/* Copy a vector of bytes into a vector of big-endian u32_t */ +#define be32dec_vect(dst, src, len) \ + memcpy((void *)dst, (const void *)src, (size_t)len) + +INLINE void be64enc(unsigned char *dst, u64_t v) +{ + *coerce(u64_t *, dst) = v; +} + +#endif /* BYTE_ORDER != BIG_ENDIAN */ + +/* SHA256 round constants. */ +static const u32_t K[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +}; + +/* Elementary functions used by SHA256 */ +#define Ch(x, y, z) ((x & (y ^ z)) ^ z) +#define Maj(x, y, z) ((x & (y | z)) | (y & z)) +#define SHR(x, n) (x >> n) +#define ROTR(x, n) ((x >> n) | (x << (32 - n))) +#define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) +#define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) +#define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)) +#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10)) + +/* SHA256 round function */ +#define RND(a, b, c, d, e, f, g, h, k) \ + h += S1(e) + Ch(e, f, g) + k; \ + d += h; \ + h += S0(a) + Maj(a, b, c); + +/* Adjusted round function for rotating state */ +#define RNDr(S, W, i, ii) \ + RND(S[(64 - i) % 8], S[(65 - i) % 8], \ + S[(66 - i) % 8], S[(67 - i) % 8], \ + S[(68 - i) % 8], S[(69 - i) % 8], \ + S[(70 - i) % 8], S[(71 - i) % 8], \ + W[i + ii] + K[i + ii]) + +/* Message schedule computation */ +#define MSCH(W, ii, i) \ + W[i + ii + 16] = s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii] + +/* + * SHA256 block compression function. The 256-bit state is transformed via + * the 512-bit input block to produce a new state. + */ +static void SHA256_transform(u32_t *state, const unsigned char block[64]) +{ + u32_t W[64]; + u32_t S[8]; + int i; + + /* 1. Prepare the first part of the message schedule W. */ + be32dec_vect(W, block, 64); + + /* 2. Initialize working variables. */ + memcpy(S, state, 32); + + /* 3. Mix. */ + for (i = 0; i < 64; i += 16) { + RNDr(S, W, 0, i); + RNDr(S, W, 1, i); + RNDr(S, W, 2, i); + RNDr(S, W, 3, i); + RNDr(S, W, 4, i); + RNDr(S, W, 5, i); + RNDr(S, W, 6, i); + RNDr(S, W, 7, i); + RNDr(S, W, 8, i); + RNDr(S, W, 9, i); + RNDr(S, W, 10, i); + RNDr(S, W, 11, i); + RNDr(S, W, 12, i); + RNDr(S, W, 13, i); + RNDr(S, W, 14, i); + RNDr(S, W, 15, i); + + if (i == 48) + break; + MSCH(W, 0, i); + MSCH(W, 1, i); + MSCH(W, 2, i); + MSCH(W, 3, i); + MSCH(W, 4, i); + MSCH(W, 5, i); + MSCH(W, 6, i); + MSCH(W, 7, i); + MSCH(W, 8, i); + MSCH(W, 9, i); + MSCH(W, 10, i); + MSCH(W, 11, i); + MSCH(W, 12, i); + MSCH(W, 13, i); + MSCH(W, 14, i); + MSCH(W, 15, i); + } + + /* 4. Mix local working variables into global state */ + for (i = 0; i < 8; i++) + state[i] += S[i]; +} + +static unsigned char PAD[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* Add padding and terminating bit-count. */ +static void SHA256_pad(SHA256_t *ctx) +{ + size_t r; + + /* Figure out how many bytes we have buffered. */ + r = (ctx->count >> 3) & 0x3f; + + /* Pad to 56 mod 64, transforming if we finish a block en route. */ + if (r < 56) { + /* Pad to 56 mod 64. */ + memcpy(&ctx->buf[r], PAD, 56 - r); + } else { + /* Finish the current block and mix. */ + memcpy(&ctx->buf[r], PAD, 64 - r); + SHA256_transform(ctx->state, ctx->buf); + + /* The start of the final block is all zeroes. */ + memset(&ctx->buf[0], 0, 56); + } + + /* Add the terminating bit-count. */ + be64enc(&ctx->buf[56], ctx->count); + + /* Mix in the final block. */ + SHA256_transform(ctx->state, ctx->buf); +} + +/* SHA-256 initialization. Begins a SHA-256 operation. */ +void SHA256_init(SHA256_t *ctx) +{ + /* Zero bits processed so far */ + ctx->count = 0; + + /* Magic initialization constants */ + ctx->state[0] = 0x6A09E667; + ctx->state[1] = 0xBB67AE85; + ctx->state[2] = 0x3C6EF372; + ctx->state[3] = 0xA54FF53A; + ctx->state[4] = 0x510E527F; + ctx->state[5] = 0x9B05688C; + ctx->state[6] = 0x1F83D9AB; + ctx->state[7] = 0x5BE0CD19; +} + +/* Add bytes into the hash */ +void SHA256_update(SHA256_t *ctx, const void *in, size_t len) +{ + u64_t bitlen; + u32_t r; + const unsigned char *src = in; + + /* Number of bytes left in the buffer from previous updates */ + r = (ctx->count >> 3) & 0x3f; + + /* Convert the length into a number of bits */ + bitlen = len << 3; + + /* Update number of bits */ + ctx->count += bitlen; + + /* Handle the case where we don't need to perform any transforms */ + if (len < 64 - r) { + memcpy(&ctx->buf[r], src, len); + return; + } + + /* Finish the current block */ + memcpy(&ctx->buf[r], src, 64 - r); + SHA256_transform(ctx->state, ctx->buf); + src += 64 - r; + len -= 64 - r; + + /* Perform complete blocks */ + while (len >= 64) { + SHA256_transform(ctx->state, src); + src += 64; + len -= 64; + } + + /* Copy left over data into buffer */ + memcpy(ctx->buf, src, len); +} + +/* + * SHA-256 finalization. Pads the input data, exports the hash value, + * and clears the context state. + */ +void SHA256_final(SHA256_t *ctx, unsigned char *digest) +{ + + /* Add padding */ + SHA256_pad(ctx); + + /* Write the hash */ + be32enc_vect(digest, ctx->state, SHA256_DIGEST_LENGTH); + + /* Clear the context state */ + memset(ctx, 0, sizeof *ctx); +} diff --git a/chksums/sha256.h b/chksums/sha256.h new file mode 100644 index 00000000..3cd57a4e --- /dev/null +++ b/chksums/sha256.h @@ -0,0 +1,40 @@ +/*- + * Copyright 2005 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#define SHA256_BLOCK_LENGTH 64 +#define SHA256_DIGEST_LENGTH 32 +#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1) + +typedef struct SHA256 { + u32_t state[8]; + u64_t count; + u8_t buf[SHA256_BLOCK_LENGTH]; +} SHA256_t; + +void SHA256_init(SHA256_t *); +void SHA256_update(SHA256_t *, const void *, size_t); +void SHA256_final(SHA256_t *, unsigned char *); @@ -71,6 +71,7 @@ #include "itypes.h" #include "buf.h" #include "ffi.h" +#include "chksum.h" #include "txr.h" #include "debug.h" @@ -12189,6 +12190,7 @@ void init(val *stack_bottom) #endif cadr_init(); time_init(); + chksum_init(); gc_state(gc_save); } @@ -51823,6 +51823,51 @@ It may or may not have any effect on the output (since the UTC zone by definition doesn't have daylight savings time). +.SS* Data Integrity + +.coNP Function @ sha256-stream +.synb +.mets (sha256-stream < stream <> [ nbytes ]) +.syne +.desc +The +.code sha256-stream +calculates the NIST SHA-256 digest over the bytes read from +.metn stream , +starting at the stream's current position. + +If the +.meta nbytes +argument is specified, it should be a nonnegative +integer. It gives the number of bytes which should be read +and included in the digest. If the argument is omitted, then bytes are read +until the end of the stream. + +The 256 bit digest value is returned as a buffer containing 32 bytes. + +.coNP Function @ sha256 +.synb +.mets (sha256 << obj ) +.syne +.desc +The +.code sha256 +function calculates the NIST SHA-256 digest over +.metn obj , +which may be a character string or a buffer. + +If +.meta obj +is a buffer, then the digest is calculated over all of the bytes contained +in that buffer, according to its current length. + +If +.meta obj +is a character string, then the digest is calculated over the bytes +which constitute its UTF-8 representation. + +The 256 bit digest value is returned as a buffer containing 32 bytes. + .SS* The Awk Utility The \*(TL library provides a macro called |