convolver 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c27f2aa98b988627391d0a9812c6b8e0a59e65cf4a506592d95f43d1a02e3ae
-  data.tar.gz: ede25a5203ed707bd3ca726eb513ceb44746bc5a04c294396d368ab3785b2c4c
+  metadata.gz: e886e4cc4f0c47a5c0e40209a20ac4b90f9c5fa349c76e9b04889fb8c010fa70
+  data.tar.gz: b656b786753b87ab68d89985262bedbbd3ad0929527a2953acde7af56cde643b
 SHA512:
-  metadata.gz: aaf0fc6ab38eedbe06c2082b8ffaa2cdbfab45b3340aadf7c87839d28aa97dbb3be1e22a99c3aef25207b656741c69763bb177003d74e440ce7d6653be22aff8
-  data.tar.gz: 20b127fa09a8c6b449e74183da3fa91a93603bc17701b4991543de6095ae64023ef217c166d5a7ef999a241de125c7278e6f1e2b3d895f5ec0d0fe2665188bd5
+  metadata.gz: 187f65c4daf5c25007348d0e3f21e44dda4bccb629f0dab067ac8193aac8977d22a441b79249d35ad4b7c2b17e43e3339db7045c0f83882009556bae6b446425
+  data.tar.gz: 4605ecab87c0027c02c30c82e78298766b311a4e359b178fec8b47427a5c6bfc57a049193173fb38fba3877874e679cf1d96ac41700a5cf090a31c5fa43c9635

data/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.1] - 2026-07-29
+
+### Fixed
+
+- Made the direct native implementation handle non-contiguous Numo::NArray
+  views safely.
+- Prevented an out-of-bounds native buffer write for rank-16 inputs.
+- Replaced unchecked native size and offset arithmetic with overflow-checked
+  calculations.
+
 ## [1.0.0] - 2026-07-21
 
 ### Added
@@ -44,4 +54,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Updated the native extension to use the maintained Numo C API and removed the
   legacy untyped-data compatibility code.
 
+[1.0.1]: https://github.com/neilslater/convolver/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/neilslater/convolver/compare/v0.3.2...v1.0.0

data/ext/convolver/convolve_raw.c

@@ -2,22 +2,37 @@
 
 #include "convolve_raw.h"
 
