xxtea-ruby 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 488c7cce3d24c1541ba45624f3d5da139831541c
+  data.tar.gz: d36abcdaaa44bd169df2b2cbba895e47882e6853
+SHA512:
+  metadata.gz: 3e646c093bf4e44d84bfcc4fbf50b27bfc7ed4e81200d495e1be676eb55b4ba867313e77a5d2cfb7addc2f6535f3266f0f25eff15f6d4d02e69829488dd23dc4
+  data.tar.gz: 873474e74ca764d7972b409915633eea03584de3da170f138c2d64195c35276c6fe189acdf9ff1ebc16f7451bc8ef4948bb52fe331ea8fcc853a9d42e35cf1f0

data/.gitignore

@@ -0,0 +1,8 @@
+
+tmp
+
+*.lock
+
+*.bundle
+
+*.gem

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+script: "bundle exec rake test"

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'rake'
+gem 'rake-compiler'
+gem 'minitest', '~> 4.1'

data/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2008-2016 Ma Bingyao <mabingyao@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# XXTEA for Ruby
+
+[![Build Status](https://travis-ci.org/xxtea/xxtea-ruby.svg?branch=master)](https://travis-ci.org/xxtea/xxtea-ruby)
+[![Gem](https://img.shields.io/gem/v/xxtea-ruby.svg)](https://rubygems.org/gems/xxtea-ruby)
+[![Gem](https://img.shields.io/gem/dt/xxtea-ruby.svg)](https://rubygems.org/gems/xxtea-ruby)
+
+## Introduction
+
+XXTEA is a fast and secure encryption algorithm. This is a XXTEA library for Ruby.
+
+It is different from the original XXTEA encryption algorithm. It encrypts and decrypts raw binary data instead of 32bit integer array, and the key is also the raw binary data.
+
+## Installation
+
+```sh
+gem install xxtea-ruby
+```
+
+## Usage
+
+```ruby
+# encoding: utf-8
+require "xxtea"
+text = "Hello World! 你好，中国！"
+key = "1234567890"
+encrypt_data = XXTEA.encrypt(text, key)
+decrypt_data = XXTEA.decrypt_utf8(encrypt_data, key)
+puts (text == decrypt_data ? "success!" : "fail!");
+```
+
+```ruby
+XXTEA.decrypt_utf8(encrypt_data, key) == XXTEA.decrypt(encrypt_data, key).force_encoding(Encoding::UTF_8)
+```
+
+## Note
+
+There is no decrypt_utf8 function in ruby 1.8.x or lower version.

data/README_zh_CN.md

@@ -0,0 +1,36 @@
+# XXTEA 加密算法的 Ruby 实现
+
+[![Build Status](https://travis-ci.org/xxtea/xxtea-ruby.svg?branch=master)](https://travis-ci.org/xxtea/xxtea-ruby)
+[![Gem](https://img.shields.io/gem/v/xxtea-ruby.svg)](https://rubygems.org/gems/xxtea-ruby)
+
+## 简介
+
+XXTEA 是一个快速安全的加密算法。本项目是 XXTEA 加密算法的 Ruby 实现。
+
+它不同于原始的 XXTEA 加密算法。它是针对原始二进制数据类型进行加密的，而不是针对 32 位 int 数组。同样，密钥也是原始二进制数据类型。
+
+## 安装
+
+```sh
+gem install xxtea-ruby
+```
+
+## 使用
+
+```ruby
+# encoding: utf-8
+require "xxtea"
+text = "Hello World! 你好，中国！"
+key = "1234567890"
+encrypt_data = XXTEA.encrypt(text, key)
+decrypt_data = XXTEA.decrypt_utf8(encrypt_data, key)
+puts (text == decrypt_data ? "success!" : "fail!");
+```
+
+```ruby
+XXTEA.decrypt_utf8(encrypt_data, key) == XXTEA.decrypt(encrypt_data, key).force_encoding(Encoding::UTF_8)
+```
+
+## 注意
+
+在 1.8.x 或更低版本的 Ruby 上，没有 decrypt_utf8 这个函数。

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rake/testtask'
+require 'rake/clean'
+
+Rake::ExtensionTask.new('xxtea') do |ext|
+  ext.lib_dir = 'lib'
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test
+
+Rake::Task[:test].prerequisites << :compile

data/ext/xxtea/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS += ' -g -O3 -Wall '
+create_makefile('xxtea')

data/ext/xxtea/ruby_xxtea.c

@@ -0,0 +1,74 @@
+/**********************************************************\
+|                                                          |
+| xxtea.c                                                  |
+|                                                          |
+| XXTEA encryption algorithm library for Lua.              |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Authors: Chen fei <cf850118@163.com>                |
+|               Ma Bingyao <mabingyao@gmail.com>           |
+| LastModified: Feb 8, 2016                                |
+|                                                          |
+\**********************************************************/
+
+#include <ruby.h>
+#ifdef RSTRING_NOEMBED
+#include <ruby/encoding.h>
+#endif
+#include "xxtea.h"
+
+VALUE rb_encrypt(VALUE mod, VALUE data, VALUE key) {
+	unsigned char * result;
+	VALUE retval;
+	size_t data_len, out_len;
+
+	Check_Type(data, T_STRING);
+	Check_Type(key, T_STRING);
+
+	data_len = RSTRING_LEN(data);
+
+	result = xxtea_encrypt(RSTRING_PTR(data), data_len, RSTRING_PTR(key), &out_len);
+
+	retval = rb_str_new((const char *)result, out_len);
+
+	free(result);
+
+	return retval;
+}
+
+VALUE rb_decrypt(VALUE mod, VALUE data, VALUE key) {
+	unsigned char *result;
+	VALUE retval;
+	size_t data_len, out_len;
+
+	Check_Type(data, T_STRING);
+	Check_Type(key, T_STRING);
+
+	data_len = RSTRING_LEN(data);
+
+	result = xxtea_decrypt(RSTRING_PTR(data), data_len, RSTRING_PTR(key), &out_len);
+
+	retval = rb_str_new((const char *)result, out_len);
+
+	free(result);
+
+	return retval;
+}
+
+#ifdef RSTRING_NOEMBED
+VALUE rb_decrypt_utf8(VALUE mod, VALUE data, VALUE key) {
+	return rb_enc_associate(rb_decrypt(mod, data, key), rb_utf8_encoding());
+}
+#endif
+
+void Init_xxtea() {
+    VALUE XXTEA = rb_define_module("XXTEA");
+    rb_define_singleton_method(XXTEA, "encrypt", rb_encrypt, 2);
+    rb_define_singleton_method(XXTEA, "decrypt", rb_decrypt, 2);
+#ifdef RSTRING_NOEMBED
+	rb_define_singleton_method(XXTEA, "decrypt_utf8", rb_decrypt_utf8, 2);
+#endif
+}

data/ext/xxtea/xxtea.c

@@ -0,0 +1,260 @@
+/**********************************************************\
+|                                                          |
+| xxtea.c                                                  |
+|                                                          |
+| XXTEA encryption algorithm library for C.                |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Authors: Chen fei <cf850118@163.com>                |
+|               Ma Bingyao <mabingyao@gmail.com>           |
+| LastModified: Feb 7, 2016                                |
+|                                                          |
+\**********************************************************/
+
+
+#include "xxtea.h"
+
+#include <string.h>
+#if defined(_MSC_VER) && _MSC_VER < 1600
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int32 uint32_t;
+#else
+#if defined(__FreeBSD__) && __FreeBSD__ < 5
+/* FreeBSD 4 doesn't have stdint.h file */
+#include <inttypes.h>
+#else
+#include <stdint.h>
+#endif
+#endif
+
+#include <sys/types.h> /* This will likely define BYTE_ORDER */
+
+#ifndef BYTE_ORDER
+#if (BSD >= 199103)
+# include <machine/endian.h>
+#else
+#if defined(linux) || defined(__linux__)
+# include <endian.h>
+#else
+#define LITTLE_ENDIAN   1234    /* least-significant byte first (vax, pc) */
+#define BIG_ENDIAN  4321    /* most-significant byte first (IBM, net) */
+#define PDP_ENDIAN  3412    /* LSB first in word, MSW first in long (pdp)*/
+
+#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || \
+   defined(vax) || defined(ns32000) || defined(sun386) || \
+   defined(MIPSEL) || defined(_MIPSEL) || defined(BIT_ZERO_ON_RIGHT) || \
+   defined(__alpha__) || defined(__alpha)
+#define BYTE_ORDER    LITTLE_ENDIAN
+#endif
+
+#if defined(sel) || defined(pyr) || defined(mc68000) || defined(sparc) || \
+    defined(is68k) || defined(tahoe) || defined(ibm032) || defined(ibm370) || \
+    defined(MIPSEB) || defined(_MIPSEB) || defined(_IBMR2) || defined(DGUX) ||\
+    defined(apollo) || defined(__convex__) || defined(_CRAY) || \
+    defined(__hppa) || defined(__hp9000) || \
+    defined(__hp9000s300) || defined(__hp9000s700) || \
+    defined (BIT_ZERO_ON_LEFT) || defined(m68k) || defined(__sparc)
+#define BYTE_ORDER  BIG_ENDIAN
+#endif
+#endif /* linux */
+#endif /* BSD */
+#endif /* BYTE_ORDER */
+
+#ifndef BYTE_ORDER
+#ifdef __BYTE_ORDER
+#if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
+#ifndef LITTLE_ENDIAN
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#endif
+#ifndef BIG_ENDIAN
+#define BIG_ENDIAN __BIG_ENDIAN
+#endif
+#if (__BYTE_ORDER == __LITTLE_ENDIAN)
+#define BYTE_ORDER LITTLE_ENDIAN
+#else
+#define BYTE_ORDER BIG_ENDIAN
+#endif
+#endif
+#endif
+#endif
+
+#define MX (((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4))) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z))
+#define DELTA 0x9e3779b9
+
+#define FIXED_KEY \
+    size_t i;\
+    uint8_t fixed_key[16];\
+    memcpy(fixed_key, key, 16);\
+    for (i = 0; (i < 16) && (fixed_key[i] != 0); ++i);\
+    for (++i; i < 16; ++i) fixed_key[i] = 0;\
+
+
+static uint32_t * xxtea_to_uint_array(const uint8_t * data, size_t len, int inc_len, size_t * out_len) {
+    uint32_t *out;
+#if !(defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN))
+    size_t i;
+#endif
+    size_t n;
+
+    n = (((len & 3) == 0) ? (len >> 2) : ((len >> 2) + 1));
+
+    if (inc_len) {
+        out = (uint32_t *)calloc(n + 1, sizeof(uint32_t));
+        if (!out) return NULL;
+        out[n] = (uint32_t)len;
+        *out_len = n + 1;
+    }
+    else {
+        out = (uint32_t *)calloc(n, sizeof(uint32_t));
+        if (!out) return NULL;
+        *out_len = n;
+    }
+#if defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
+    memcpy(out, data, len);
+#else
+    for (i = 0; i < len; ++i) {
+        out[i >> 2] |= (uint32_t)data[i] << ((i & 3) << 3);
+    }
+#endif
+
+    return out;
+}
+
+static uint8_t * xxtea_to_ubyte_array(const uint32_t * data, size_t len, int inc_len, size_t * out_len) {
+    uint8_t *out;
+#if !(defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN))
+    size_t i;
+#endif
+    size_t m, n;
+
+    n = len << 2;
+
+    if (inc_len) {
+        m = data[len - 1];
+        n -= 4;
+        if ((m < n - 3) || (m > n)) return NULL;
+        n = m;
+    }
+
+    out = (uint8_t *)malloc(n + 1);
+
+#if defined(BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
+    memcpy(out, data, n);
+#else
+    for (i = 0; i < n; ++i) {
+        out[i] = (uint8_t)(data[i >> 2] >> ((i & 3) << 3));
+    }
+#endif
+
+    out[n] = '\0';
+    *out_len = n;
+
+    return out;
+}
+
+static uint32_t * xxtea_uint_encrypt(uint32_t * data, size_t len, uint32_t * key) {
+    uint32_t n = (uint32_t)len - 1;
+    uint32_t z = data[n], y, p, q = 6 + 52 / (n + 1), sum = 0, e;
+
+    if (n < 1) return data;
+
+    while (0 < q--) {
+        sum += DELTA;
+        e = sum >> 2 & 3;
+
+        for (p = 0; p < n; p++) {
+            y = data[p + 1];
+            z = data[p] += MX;
+        }
+
+        y = data[0];
+        z = data[n] += MX;
+    }
+
+    return data;
+}
+
+static uint32_t * xxtea_uint_decrypt(uint32_t * data, size_t len, uint32_t * key) {
+    uint32_t n = (uint32_t)len - 1;
+    uint32_t z, y = data[0], p, q = 6 + 52 / (n + 1), sum = q * DELTA, e;
+
+    if (n < 1) return data;
+
+    while (sum != 0) {
+        e = sum >> 2 & 3;
+
+        for (p = n; p > 0; p--) {
+            z = data[p - 1];
+            y = data[p] -= MX;
+        }
+
+        z = data[n];
+        y = data[0] -= MX;
+        sum -= DELTA;
+    }
+
+    return data;
+}
+
+static uint8_t * xxtea_ubyte_encrypt(const uint8_t * data, size_t len, const uint8_t * key, size_t * out_len) {
+    uint8_t *out;
+    uint32_t *data_array, *key_array;
+    size_t data_len, key_len;
+
+    if (!len) return NULL;
+
+    data_array = xxtea_to_uint_array(data, len, 1, &data_len);
+    if (!data_array) return NULL;
+
+    key_array  = xxtea_to_uint_array(key, 16, 0, &key_len);
+    if (!key_array) {
+        free(data_array);
+        return NULL;
+    }
+
+    out = xxtea_to_ubyte_array(xxtea_uint_encrypt(data_array, data_len, key_array), data_len, 0, out_len);
+
+    free(data_array);
+    free(key_array);
+
+    return out;
+}
+
+static uint8_t * xxtea_ubyte_decrypt(const uint8_t * data, size_t len, const uint8_t * key, size_t * out_len) {
+    uint8_t *out;
+    uint32_t *data_array, *key_array;
+    size_t data_len, key_len;
+
+    if (!len) return NULL;
+
+    data_array = xxtea_to_uint_array(data, len, 0, &data_len);
+    if (!data_array) return NULL;
+
+    key_array  = xxtea_to_uint_array(key, 16, 0, &key_len);
+    if (!key_array) {
+        free(data_array);
+        return NULL;
+    }
+
+    out = xxtea_to_ubyte_array(xxtea_uint_decrypt(data_array, data_len, key_array), data_len, 1, out_len);
+
+    free(data_array);
+    free(key_array);
+
+    return out;
+}
+
+// public functions
+
+void * xxtea_encrypt(const void * data, size_t len, const void * key, size_t * out_len) {
+    FIXED_KEY
+    return xxtea_ubyte_encrypt(data, len, fixed_key, out_len);
+}
+
+void * xxtea_decrypt(const void * data, size_t len, const void * key, size_t * out_len) {
+    FIXED_KEY
+    return xxtea_ubyte_decrypt(data, len, fixed_key, out_len);
+}

data/ext/xxtea/xxtea.h

@@ -0,0 +1,54 @@
+/**********************************************************\
+|                                                          |
+| xxtea.h                                                  |
+|                                                          |
+| XXTEA encryption algorithm library for C.                |
+|                                                          |
+| Encryption Algorithm Authors:                            |
+|      David J. Wheeler                                    |
+|      Roger M. Needham                                    |
+|                                                          |
+| Code Authors: Chen fei <cf850118@163.com>                |
+|               Ma Bingyao <mabingyao@gmail.com>           |
+| LastModified: Mar 3, 2015                                |
+|                                                          |
+\**********************************************************/
+
+#ifndef XXTEA_INCLUDED
+#define XXTEA_INCLUDED
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Function: xxtea_encrypt
+ * @data:    Data to be encrypted
+ * @len:     Length of the data to be encrypted
+ * @key:     Symmetric key
+ * @out_len: Pointer to output length variable
+ * Returns:  Encrypted data or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer.
+ */
+void * xxtea_encrypt(const void * data, size_t len, const void * key, size_t * out_len);
+
+/**
+ * Function: xxtea_decrypt
+ * @data:    Data to be decrypted
+ * @len:     Length of the data to be decrypted
+ * @key:     Symmetric key
+ * @out_len: Pointer to output length variable
+ * Returns:  Decrypted data or %NULL on failure
+ *
+ * Caller is responsible for freeing the returned buffer.
+ */
+void * xxtea_decrypt(const void * data, size_t len, const void * key, size_t * out_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/test/xxtea_test.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require "minitest/autorun"
+require "xxtea"
+
+describe "XXTEA" do
+    it "test xxtea encrypt and decrypt" do
+        text = "Hello World! 你好，中国！"
+        key = "1234567890"
+        encrypt_data = XXTEA.encrypt(text, key)
+        if RUBY_VERSION >= "1.9.0" then
+            decrypt_data = XXTEA.decrypt_utf8(encrypt_data, key)
+            decrypt_data2 = XXTEA.decrypt(encrypt_data, key).force_encoding(Encoding::UTF_8)
+            assert_equal text, decrypt_data
+            assert_equal decrypt_data, decrypt_data2
+        else
+            decrypt_data = XXTEA.decrypt(encrypt_data, key)
+            assert_equal text, decrypt_data
+        end
+    end
+end

data/xxtea-ruby.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name         = 'xxtea-ruby'
+  s.version      = '1.2.0'
+  s.license      = 'MIT'
+  s.author       = 'Ma Bingyao ( andot )'
+  s.email        = 'mabingyao@gmail.com'
+  s.homepage     = 'https://github.com/xxtea/xxtea-ruby'
+  s.platform     = Gem::Platform::RUBY
+  s.description  = <<-EOF
+  XXTEA is a fast and secure encryption algorithm. This is a XXTEA library for Ruby.
+
+  It is different from the original XXTEA encryption algorithm. It encrypts and decrypts raw binary data instead of 32bit integer array, and the key is also the raw binary data.
+EOF
+
+  s.summary      = 'XXTEA is a fast and secure encryption algorithm. This is a XXTEA library for Ruby.'
+  s.files        = `git ls-files`.split($/)
+  s.test_files   = s.files.grep(%r{^test/})
+  s.require_path = 'lib'
+  s.extensions   = ["ext/xxtea/extconf.rb"]
+  end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: xxtea-ruby
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Ma Bingyao ( andot )
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-07 00:00:00.000000000 Z
+dependencies: []
+description: |2
+    XXTEA is a fast and secure encryption algorithm. This is a XXTEA library for Ruby.
+
+    It is different from the original XXTEA encryption algorithm. It encrypts and decrypts raw binary data instead of 32bit integer array, and the key is also the raw binary data.
+email: mabingyao@gmail.com
+executables: []
+extensions:
+- ext/xxtea/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- README_zh_CN.md
+- Rakefile
+- ext/xxtea/extconf.rb
+- ext/xxtea/ruby_xxtea.c
+- ext/xxtea/xxtea.c
+- ext/xxtea/xxtea.h
+- test/xxtea_test.rb
+- xxtea-ruby.gemspec
+homepage: https://github.com/xxtea/xxtea-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: XXTEA is a fast and secure encryption algorithm. This is a XXTEA library
+  for Ruby.
+test_files:
+- test/xxtea_test.rb