sha hashes skip instead of strip serialization headers

Author: shikokuchuo

DESCRIPTION

@@ -1,7 +1,7 @@
 Package: nanonext
 Type: Package
 Title: NNG (Nanomsg Next Gen) Lightweight Messaging Library
-Version: 0.12.0.9018
+Version: 0.12.0.9019
 Description: R binding for NNG (Nanomsg Next Gen), a successor to ZeroMQ. NNG is
     a socket library implementing 'Scalability Protocols', a reliable,
     high-performance standard for common communications patterns including

NEWS.md

@@ -1,4 +1,4 @@
-# nanonext 0.12.0.9018 (development)
+# nanonext 0.12.0.9019 (development)
 
 *Please note this version contains breaking behavioural changes - see updates below.*
 
@@ -7,7 +7,7 @@
 * Default blocking behaviour of `send()` and `recv()` over Sockets and Contexts aligned to non-blocking (this change is facilitated by the introduction of synchronous context sends in NNG v1.6.0).
 * Unserialization / decoding errors where the received message cannot be translated to the specified mode will output a message to stderr, but no longer generate a warning.
 * `ncurl()`, `ncurl_aio()` and `ncurl_session()` now restrict 'header' and 'response' arguments to character vectors only, no longer accepting lists (for safety and performance).
-* SHA functions now strip the serialization header from serialized R objects. This ensures portability as the R version and native encoding information is written into the header. Note: hashes will be different to those obtained using prior versions of this package for serialized objects.
+* SHA functions now skip the serialization header for serialized R objects. This ensures portability as these contain R version and encoding information. Note: hashes will be different to those obtained using prior versions of this package for serialized objects.
 * `messenger()` specifying 'auth' now works reliably on endpoints using different R versions/platforms due to the above hashing portability fix.
 * `sha1()` is removed as a hash option.
 * Internal memory-efficiency and performance enhancements.

R/tls.R

