xxtea 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8eca82a1c887086264d8807bf55a1980dc28f35f956c02a5bf66ebef33ab8f6
-  data.tar.gz: d6707b17d68788035c7d8f2d90210f15408ba3a1d7a0e3c4dc0636d2b519dd10
+  metadata.gz: 52dd181dad48d0089d4f84d4b715b0c7231ea004c35928e4ec5c154b5c19a569
+  data.tar.gz: b60c3915ae8573e6d234cd6e9315f48ccb893c535d78ed3defd5f61428b4c825
 SHA512:
-  metadata.gz: e829728fcc9f4296e74f9bee45568aab867679971c866ca992146a715a62444fea17602bf21322041c82bed745d7ba7a7f10905e7df4ecf194547b41164ac686
-  data.tar.gz: 3a4224238e8e3d062dfc83671981834e1ab571c2e293bb90095db8ad46de86921c94d87972dcd0f3180ab6c562d9913e1dd1f2f4692dd07815752ffb12b8349e
+  metadata.gz: a49001c4bb5c6e53a495bf3a96ecc61d084bb822a77dfda6370dd432b5f50ae54321ffbec3736cc1773fc68059465cb42aeedb3db2511b54c86f44ba390976f0
+  data.tar.gz: a9671360c531507c76ddec41561817312e4f0c961ef1bc6865b6e2ae5ff1ac39eab35d990ca1cab69317992e815e34277e039b60cab7b6b692aa20c550f51731

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.1.0
+
+- Add named padding schemes: `:pkcs7_4_min8` (default, also `true`), `:pkcs7_8`, and `:none` (also `false`).
+- `:pkcs7_4_min8` is 4-byte PKCS#7-like with an 8-byte minimum (pad values 5–8 for short inputs), compatible with Python xxtea.
+- `:pkcs7_8` is standard 8-byte PKCS#7, compatible with Python [xxteang](https://github.com/ifduyue/xxteang).
+
 ## 1.0.0
 
 - Rewrite as a Ruby C extension compatible with Python [xxtea](https://github.com/ifduyue/xxtea) 5.3.3.

data/README.md

@@ -5,7 +5,8 @@
 
 [XXTEA](https://en.wikipedia.org/wiki/XXTEA) implemented as a Ruby C extension, licensed under 2-clause BSD.
 
-Ciphertext is compatible with the [Python xxtea](https://github.com/ifduyue/xxtea) package.
+Default ciphertext is compatible with the [Python xxtea](https://github.com/ifduyue/xxtea) package.
+`padding: :pkcs7_8` is compatible with [Python xxteang](https://github.com/ifduyue/xxteang).
 
 The XXTEA algorithm takes a 128-bit key and operates on an array of 32-bit
 integers (at least 2 integers), but it doesn't define the conversions between
@@ -21,12 +22,11 @@ integers, which is required by the XXTEA algorithm). As a result of these
 measures, you can encrypt not only texts, but also any binary bytes of any
 length.
 
-> **Note:** This implementation uses a **non-standard** 4-byte block PKCS#7
-> padding instead of the conventional 8-byte or 16-byte block. For inputs
-> shorter than 4 bytes, a non-standard hack pads an extra 4 bytes (producing
-> pad values 5–8) to satisfy XXTEA's 2-word minimum. This means the output is
-> **NOT** compatible with other XXTEA implementations. Pass `padding: false`
-> for raw XXTEA (requires data length ≥ 8 and multiple of 4).
+> **Note:** The default (`:pkcs7_4_min8`) is **not** standard 4-byte PKCS#7.
+> For inputs shorter than 4 bytes it pads an extra 4 bytes (pad values 5–8)
+> to satisfy XXTEA's 2-word minimum. Pass `padding: :pkcs7_8` for standard
+> 8-byte PKCS#7 (compatible with Python xxteang), or `padding: false` for
+> raw XXTEA (requires data length ≥ 8 and multiple of 4).
 
 ## Installation
 
@@ -87,9 +87,10 @@ They are stored on the object and used by every `encrypt`, `decrypt`,
 `encrypt_hex`, and `decrypt_hex` call:
 
 ```ruby
-c = XXTEA.new(key)                       # rounds=0, padding=true
-c = XXTEA.new(key, rounds: 64)           # override rounds
-c = XXTEA.new(key, padding: false)       # disable padding
+c = XXTEA.new(key)                         # rounds=0, padding=:pkcs7_4_min8
+c = XXTEA.new(key, rounds: 64)             # override rounds
+c = XXTEA.new(key, padding: false)         # disable padding
+c = XXTEA.new(key, padding: :pkcs7_8)      # 8-byte PKCS#7
 c = XXTEA.new(key, padding: false, rounds: 42)
 ```
 
@@ -103,19 +104,31 @@ s == XXTEA.decrypt([hexenc].pack("H*"), key)  # => true
 
 ## Padding
 
-Padding is enabled by default, using a **non-standard 4-byte block PKCS#7**
-scheme. The pad byte value is `4 - (data.bytesize & 3)` (range 1–4), plus an
-extra 4 bytes when the input is shorter than 4 bytes to meet XXTEA's 2-word
-minimum (producing pad values 5–8).
+`padding` accepts a scheme name, so more paddings can be added later:
 
-Because padding always adds at least one byte, encrypting an 8-byte input
-produces a 12-byte ciphertext. This is incompatible with other XXTEA
-implementations that use a standard block size or skip padding altogether.
-Use `padding: false` for raw, unpadded XXTEA.
+| Value | Meaning |
+| --- | --- |
+| `true` or `:pkcs7_4_min8` (default) | 4-byte PKCS#7-like, padded to at least 8 bytes. Compatible with Python xxtea. Not standard 4-byte PKCS#7 |
+| `:pkcs7_8` | Standard **8-byte** PKCS#7, compatible with Python xxteang |
+| `false` or `:none` | No padding (raw XXTEA) |
+
+`XXTEA::PKCS7_4_MIN8` and `XXTEA::PKCS7_8` are aliases for the symbols.
+
+The default `:pkcs7_4_min8` scheme uses pad byte value `4 - (data.bytesize & 3)`
+(range 1–4), plus an extra 4 bytes when the input is shorter than 4 bytes
+to meet XXTEA's 2-word minimum (producing pad values 5–8). Standard 4-byte
+PKCS#7 never uses pad values 5–8. Because padding always adds at least one
+byte, encrypting an 8-byte input produces a 12-byte ciphertext.
+
+8-byte PKCS#7 uses pad byte value `8 - (data.bytesize & 7)` (range 1–8).
+Encrypting an 8-byte input produces a 16-byte ciphertext.
 
 ```ruby
 XXTEA.decrypt_hex(XXTEA.encrypt_hex("", key), key)   # => ""
 XXTEA.decrypt_hex(XXTEA.encrypt_hex(" ", key), key)  # => " "
+
+XXTEA.encrypt("12345678", key).bytesize                      # => 12  (:pkcs7_4_min8)
+XXTEA.encrypt("12345678", key, padding: :pkcs7_8).bytesize   # => 16  (:pkcs7_8)
 ```
 
 You can disable padding by setting `padding: false`.
@@ -196,7 +209,8 @@ XXTEA.new("k" * 16, rounds: 2**32)
 
 ## Compatibility
 
-- Compatible with [Python xxtea](https://github.com/ifduyue/xxtea) (same padding, endianness, and rounds).
+- Compatible with [Python xxtea](https://github.com/ifduyue/xxtea) (default `:pkcs7_4_min8` padding, endianness, and rounds).
+- `padding: :pkcs7_8` is compatible with [Python xxteang](https://github.com/ifduyue/xxteang).
 - The `XXTEA.encrypt(data, key)` / `XXTEA.decrypt(data, key)` class methods remain compatible with gem 0.0.1 for valid ciphertext. `XXTEA` is now a class rather than a module, and invalid padding raises `ArgumentError` instead of returning stripped bytes.
 
 ## Releasing

data/ext/xxtea/xxtea.c

@@ -22,9 +22,11 @@
  * 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.
  *
- * Ciphertext is compatible with the Python xxtea package
+ * Default ciphertext is compatible with the Python xxtea package
  * (https://github.com/ifduyue/xxtea): little-endian 32-bit words and
- * non-standard 4-byte PKCS#7 padding (pad+4 for inputs shorter than 4 bytes).
+ * :pkcs7_4_min8 padding (4-byte PKCS#7-like, pad+4 for inputs shorter than 4 bytes).
+ * padding: :pkcs7_8 uses 8-byte PKCS#7, compatible with Python xxteang
+ * (https://github.com/ifduyue/xxteang).
  */
 
 #include "ruby.h"
@@ -45,6 +47,9 @@
 
 static ID id_padding;
 static ID id_rounds;
+static ID id_none;
+static ID id_pkcs7_4_min8;
+static ID id_pkcs7_8;
 static VALUE cXXTEA;
 
 typedef struct {
@@ -134,24 +139,45 @@ bytes2longs(const char *in, long inlen, uint32_t *out, int padding)
 #endif
     }
 
+    i = nwords << 2;
+
+    if (padding == 8) {
+        /*
+         * 8-byte PKCS#7 (xxteang): pad = 8 - (len & 7), range 1-8.
+         * Completes the partial word, then adds a whole extra pad word
+         * unless the length is 4 mod 8.
+         */
+        uint32_t w = 0;
+        int r = (int)(inlen & 3);
+        int shift = 0;
+        uint32_t pw;
+        for (; i < inlen; i++, shift += 8) {
+            w |= (uint32_t)s[i] << shift;
+        }
+        pad = 8 - (int)(inlen & 7);
+        pw = (uint32_t)pad * 0x01010101u;
+        w |= pw & (~0u << (8 * r));
+        out[nwords] = w;
+        if ((inlen & 4) == 0) {
+            out[nwords + 1] = pw;
+        }
+        return;
+    }
+
     /*
-     * Assemble the final partial word (0-3 leftover data bytes plus
-     * padding) in a local and store it with a single write, so every
-     * output byte is written exactly once and the caller does not need
-     * to zero the buffer first.  Inputs shorter than 4 bytes are padded
-     * to two words, which also guarantees the minimum XXTEA block size.
+     * :pkcs7_4_min8 (default): 4-byte PKCS#7-like, but inputs shorter
+     * than 4 bytes are padded to two words (pad values 5-8) for XXTEA's
+     * 2-word minimum.  Not standard PKCS#7.
      */
-    i = nwords << 2;
-    if (padding || (inlen & 3) != 0) {
+    if (padding == 4 || (inlen & 3) != 0) {
         uint32_t w = 0;
         int r = (int)(inlen & 3);
         int shift = 0;
         for (; i < inlen; i++, shift += 8) {
             w |= (uint32_t)s[i] << shift;
         }
-        if (padding) {
+        if (padding == 4) {
             pad = 4 - r;
-            /* Ensure XXTEA always has at least two 32-bit words. */
             if (inlen < 4) {
                 pad += 4;
             }
@@ -190,7 +216,7 @@ longs2bytes(const uint32_t *in, long inlen, char *out, int padding)
 
     outlen = inlen * 4;
 
-    /* 4-byte PKCS#7-style unpadding. */
+    /* PKCS#7-style unpadding (4-byte or 8-byte; pad values 1-8). */
     if (padding) {
         pad = s[outlen - 1];
         outlen -= pad;
@@ -266,13 +292,47 @@ parse_rounds(VALUE obj)
     return NUM2UINT(obj);
 }
 
+/* 0 = none, 4 = :pkcs7_4_min8 (default), 8 = :pkcs7_8. */
+static int
+parse_padding(VALUE obj)
+{
+    ID id;
+
+    if (obj == Qfalse) {
+        return 0;
+    }
+    if (obj == Qtrue) {
+        return 4;
+    }
+    if (RB_TYPE_P(obj, T_STRING)) {
+        obj = rb_str_intern(obj);
+    }
+    if (!SYMBOL_P(obj)) {
+        rb_raise(rb_eTypeError,
+                 "padding must be true, false, :none, :pkcs7_4_min8, or :pkcs7_8");
+    }
+    id = SYM2ID(obj);
+    if (id == id_none) {
+        return 0;
+    }
+    if (id == id_pkcs7_4_min8) {
+        return 4;
+    }
+    if (id == id_pkcs7_8) {
+        return 8;
+    }
+    rb_raise(rb_eArgError,
+             "unknown padding %+"PRIsVALUE" (expected :none, :pkcs7_4_min8, or :pkcs7_8)",
+             obj);
+}
+
 static void
 parse_opts(VALUE opts, int *padding, unsigned int *rounds)
 {
     ID kwids[2];
     VALUE kwvals[2];
 
-    *padding = 1;
+    *padding = 4;
     *rounds = 0;
     if (NIL_P(opts)) {
         return;
@@ -283,7 +343,7 @@ parse_opts(VALUE opts, int *padding, unsigned int *rounds)
     rb_get_kwargs(opts, kwids, 0, 2, kwvals);
 
     if (kwvals[0] != Qundef) {
-        *padding = RTEST(kwvals[0]);
+        *padding = parse_padding(kwvals[0]);
     }
     if (kwvals[1] != Qundef) {
         *rounds = parse_rounds(kwvals[1]);
@@ -315,7 +375,18 @@ encrypt_impl(VALUE data, const char key[16], int padding, unsigned int rounds)
                  "Data length must be a multiple of 4 bytes and must not be less than 8 bytes");
     }
 
-    alen = data_len < 4 ? 2 : (data_len >> 2) + padding;
+    if (padding == 8) {
+        if (data_len > LONG_MAX - 8) {
+            rb_raise(rb_eRangeError, "data too large");
+        }
+        alen = ((data_len & ~7L) + 8) >> 2;
+    }
+    else if (padding == 4) {
+        alen = data_len < 4 ? 2 : (data_len >> 2) + 1;
+    }
+    else {
+        alen = data_len >> 2;
+    }
     if (alen > INT_MAX || alen > LONG_MAX / 4) {
         rb_raise(rb_eRangeError, "data too large");
     }
@@ -501,7 +572,7 @@ xxtea_alloc(VALUE klass)
     xxtea_cipher_t *cipher;
     VALUE obj = TypedData_Make_Struct(klass, xxtea_cipher_t, &xxtea_cipher_type, cipher);
     memset(cipher, 0, sizeof(*cipher));
-    cipher->padding = 1;
+    cipher->padding = 4;
     cipher->rounds = 0;
     return obj;
 }
@@ -556,7 +627,9 @@ xxtea_inspect(VALUE self)
     xxtea_cipher_t *cipher = xxtea_get(self);
     return rb_sprintf("#<%s:%p padding=%s rounds=%u>",
                       rb_obj_classname(self), (void *)self,
-                      cipher->padding ? "true" : "false", cipher->rounds);
+                      cipher->padding == 0 ? "false" :
+                      cipher->padding == 4 ? "pkcs7_4_min8" : "pkcs7_8",
+                      cipher->rounds);
 }
 
 void
@@ -566,6 +639,9 @@ Init_xxtea(void)
 
     id_padding = rb_intern("padding");
     id_rounds = rb_intern("rounds");
+    id_none = rb_intern("none");
+    id_pkcs7_4_min8 = rb_intern("pkcs7_4_min8");
+    id_pkcs7_8 = rb_intern("pkcs7_8");
 
     cXXTEA = rb_define_class("XXTEA", rb_cObject);
     rb_define_alloc_func(cXXTEA, xxtea_alloc);
@@ -581,4 +657,7 @@ Init_xxtea(void)
     rb_define_method(cXXTEA, "encrypt_hex", xxtea_encrypt_hex, 1);
     rb_define_method(cXXTEA, "decrypt_hex", xxtea_decrypt_hex, 1);
     rb_define_method(cXXTEA, "inspect", xxtea_inspect, 0);
+
+    rb_define_const(cXXTEA, "PKCS7_4_MIN8", ID2SYM(id_pkcs7_4_min8));
+    rb_define_const(cXXTEA, "PKCS7_8", ID2SYM(id_pkcs7_8));
 }

data/lib/xxtea/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class XXTEA
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xxtea
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Yue Du