xxtea 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 40a67d849e79434013e6648f21ddc02e7e6e93cf
-  data.tar.gz: 480a724d92d0ec28c64a264e7ababd1daf0a23ad
+SHA256:
+  metadata.gz: b8eca82a1c887086264d8807bf55a1980dc28f35f956c02a5bf66ebef33ab8f6
+  data.tar.gz: d6707b17d68788035c7d8f2d90210f15408ba3a1d7a0e3c4dc0636d2b519dd10
 SHA512:
-  metadata.gz: f9344b00aae36904b61f0facd0900a734c462e036335021dce7494f083f3fe0949a3e9102ba3bfd5dd8cc0094bd7cb22a46995dac76f9a28f8bef8eddf1e92a3
-  data.tar.gz: 844b8fea4b61f4a71863952af8f0117f0c1eb52da0335ecc1fb8098470cc810619cc65c8c5d0f162dad4ec5ae674c5fd6cc6d28f9961d20331d68cec53025644
+  metadata.gz: e829728fcc9f4296e74f9bee45568aab867679971c866ca992146a715a62444fea17602bf21322041c82bed745d7ba7a7f10905e7df4ecf194547b41164ac686
+  data.tar.gz: 3a4224238e8e3d062dfc83671981834e1ab571c2e293bb90095db8ad46de86921c94d87972dcd0f3180ab6c562d9913e1dd1f2f4692dd07815752ffb12b8349e

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 1.0.0
+
+- Rewrite as a Ruby C extension compatible with Python [xxtea](https://github.com/ifduyue/xxtea) 5.3.3.
+- Keep `XXTEA.encrypt` / `XXTEA.decrypt` (16-byte key, non-standard 4-byte PKCS#7 padding).
+- Add `padding:` and `rounds:` keyword arguments.
+- Add `encrypt_hex` / `decrypt_hex`.
+- Add `XXTEA.new(key, padding: true, rounds: 0)` cipher objects.
+- Validate PKCS#7 padding on decrypt; reject invalid padding with `ArgumentError`.
+- Encode ciphertext as little-endian bytes on all architectures.
+- Require Ruby >= 3.1.
+
+## 0.0.1 — 2015-03-08
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2026, Yue Du
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * 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.

data/README.md

@@ -0,0 +1,216 @@
+# xxtea
+
+[![CI](https://github.com/ifduyue/ruby-xxtea/actions/workflows/test.yml/badge.svg)](https://github.com/ifduyue/ruby-xxtea/actions/workflows/test.yml)
+[![Gem Version](https://badge.fury.io/rb/xxtea.svg)](https://rubygems.org/gems/xxtea)
+
+[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.
+
+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
+bytes and array. Due to this reason, many XXTEA implementations out there are
+not compatible with each other.
+
+In this implementation, the conversions between bytes and array are taken care
+of by `longs2bytes` and `bytes2longs`. A non-standard 4-byte block
+[PKCS#7](https://en.wikipedia.org/wiki/Padding_(cryptography)#PKCS7) padding is
+used to make sure that the input bytes are padded to a multiple of 4-byte (the
+size of a 32-bit integer) and at least 8-byte long (the size of two 32-bit
+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).
+
+## Installation
+
+A C compiler is required. Then:
+
+```
+$ gem install xxtea
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem "xxtea"
+```
+
+## Usage
+
+This gem provides four class methods: `encrypt`, `decrypt`, `encrypt_hex`, and
+`decrypt_hex`, plus an `XXTEA` type for reusable cipher objects.
+
+```ruby
+require "xxtea"
+require "securerandom"
+
+key = SecureRandom.random_bytes(16)  # Key must be a 16-byte string.
+s = "xxtea is good"
+
+enc = XXTEA.encrypt(s, key)
+dec = XXTEA.decrypt(enc, key)
+s == dec  # => true
+
+hexenc = XXTEA.encrypt_hex(s, key)
+s == XXTEA.decrypt_hex(hexenc, key)  # => true
+
+enc.unpack1("H*") == hexenc  # => true
+```
+
+## XXTEA Type
+
+The `XXTEA` type holds a 16-byte key, rounds, and padding setting, so you can
+encrypt and decrypt multiple times without passing them each call.
+
+```ruby
+cipher = XXTEA.new(key, padding: false, rounds: 128)
+cipher
+# => #<XXTEA:0x... padding=false rounds=128>
+
+enc = cipher.encrypt("12345678")
+cipher.decrypt(enc)  # => "12345678"
+
+hexenc = cipher.encrypt_hex("12345678")
+cipher.decrypt_hex(hexenc)  # => "12345678"
+```
+
+`rounds` defaults to `0` (auto), `padding` defaults to `true`.
+`rounds: 0` means `6 + 52 / n`, where n is the number of 32-bit words in the data.
+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, padding: false, rounds: 42)
+```
+
+`encrypt_hex` and `decrypt_hex` operate on ciphertext in a hexadecimal
+representation. They are exactly equivalent to:
+
+```ruby
+hexenc = XXTEA.encrypt(s, key).unpack1("H*")
+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).
+
+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.
+
+```ruby
+XXTEA.decrypt_hex(XXTEA.encrypt_hex("", key), key)   # => ""
+XXTEA.decrypt_hex(XXTEA.encrypt_hex(" ", key), key)  # => " "
+```
+
+You can disable padding by setting `padding: false`.
+In this case data will not be padded, so data length must be a multiple of 4
+bytes and must not be less than 8 bytes. Otherwise `ArgumentError` will be
+raised:
+
+```ruby
+XXTEA.encrypt_hex("", key, padding: false)
+# ArgumentError: Data length must be a multiple of 4 bytes and must not be less than 8 bytes
+
+XXTEA.encrypt_hex("xxtea is good", key, padding: false)
+# ArgumentError: Data length must be a multiple of 4 bytes and must not be less than 8 bytes
+
+XXTEA.decrypt_hex(XXTEA.encrypt_hex("12345678", key, padding: false), key, padding: false)
+# => "12345678"
+```
+
+## Rounds
+
+By default xxtea manipulates the input data for `6 + 52 / n` rounds,
+where n denotes how many 32-bit integers the input data can fit in.
+We can change this by setting the `rounds` parameter.
+
+Do note that the more rounds it is, the more time will be consumed.
+`rounds` must fit in a 32-bit unsigned integer; values exceeding
+`2**32 - 1` raise `RangeError`.
+
+```ruby
+data = "0123456789"
+key = "abcdefghijklmnop"
+XXTEA.encrypt_hex(data, key)
+# => "5b80b08a5d1923e4cd992dd5"
+6 + 52 / ((data.bytesize + 3) / 4)  # 23
+XXTEA.encrypt_hex(data, key, rounds: 23)
+# => "5b80b08a5d1923e4cd992dd5"
+XXTEA.encrypt_hex(data, key, rounds: 1024)
+# => "1577bbf28c43ced93bd50720"
+```
+
+## Catching Exceptions
+
+When calling these methods, an `ArgumentError`, `TypeError`, or `RangeError`
+may be raised.
+
+```ruby
+begin
+  XXTEA.decrypt("", key: "")
+rescue => e
+  puts "#{e.class} : #{e.message}"
+end
+# ArgumentError : Need a 16-byte key.
+
+XXTEA.decrypt("", " " * 16)
+# ArgumentError : Data length must be a multiple of 4 bytes and must not be less than 8 bytes
+
+XXTEA.decrypt(" " * 8, " " * 16)
+# ArgumentError : Invalid data, illegal padding. Could be using a wrong key.
+
+XXTEA.decrypt_hex(" " * 8, " " * 16)
+# ArgumentError : Non-hexadecimal digit found
+
+XXTEA.decrypt_hex("abc", " " * 16)
+# ArgumentError : Odd-length string
+
+XXTEA.decrypt_hex("abcd", " " * 16)
+# ArgumentError : Data length must be a multiple of 4 bytes and must not be less than 8 bytes
+
+XXTEA.encrypt("x", "k" * 16, rounds: 2**32)
+# RangeError : rounds value too large
+
+XXTEA.new("short")
+# ArgumentError : Need a 16-byte key.
+
+XXTEA.new("k" * 16, rounds: 2**32)
+# RangeError : rounds value too large
+```
+
+## Compatibility
+
+- Compatible with [Python xxtea](https://github.com/ifduyue/xxtea) (same padding, endianness, and rounds).
+- 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
+
+Push a `v*` tag (for example `v1.0.0`). [`.github/workflows/build.yml`](.github/workflows/build.yml) builds the gem, publishes it to RubyGems.org via [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/), and creates a GitHub Release.
+
+The trusted publisher on RubyGems.org must match:
+
+- Repository owner: `ifduyue`
+- Repository name: `ruby-xxtea`
+- Workflow filename: `build.yml`
+- Environment: `release`
+
+## License
+
+BSD-2-Clause. See [LICENSE](LICENSE).
+

data/ext/xxtea/extconf.rb

@@ -1,5 +1,5 @@
-require 'mkmf'
+# frozen_string_literal: true
 
-$CFLAGS += ' -g -O3 -Wall '
+require "mkmf"
 
-create_makefile('xxtea/xxtea')
+create_makefile("xxtea/xxtea")

data/ext/xxtea/xxtea.c

@@ -1,19 +1,84 @@
-
+/*
+ * Copyright (c) 2014-2026, Yue Du
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * 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.
+ *
+ * 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).
+ */
+
+#include "ruby.h"
+#include "ruby/encoding.h"
+
+#include <limits.h>
 #include <stdint.h>
-#include <stdlib.h>
-#include <ruby.h>
-
-
-#define DELTA 0x9e3779b9
-#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
+#include <string.h>
+
+#define DELTA 0x9e3779b9U
+#define MX (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z)))
+
+#if defined(WORDS_BIGENDIAN)
+# define XXTEA_LITTLE_ENDIAN 0
+#else
+# define XXTEA_LITTLE_ENDIAN 1
+#endif
+
+static ID id_padding;
+static ID id_rounds;
+static VALUE cXXTEA;
+
+typedef struct {
+    char key[16];
+    unsigned int rounds;
+    int padding;
+} xxtea_cipher_t;
+
+static const rb_data_type_t xxtea_cipher_type = {
+    .wrap_struct_name = "XXTEA",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = NULL,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static inline xxtea_cipher_t *
+xxtea_get(VALUE obj)
+{
+    xxtea_cipher_t *cipher;
+    TypedData_Get_Struct(obj, xxtea_cipher_t, &xxtea_cipher_type, cipher);
+    return cipher;
+}
 
-static void btea(uint32_t *v, int n, uint32_t const key[4])
+static void
+btea(uint32_t *v, int n, uint32_t const key[4], unsigned int rounds)
 {
     uint32_t y, z, sum;
-    unsigned p, rounds, e;
+    unsigned p, e;
 
     if (n > 1) {          /* Coding Part */
-        rounds = 6 + 52 / n;
+        rounds = rounds == 0 ? (unsigned)(6 + 52 / n) : rounds;
         sum = 0;
         z = v[n - 1];
 
@@ -21,26 +86,25 @@ static void btea(uint32_t *v, int n, uint32_t const key[4])
             sum += DELTA;
             e = (sum >> 2) & 3;
 
-            for (p = 0; p < n - 1; p++) {
+            for (p = 0; p < (unsigned)(n - 1); p++) {
                 y = v[p + 1];
                 z = v[p] += MX;
             }
 
             y = v[0];
             z = v[n - 1] += MX;
-        }
-        while (--rounds);
+        } while (--rounds);
     }
     else if (n < -1) {    /* Decoding Part */
         n = -n;
-        rounds = 6 + 52 / n;
-        sum = rounds * DELTA;
+        rounds = rounds == 0 ? (unsigned)(6 + 52 / n) : rounds;
+        sum = (uint32_t)(rounds * DELTA);
         y = v[0];
 
         do {
             e = (sum >> 2) & 3;
 
-            for (p = n - 1; p > 0; p--) {
+            for (p = (unsigned)(n - 1); p > 0; p--) {
                 z = v[p - 1];
                 y = v[p] -= MX;
             }
@@ -48,182 +112,473 @@ static void btea(uint32_t *v, int n, uint32_t const key[4])
             z = v[n - 1];
             y = v[0] -= MX;
             sum -= DELTA;
-        }
-        while (--rounds);
+        } while (--rounds);
     }
 }
 
-static int bytes2longs(const char *in, int inlen, uint32_t *out, int padding)
+static void
+bytes2longs(const char *in, long inlen, uint32_t *out, int padding)
 {
-    int i, pad;
-    const unsigned char *s;
-
-    s = (const unsigned char *)in;
-
-    /* (i & 3) << 3 -> [0, 8, 16, 24] */
-    for (i = 0; i < inlen;  i++) {
-        out[i >> 2] |= s[i] << ((i & 3) << 3);
+    long i, nwords;
+    int pad;
+    const unsigned char *s = (const unsigned char *)in;
+
+    nwords = inlen >> 2;
+    for (i = 0; i < nwords; i++) {
+#if XXTEA_LITTLE_ENDIAN
+        memcpy(&out[i], s + 4 * i, 4);
+#else
+        const unsigned char *p = s + 4 * i;
+        out[i] = (uint32_t)p[0] | ((uint32_t)p[1] << 8) |
+                 ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
+#endif
     }
 
-    /* PKCS#7 padding */
-    if (padding) {
-        pad = 4 - (inlen & 3);
-        /* make sure lenght of out >= 2 */
-        pad = (inlen < 4) ? pad + 4 : pad;
-        for (i = inlen; i < inlen + pad; i++) {
-            out[i >> 2] |= pad << ((i & 3) << 3);
+    /*
+     * 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.
+     */
+    i = nwords << 2;
+    if (padding || (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) {
+            pad = 4 - r;
+            /* Ensure XXTEA always has at least two 32-bit words. */
+            if (inlen < 4) {
+                pad += 4;
+            }
+            w |= (uint32_t)pad * 0x01010101u & (~0u << (8 * r));
+            if (inlen < 4) {
+                out[nwords + 1] = (uint32_t)pad * 0x01010101u;
+            }
         }
+        out[nwords] = w;
     }
-
-    /* Divided by 4, and then rounded up (ceil) to an integer.
-     * Which is the number of how many longs we've got.
-     */
-    return ((i - 1) >> 2) + 1;
 }
 
-static int longs2bytes(uint32_t *in, int inlen, char *out, int padding)
+static long
+longs2bytes(const uint32_t *in, long inlen, char *out, int padding)
 {
-    int i, pad;
-    unsigned char *s;
-
-    s = (unsigned char *)out;
-
+    long i, outlen;
+    int pad;
+    unsigned char *s = (unsigned char *)out;
+
+#if XXTEA_LITTLE_ENDIAN
+    /* Callers always pass the same buffer; words are already LE bytes. */
+    (void)in;
+#else
+    /*
+     * Big endian: write each word as little-endian bytes.  Snapshot the
+     * whole word first because in and out alias.
+     */
     for (i = 0; i < inlen; i++) {
-        s[4 * i] = in[i] & 0xFF;
-        s[4 * i + 1] = (in[i] >> 8) & 0xFF;
-        s[4 * i + 2] = (in[i] >> 16) & 0xFF;
-        s[4 * i + 3] = (in[i] >> 24) & 0xFF;
+        uint32_t word = in[i];
+        s[4 * i]     = (unsigned char)(word & 0xFF);
+        s[4 * i + 1] = (unsigned char)((word >> 8) & 0xFF);
+        s[4 * i + 2] = (unsigned char)((word >> 16) & 0xFF);
+        s[4 * i + 3] = (unsigned char)((word >> 24) & 0xFF);
     }
+#endif
 
-    i *= 4;
+    outlen = inlen * 4;
 
-    /* PKCS#7 unpadding */
+    /* 4-byte PKCS#7-style unpadding. */
     if (padding) {
-        pad = s[i - 1];
-        i -= pad;
-    }
+        pad = s[outlen - 1];
+        outlen -= pad;
+
+        if (pad < 1 || pad > 8) {
+            return -1;
+        }
 
-    s[i] = '\0';
+        if (outlen < 0) {
+            return -2;
+        }
+
+        for (i = outlen; i < inlen * 4; i++) {
+            if (s[i] != pad) {
+                return -3;
+            }
+        }
+    }
 
-    /* How many bytes we've got */
-    return i;
+    s[outlen] = '\0';
+    return outlen;
 }
 
-VALUE xxtea_encrypt(VALUE mod, VALUE data, VALUE key)
+typedef struct {
+    const char *data;
+    long data_len;
+    char key[16];
+    uint32_t *buf;
+    int n;
+    int padding;
+    unsigned int rounds;
+    long rc;
+} crypt_job;
+
+static void *
+encrypt_nogvl(void *ptr)
 {
-    int alen, dlen, klen;
-    uint32_t *d, k[4];
-    VALUE retval;
-    char *retbuf;
+    crypt_job *j = (crypt_job *)ptr;
+    uint32_t k[4];
+
+    bytes2longs(j->data, j->data_len, j->buf, j->padding);
+    bytes2longs(j->key, 16, k, 0);
+    btea(j->buf, j->n, k, j->rounds);
+#if !XXTEA_LITTLE_ENDIAN
+    longs2bytes(j->buf, j->n, (char *)j->buf, 0);
+#endif
+    return NULL;
+}
 
-    d = NULL;
-    k[0] = k[1] = k[2] = k[3] = 0;
+static void *
+decrypt_nogvl(void *ptr)
+{
+    crypt_job *j = (crypt_job *)ptr;
+    uint32_t k[4];
+
+    bytes2longs(j->data, j->data_len, j->buf, 0);
+    bytes2longs(j->key, 16, k, 0);
+    btea(j->buf, -j->n, k, j->rounds);
+    j->rc = longs2bytes(j->buf, j->n, (char *)j->buf, j->padding);
+    return NULL;
+}
 
-    Check_Type(data, T_STRING);
-    Check_Type(key, T_STRING);
+static unsigned int
+parse_rounds(VALUE obj)
+{
+    if (!RB_INTEGER_TYPE_P(obj)) {
+        rb_raise(rb_eTypeError, "rounds must be an Integer");
+    }
+    if (RTEST(rb_funcall(obj, rb_intern("<"), 1, INT2FIX(0))) ||
+        RTEST(rb_funcall(obj, rb_intern(">"), 1, UINT2NUM(UINT_MAX)))) {
+        rb_raise(rb_eRangeError, "rounds value too large");
+    }
+    return NUM2UINT(obj);
+}
 
-    dlen = RSTRING_LEN(data);
-    klen = RSTRING_LEN(key);
+static void
+parse_opts(VALUE opts, int *padding, unsigned int *rounds)
+{
+    ID kwids[2];
+    VALUE kwvals[2];
 
-    if (klen != 16) {
-        rb_raise(rb_eArgError, "Need a 16-byte key.");
-        return Qnil;
+    *padding = 1;
+    *rounds = 0;
+    if (NIL_P(opts)) {
+        return;
     }
 
-    alen = dlen < 4 ? 2 : (dlen >> 2) + 1;
-    d = (uint32_t *)calloc(alen, sizeof(uint32_t));
+    kwids[0] = id_padding;
+    kwids[1] = id_rounds;
+    rb_get_kwargs(opts, kwids, 0, 2, kwvals);
+
+    if (kwvals[0] != Qundef) {
+        *padding = RTEST(kwvals[0]);
+    }
+    if (kwvals[1] != Qundef) {
+        *rounds = parse_rounds(kwvals[1]);
+    }
+}
 
-    if (!d) {
-      rb_raise(rb_eNoMemError, "calloc failed.");
-      return Qnil;
+static void
+require_key(VALUE key, char out[16])
+{
+    StringValue(key);
+    if (RSTRING_LEN(key) != 16) {
+        rb_raise(rb_eArgError, "Need a 16-byte key.");
     }
+    memcpy(out, RSTRING_PTR(key), 16);
+}
 
-    bytes2longs(StringValuePtr(data), dlen, d, 1);
-    bytes2longs(StringValuePtr(key), klen, k, 0);
-    btea(d, alen, k);
+static VALUE
+encrypt_impl(VALUE data, const char key[16], int padding, unsigned int rounds)
+{
+    crypt_job job;
+    VALUE retval;
+    long data_len, alen;
+
+    StringValue(data);
+    data_len = RSTRING_LEN(data);
 
-    retval = rb_str_new(NULL, (alen << 2));
+    if (!padding && (data_len < 8 || (data_len & 3) != 0)) {
+        rb_raise(rb_eArgError,
+                 "Data length must be a multiple of 4 bytes and must not be less than 8 bytes");
+    }
 
-    if (!retval) {
-        free(d);
-        return Qnil;
+    alen = data_len < 4 ? 2 : (data_len >> 2) + padding;
+    if (alen > INT_MAX || alen > LONG_MAX / 4) {
+        rb_raise(rb_eRangeError, "data too large");
     }
 
-    retbuf = RSTRING_PTR(retval);
-    longs2bytes(d, alen, retbuf, 0);
+    retval = rb_str_new(NULL, alen << 2);
+    rb_enc_associate(retval, rb_ascii8bit_encoding());
 
+    memset(&job, 0, sizeof(job));
+    job.data = RSTRING_PTR(data);
+    job.data_len = data_len;
+    memcpy(job.key, key, 16);
+    job.buf = (uint32_t *)RSTRING_PTR(retval);
+    job.n = (int)alen;
+    job.padding = padding;
+    job.rounds = rounds;
+
+    encrypt_nogvl(&job);
+    RB_GC_GUARD(data);
     return retval;
 }
 
-VALUE xxtea_decrypt(VALUE mod, VALUE data, VALUE key)
+static VALUE
+decrypt_impl(VALUE data, const char key[16], int padding, unsigned int rounds)
 {
-    int alen, dlen, klen, rc;
-    uint32_t *d, k[4];
+    crypt_job job;
     VALUE retval;
-    char *retbuf;
-
-    d = NULL;
-    k[0] = k[1] = k[2] = k[3] = 0;
-
-    Check_Type(data, T_STRING);
-    Check_Type(key, T_STRING);
+    long data_len, alen;
 
-    dlen = RSTRING_LEN(data);
-    klen = RSTRING_LEN(key);
+    StringValue(data);
+    data_len = RSTRING_LEN(data);
 
-    if (klen != 16) {
-        rb_raise(rb_eArgError, "Need a 16-byte key.");
-        return Qnil;
+    if (data_len & 3 || data_len < 8) {
+        rb_raise(rb_eArgError,
+                 "Data length must be a multiple of 4 bytes and must not be less than 8 bytes");
     }
 
-    /* not divided by 4, or length < 8 */
-    if (dlen & 3 || dlen < 8) {
-        rb_raise(rb_eArgError, "Invalid data.");
-        return Qnil;
+    alen = data_len / 4;
+    if (alen > INT_MAX || alen > LONG_MAX / 4) {
+        rb_raise(rb_eRangeError, "data too large");
     }
 
-    retval = rb_str_new(NULL, dlen);
+    retval = rb_str_new(NULL, data_len);
+    rb_enc_associate(retval, rb_ascii8bit_encoding());
+
+    memset(&job, 0, sizeof(job));
+    job.data = RSTRING_PTR(data);
+    job.data_len = data_len;
+    memcpy(job.key, key, 16);
+    job.buf = (uint32_t *)RSTRING_PTR(retval);
+    job.n = (int)alen;
+    job.padding = padding;
+    job.rounds = rounds;
 
-    if (!retval) {
-        free(d);
-        return Qnil;
+    decrypt_nogvl(&job);
+    RB_GC_GUARD(data);
+
+    if (padding) {
+        if (job.rc < 0) {
+            rb_raise(rb_eArgError,
+                     "Invalid data, illegal padding. Could be using a wrong key.");
+        }
+        rb_str_resize(retval, job.rc);
     }
 
-    retbuf = RSTRING_PTR(retval);
+    return retval;
+}
 
-    alen = dlen >> 2;
-    d = (uint32_t *)calloc(alen, sizeof(uint32_t));
+static VALUE
+bytes_to_hex(VALUE bytes)
+{
+    static const char hex[] = "0123456789abcdef";
+    const unsigned char *s;
+    char *d;
+    long i, len;
+    VALUE out;
+
+    StringValue(bytes);
+    len = RSTRING_LEN(bytes);
+    out = rb_usascii_str_new(NULL, len * 2);
+    s = (const unsigned char *)RSTRING_PTR(bytes);
+    d = RSTRING_PTR(out);
+    for (i = 0; i < len; i++) {
+        d[i * 2]     = hex[s[i] >> 4];
+        d[i * 2 + 1] = hex[s[i] & 0x0f];
+    }
+    return out;
+}
+
+static int
+hex_nibble(int c)
+{
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+}
 
-    if (!d) {
-        rb_raise(rb_eNoMemError, "calloc failed.");
-        return Qnil;
+static VALUE
+hex_to_bytes(VALUE hex)
+{
+    const unsigned char *s;
+    unsigned char *d;
+    long i, len;
+    VALUE out;
+
+    StringValue(hex);
+    len = RSTRING_LEN(hex);
+    if (len & 1) {
+        rb_raise(rb_eArgError, "Odd-length string");
     }
 
-    retval = rb_str_new(NULL, (alen << 2));
+    out = rb_str_new(NULL, len / 2);
+    rb_enc_associate(out, rb_ascii8bit_encoding());
+    s = (const unsigned char *)RSTRING_PTR(hex);
+    d = (unsigned char *)RSTRING_PTR(out);
 
-    if (!retval) {
-        free(d);
-        return NULL;
+    for (i = 0; i < len; i += 2) {
+        int hi = hex_nibble(s[i]);
+        int lo = hex_nibble(s[i + 1]);
+        if (hi < 0 || lo < 0) {
+            rb_raise(rb_eArgError, "Non-hexadecimal digit found");
+        }
+        d[i / 2] = (unsigned char)((hi << 4) | lo);
     }
+    return out;
+}
 
-    retbuf = RSTRING_PTR(retval);
+static VALUE
+xxtea_s_encrypt(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE data, key, opts;
+    int padding;
+    unsigned int rounds;
+    char keybuf[16];
+
+    (void)klass;
+    rb_scan_args(argc, argv, "2:", &data, &key, &opts);
+    parse_opts(opts, &padding, &rounds);
+    require_key(key, keybuf);
+    return encrypt_impl(data, keybuf, padding, rounds);
+}
 
-    bytes2longs(StringValuePtr(data), dlen, d, 0);
-    bytes2longs(StringValuePtr(key), klen, k, 0);
-    btea(d, -alen, k);
+static VALUE
+xxtea_s_decrypt(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE data, key, opts;
+    int padding;
+    unsigned int rounds;
+    char keybuf[16];
+
+    (void)klass;
+    rb_scan_args(argc, argv, "2:", &data, &key, &opts);
+    parse_opts(opts, &padding, &rounds);
+    require_key(key, keybuf);
+    return decrypt_impl(data, keybuf, padding, rounds);
+}
 
-    if ((rc = longs2bytes(d, alen, retbuf, 1)) != dlen) {
-        /* Remove PKCS#7 padded chars */
-        rb_str_resize(retval, rc);
-    }
+static VALUE
+xxtea_s_encrypt_hex(int argc, VALUE *argv, VALUE klass)
+{
+    return bytes_to_hex(xxtea_s_encrypt(argc, argv, klass));
+}
 
-    return retval;
+static VALUE
+xxtea_s_decrypt_hex(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE data, key, opts;
+    int padding;
+    unsigned int rounds;
+    char keybuf[16];
+    VALUE raw;
+
+    rb_scan_args(argc, argv, "2:", &data, &key, &opts);
+    parse_opts(opts, &padding, &rounds);
+    raw = hex_to_bytes(data);
+    require_key(key, keybuf);
+    return decrypt_impl(raw, keybuf, padding, rounds);
 }
 
+static VALUE
+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->rounds = 0;
+    return obj;
+}
 
-void Init_xxtea()
+static VALUE
+xxtea_initialize(int argc, VALUE *argv, VALUE self)
 {
-    VALUE mXXTEA = rb_define_module("XXTEA");
-    rb_define_singleton_method(mXXTEA, "encrypt", xxtea_encrypt, 2);
-    rb_define_singleton_method(mXXTEA, "decrypt", xxtea_decrypt, 2);
+    VALUE key, opts;
+    xxtea_cipher_t *cipher = xxtea_get(self);
+    int padding;
+    unsigned int rounds;
+
+    rb_scan_args(argc, argv, "1:", &key, &opts);
+    parse_opts(opts, &padding, &rounds);
+    require_key(key, cipher->key);
+    cipher->padding = padding;
+    cipher->rounds = rounds;
+    return self;
+}
+
+static VALUE
+xxtea_encrypt(VALUE self, VALUE data)
+{
+    xxtea_cipher_t *cipher = xxtea_get(self);
+    return encrypt_impl(data, cipher->key, cipher->padding, cipher->rounds);
+}
+
+static VALUE
+xxtea_decrypt(VALUE self, VALUE data)
+{
+    xxtea_cipher_t *cipher = xxtea_get(self);
+    return decrypt_impl(data, cipher->key, cipher->padding, cipher->rounds);
+}
+
+static VALUE
+xxtea_encrypt_hex(VALUE self, VALUE data)
+{
+    return bytes_to_hex(xxtea_encrypt(self, data));
+}
+
+static VALUE
+xxtea_decrypt_hex(VALUE self, VALUE data)
+{
+    xxtea_cipher_t *cipher = xxtea_get(self);
+    VALUE raw = hex_to_bytes(data);
+    return decrypt_impl(raw, cipher->key, cipher->padding, cipher->rounds);
+}
+
+static VALUE
+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);
+}
+
+void
+Init_xxtea(void)
+{
+    rb_ext_ractor_safe(true);
+
+    id_padding = rb_intern("padding");
+    id_rounds = rb_intern("rounds");
+
+    cXXTEA = rb_define_class("XXTEA", rb_cObject);
+    rb_define_alloc_func(cXXTEA, xxtea_alloc);
+
+    rb_define_singleton_method(cXXTEA, "encrypt", xxtea_s_encrypt, -1);
+    rb_define_singleton_method(cXXTEA, "decrypt", xxtea_s_decrypt, -1);
+    rb_define_singleton_method(cXXTEA, "encrypt_hex", xxtea_s_encrypt_hex, -1);
+    rb_define_singleton_method(cXXTEA, "decrypt_hex", xxtea_s_decrypt_hex, -1);
+
+    rb_define_method(cXXTEA, "initialize", xxtea_initialize, -1);
+    rb_define_method(cXXTEA, "encrypt", xxtea_encrypt, 1);
+    rb_define_method(cXXTEA, "decrypt", xxtea_decrypt, 1);
+    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);
 }

data/lib/xxtea/version.rb

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

data/lib/xxtea.rb

@@ -1,13 +1,4 @@
-require 'xxtea/version'
-require 'xxtea/xxtea'
+# frozen_string_literal: true
 
-
-module XXTEA
-  def self.encrypt_hex(data, key)
-    encrypt(data, key).unpack('H*').first
-  end
-
-  def self.decrypt_hex(data, key)
-    decrypt([data].pack('H*'), key)
-  end 
-end
+require "xxtea/version"
+require "xxtea/xxtea"

metadata

@@ -1,16 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: xxtea
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Yue Du
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-08 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies: []
-description: Ruby xxtea module
+description: |
+  XXTEA implemented as a Ruby C extension. Ciphertext is compatible with the
+  Python xxtea package: little-endian 32-bit words and non-standard 4-byte
+  PKCS#7 padding.
 email:
 - ifduyue@gmail.com
 executables: []
@@ -18,19 +21,23 @@ extensions:
 - ext/xxtea/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
-- Rakefile
+- CHANGELOG.md
+- LICENSE
+- README.md
 - ext/xxtea/extconf.rb
 - ext/xxtea/xxtea.c
 - lib/xxtea.rb
 - lib/xxtea/version.rb
-- xxtea.gemspec
-homepage: http://github.com/ifduyue/xxtea
+homepage: https://github.com/ifduyue/ruby-xxtea
 licenses:
-- BSD
-metadata: {}
-post_install_message: 
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/ifduyue/ruby-xxtea
+  source_code_uri: https://github.com/ifduyue/ruby-xxtea
+  changelog_uri: https://github.com/ifduyue/ruby-xxtea/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/ifduyue/ruby-xxtea/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -38,16 +45,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.2
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Ruby xxtea module
+summary: XXTEA block cipher as a Ruby C extension
 test_files: []

data/.gitignore

@@ -1,3 +0,0 @@
-*.bundle
-*.gem
-*.o

data/Gemfile

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-
-gemspec
-
-gem 'rake'
-gem 'rake-compiler'

data/Rakefile

@@ -1,6 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/extensiontask'
-
-Rake::ExtensionTask.new('xxtea') do |ext|
-  ext.lib_dir = 'lib/xxtea'
-end

data/xxtea.gemspec

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'xxtea/version'
-Gem::Specification.new do |gem|
-  gem.name = "xxtea"
-  gem.version = XXTEA::VERSION
-  gem.authors = ["Yue Du"]
-  gem.email = ["ifduyue@gmail.com"]
-  gem.description = %q{Ruby xxtea module}
-  gem.summary = %q{Ruby xxtea module}
-  gem.homepage = "http://github.com/ifduyue/xxtea"
-  gem.license = 'BSD'
-  gem.files = `git ls-files`.split($/)
-  gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-  gem.extensions = ["ext/xxtea/extconf.rb"]
-end