@@ -90,9 +90,9 @@ tls_config <- function(client = NULL, server = NULL, pass = NULL, auth = is.null
 #' @details For arguments 'x' and 'key', a scalar string or raw vector (with no
 #'     attributes) is hashed 'as is'.
 #'
-#'     All other objects are first serialized using R serialization version 3,
-#'     big-endian representation, with the headers stripped (for portability as
-#'     these contain the R version number and native encoding information).
+#'     All other objects are first serialized using R serialization v3 XDR, with
+#'     headers skipped (for portability as these contain R version and encoding
+#'     information).
 #'
 #'     The result of hashing is always a byte sequence, which is converted to a
 #'     character string hex representation if 'convert' is TRUE, or returned as

man/sha256.Rd

@@ -42,12 +42,12 @@ SEXP mk_error(const int xc) {
 
 }
 
-SEXP eval_safe (void *call) {
+static SEXP eval_safe (void *call) {
   return Rf_eval((SEXP) call, R_GlobalEnv);
 }
 
-void rl_reset(void *nothing, Rboolean jump) {
-  if (jump && nothing == NULL)
+static void rl_reset(void *data, Rboolean jump) {
+  if (jump && data == NULL)
     SET_TAG(nano_refHook, R_NilValue);
 }
 
@@ -72,6 +72,32 @@ static void nano_write_bytes(R_outpstream_t stream, void *src, int len) {
 
 }
 
+static void nano_skip_bytes(R_outpstream_t stream, void *src, int len) {
+
+  nano_buf *buf = (nano_buf *) stream->data;
+  if (buf->len <= NANONEXT_SERIAL_HEADERS) {
+    buf->len--;
+    buf->len = buf->len ? buf->len : NANONEXT_INIT_BUFSIZE;
+    return;
+  }
+
+  size_t req = buf->cur + (size_t) len;
+  if (req > buf->len) {
+    if (req > R_XLEN_T_MAX) {
+      if (buf->len) R_Free(buf->buf);
+      Rf_error("serialization exceeds max length of raw vector");
+    }
+    do {
+      buf->len = buf->len * (double) (buf->len > 268435456 ? 1.2 : 2);
+    } while (buf->len < req);
+    buf->buf = R_Realloc(buf->buf, buf->len, unsigned char);
+  }
+
+  memcpy(buf->buf + buf->cur, src, len);
+  buf->cur += len;
+
+}
+
 static void nano_read_bytes(R_inpstream_t stream, void *dst, int len) {
 
   nano_buf *buf = (nano_buf *) stream->data;
@@ -243,9 +269,11 @@ void nano_serialize_next(nano_buf *buf, const SEXP object) {
 
 }
 
-void nano_serialize_xdr(nano_buf *buf, const SEXP object) {
+void nano_serialize_xdr(nano_buf *buf, const SEXP object, const int skip) {
 
   NANO_ALLOC(buf, NANONEXT_INIT_BUFSIZE);
+  buf->len = skip ? NANONEXT_SERIAL_HEADERS : buf->len;
+
   struct R_outpstream_st output_stream;
 
   R_InitOutPStream(
@@ -254,7 +282,7 @@ void nano_serialize_xdr(nano_buf *buf, const SEXP object) {
     R_pstream_xdr_format,
     NANONEXT_SERIAL_VER,
     NULL,
-    nano_write_bytes,
+    skip ? nano_skip_bytes : nano_write_bytes,
     NULL,
     R_NilValue
   );

src/core.c

@@ -117,7 +117,6 @@ typedef struct nano_cv_s {
 #include <mbedtls/sha512.h>
 #include <mbedtls/version.h>
 
-#define NANO_SHLEN 23
 #define SHA224_KEY_SIZE 28
 #define SHA256_KEY_SIZE 32
 #define SHA384_KEY_SIZE 48
@@ -158,6 +157,7 @@ typedef struct nano_cv_s {
 #define ERROR_RET(xc) { Rf_warning("%d | %s", xc, nng_strerror(xc)); return mk_error(xc); }
 #define NANONEXT_INIT_BUFSIZE 8192
 #define NANONEXT_SERIAL_VER 3
+#define NANONEXT_SERIAL_HEADERS 6
 #define NANONEXT_LD_STRLEN 21
 #define NANO_ALLOC(x, sz)                                      \
   (x)->buf = R_Calloc(sz, unsigned char);                      \
@@ -186,7 +186,7 @@ int nano_matcharg(const SEXP);
 int nano_matchargs(const SEXP);
 void nano_serialize(nano_buf *, const SEXP);
 void nano_serialize_next(nano_buf *, const SEXP);
-void nano_serialize_xdr(nano_buf *, const SEXP);
+void nano_serialize_xdr(nano_buf *, const SEXP, const int);
 SEXP nano_unserialize(unsigned char *, const size_t);
 SEXP rawToChar(const unsigned char *, const size_t);
 void dialer_finalizer(SEXP);

src/nanonext.h

@@ -57,11 +57,7 @@ static nano_buf nano_any_buf(const SEXP x, const int strip) {
     }
   }
 
-  nano_serialize_xdr(&buf, x);
-  if (strip) {
-    buf.cur = buf.cur - NANO_SHLEN;
-    memmove(buf.buf, buf.buf + NANO_SHLEN, buf.cur);
-  }
+  nano_serialize_xdr(&buf, x, strip);
 
   return buf;
 

src/tls.c

@@ -518,7 +518,7 @@ nanotest(sha256("test") == "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d
 nanotest(length(sha256(c("one", "two"), key = "PRIVATE_key", convert = FALSE)) == 32L)
 nanotest(nchar(sha512(c(1.1, 2.2), as.raw(1L))) == 128L)
 nanotest(length(sha512("testing", convert = FALSE)) == 64L)
-nanotest(length(sha384(as.list(random(1e3L)), "KEY", convert = FALSE)) == 48L)
+nanotest(length(sha384(runif(5e3L), "KEY", convert = FALSE)) == 48L)
 nanotest(nchar(sha384(7000L, key = NULL, convert = TRUE)) == 96L)
 nanotest(length(sha224(c("one", "two"), key = "PRIVATE_key", convert = FALSE)) == 28L)
 nanotest(sha224(as.raw(0L)) == "fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073")