-static inline int size_from_shape( int rank, int *shape ) {
-  int size = 1;
+static inline size_t checked_add( size_t left, size_t right, const char *description ) {
+  if ( right > SIZE_MAX - left ) {
+    rb_raise( rb_eRangeError, "%s exceeds native implementation limit", description );
+  }
+  return left + right;
+}
+
+static inline size_t checked_multiply( size_t left, size_t right, const char *description ) {
+  if ( left != 0 && right > SIZE_MAX / left ) {
+    rb_raise( rb_eRangeError, "%s exceeds native implementation limit", description );
+  }
+  return left * right;
+}
+
+static inline size_t size_from_shape( int rank, const size_t *shape, const char *description ) {
+  size_t size = 1;
   int i;
-  for ( i = 0; i < rank; i++ ) { size *= shape[i]; }
+  for ( i = 0; i < rank; i++ ) {
+    size = checked_multiply( size, shape[i], description );
+  }
   return size;
 }
 
 // Sets reverse indices
-static inline void corner_reset( int rank, int *shape, int *rev_indices ) {
+static inline void corner_reset( int rank, const size_t *shape, size_t *rev_indices ) {
   int i;
   for ( i = 0; i < rank; i++ ) { rev_indices[i] = shape[i] - 1; }
-  return;
 }
 
 // Counts indices down, returns number of ranks that reset
-static inline int corner_dec( int rank, int *shape, int *rev_indices ) {
+static inline int corner_dec( int rank, const size_t *shape, size_t *rev_indices ) {
   int i = 0;
   (void) rank;
   while ( ! rev_indices[i]-- ) {
@@ -28,16 +43,31 @@ static inline int corner_dec( int rank, int *shape, int *rev_indices ) {
 }
 
 // Generates co-increment steps by rank boundaries crossed, for the outer position as inner position is incremented by 1
-static inline void calc_co_increment( int rank, int *outer_shape, int *inner_shape, int *co_increment ) {
-  int i, factor;
+static inline void calc_co_increment(
+    int rank, const size_t *outer_shape, const size_t *inner_shape, size_t *co_increment ) {
+  size_t factor = 1;
+  int i;
   co_increment[0] = 1; // co-increment is always 1 in lowest rank
-  factor = 1;
   for ( i = 0; i < rank; i++ ) {
-    co_increment[i+1] = co_increment[i] + factor * ( outer_shape[i] - inner_shape[i] );
-    factor *= outer_shape[i];
+    size_t skipped = checked_multiply( factor, outer_shape[i] - inner_shape[i], "array offset" );
+    co_increment[i+1] = checked_add( co_increment[i], skipped, "array offset" );
+    factor = checked_multiply( factor, outer_shape[i], "array size" );
   }
 }
 
+static inline size_t maximum_offset(
+    int rank, const size_t *outer_shape, const size_t *inner_shape, const char *description ) {
+  size_t factor = 1;
+  size_t offset = 0;
+  int i;
+  for ( i = 0; i < rank; i++ ) {
+    size_t dimension_offset = checked_multiply( factor, inner_shape[i] - 1, description );
+    offset = checked_add( offset, dimension_offset, description );
+    factor = checked_multiply( factor, outer_shape[i], "array size" );
+  }
+  return offset;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //
 //  Convolve
@@ -46,33 +76,46 @@ static inline void calc_co_increment( int rank, int *outer_shape, int *inner_sha
 //
 
 void convolve_raw(
-    int in_rank, int *in_shape, float *in_ptr,
-    int kernel_rank, int *kernel_shape, float *kernel_ptr,
-    int out_rank, int *out_shape, float *out_ptr ) {
-  int i, j, kernel_size, kernel_aligned, out_size, offset;
-  int out_co_incr[LARGEST_RANK], kernel_co_incr[LARGEST_RANK];
-  int ker_q[LARGEST_RANK], out_q[LARGEST_RANK];
-  int *kernel_co_incr_cache;
-
-  kernel_size = size_from_shape( kernel_rank, kernel_shape );
-  kernel_aligned = 4 * (kernel_size/4);
-  out_size = size_from_shape( out_rank, out_shape );
+    int in_rank, const size_t *in_shape, const float *in_ptr,
+    int kernel_rank, const size_t *kernel_shape, const float *kernel_ptr,
+    int out_rank, const size_t *out_shape, float *out_ptr ) {
+  size_t i, j, input_size, kernel_size, kernel_aligned, out_size, offset;
+  size_t maximum_input_offset;
+  size_t out_co_incr[LARGEST_RANK + 1], kernel_co_incr[LARGEST_RANK + 1];
+  size_t ker_q[LARGEST_RANK], out_q[LARGEST_RANK];
+  size_t *kernel_co_incr_cache;
+  VALUE cache_storage = 0;
+
+  kernel_size = size_from_shape( kernel_rank, kernel_shape, "kernel size" );
+  kernel_aligned = kernel_size - kernel_size % 4;
+  out_size = size_from_shape( out_rank, out_shape, "output size" );
+  input_size = size_from_shape( in_rank, in_shape, "input size" );
 
   calc_co_increment( in_rank, in_shape, out_shape, out_co_incr );
   calc_co_increment( in_rank, in_shape, kernel_shape, kernel_co_incr );
+  maximum_input_offset = checked_add(
+    maximum_offset( in_rank, in_shape, out_shape, "input offset" ),
+    maximum_offset( in_rank, in_shape, kernel_shape, "input offset" ),
+    "input offset"
+  );
+  if ( maximum_input_offset >= input_size ) {
+    rb_raise( rb_eRangeError, "input offset exceeds native implementation limit" );
+  }
 
-  kernel_co_incr_cache = ALLOC_N( int, kernel_size );
+  kernel_co_incr_cache = RB_ALLOCV_N( size_t, cache_storage, kernel_size );
   kernel_co_incr_cache[0] = 0;
 
   corner_reset( kernel_rank, kernel_shape, ker_q );
   for ( i = 1; i < kernel_size; i++ ) {
-    kernel_co_incr_cache[i] = kernel_co_incr_cache[i-1] + kernel_co_incr[ corner_dec( kernel_rank, kernel_shape, ker_q  ) ];
+    kernel_co_incr_cache[i] = checked_add(
+      kernel_co_incr_cache[i-1],
+      kernel_co_incr[ corner_dec( kernel_rank, kernel_shape, ker_q ) ],
+      "kernel offset"
+    );
   }
 
-  // For convenience of flow, we set offset to -1 and adjust countdown 1 higher to compensate
-  offset = -1;
+  offset = 0;
   corner_reset( out_rank, out_shape, out_q );
-  out_q[0]++;
 
   // Main convolve loop
   for ( i = 0; i < out_size; i++ ) {
@@ -83,8 +126,6 @@ void convolve_raw(
 #endif
     float t = 0.0;
 
-    offset += out_co_incr[ corner_dec( out_rank, out_shape, out_q ) ];
-
 #if CONVOLVER_USE_SSE
     // Use SIMD for all the aligned values in groups of 4
     for ( j = 0; j < kernel_aligned; j +=4 ) {
@@ -114,8 +155,15 @@ void convolve_raw(
 #else
     out_ptr[i] = t;
 #endif
+
+    if ( i + 1 < out_size ) {
+      offset = checked_add(
+        offset,
+        out_co_incr[ corner_dec( out_rank, out_shape, out_q ) ],
+        "input offset"
+      );
+    }
   }
 
-  xfree( kernel_co_incr_cache );
-  return;
+  RB_ALLOCV_END( cache_storage );
 }

data/ext/convolver/convolve_raw.h

@@ -18,8 +18,8 @@
 #define LARGEST_RANK 16
 
 void convolve_raw(
-    int in_rank, int *in_shape, float *in_ptr,
-    int kernel_rank, int *kernel_shape, float *kernel_ptr,
-    int out_rank, int *out_shape, float *out_ptr );
+    int in_rank, const size_t *in_shape, const float *in_ptr,
+    int kernel_rank, const size_t *kernel_shape, const float *kernel_ptr,
+    int out_rank, const size_t *out_shape, float *out_ptr );
 
 #endif

data/ext/convolver/convolver.c

@@ -1,4 +1,3 @@
-#include <limits.h>
 #include <ruby.h>
 #include <numo/narray.h>
 #include <numo/intern.h>
@@ -7,14 +6,11 @@
 
 static VALUE mConvolver;
 
-static void copy_shape(int rank, const size_t *source, int *target) {
+static void copy_shape(int rank, const size_t *source, size_t *target) {
   int i;
 
   for (i = 0; i < rank; i++) {
-    if (source[rank - i - 1] > INT_MAX) {
-      rb_raise(rb_eArgError, "array dimension exceeds native implementation limit");
-    }
-    target[i] = (int)source[rank - i - 1];
+    target[i] = source[rank - i - 1];
   }
 }
 
@@ -34,9 +30,9 @@ static VALUE convolver_convolve_basic(VALUE self, VALUE signal, VALUE kernel) {
   narray_t *kernel_narray;
   int rank;
   int i;
-  int signal_shape[LARGEST_RANK];
-  int kernel_shape[LARGEST_RANK];
-  int result_shape[LARGEST_RANK];
+  size_t signal_shape[LARGEST_RANK];
+  size_t kernel_shape[LARGEST_RANK];
+  size_t result_shape[LARGEST_RANK];
   size_t numo_result_shape[LARGEST_RANK];
 
   (void)self;
@@ -47,6 +43,12 @@ static VALUE convolver_convolve_basic(VALUE self, VALUE signal, VALUE kernel) {
 
   signal_value = rb_funcall(numo_cSFloat, rb_intern("cast"), 1, signal);
   kernel_value = rb_funcall(numo_cSFloat, rb_intern("cast"), 1, kernel);
+  if (!RTEST(na_check_contiguous(signal_value))) {
+    signal_value = na_copy(signal_value);
+  }
+  if (!RTEST(na_check_contiguous(kernel_value))) {
+    kernel_value = na_copy(kernel_value);
+  }
   GetNArray(signal_value, signal_narray);
   GetNArray(kernel_value, kernel_narray);
 
@@ -66,10 +68,10 @@ static VALUE convolver_convolve_basic(VALUE self, VALUE signal, VALUE kernel) {
   copy_shape(rank, kernel_narray->shape, kernel_shape);
 
   for (i = 0; i < rank; i++) {
-    result_shape[i] = signal_shape[i] - kernel_shape[i] + 1;
-    if (result_shape[i] < 1) {
+    if (signal_shape[i] < kernel_shape[i]) {
       rb_raise(rb_eArgError, "kernel must not be larger than signal in any dimension");
     }
+    result_shape[i] = signal_shape[i] - kernel_shape[i] + 1;
     numo_result_shape[rank - i - 1] = (size_t)result_shape[i];
   }
 

data/lib/convolver/version.rb

@@ -2,5 +2,5 @@
 
 module Convolver
   # Current gem version.
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: convolver
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Neil Slater