cf-ruby-libecp 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 5dcfb0c06bc9cc0ad5dadf35f7b2571a5edc24c4
-  data.tar.gz: 74386da86512de41b0e8495645f752e7a0911c8a
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmU3Y2MyZGM1OTk2MDJmYWY3MzA3MTg1YzM3ODliMjg3OTE3MjQxYg==
+  data.tar.gz: !binary |-
+    N2U5NTU1NzQyMDI4NmJiMDc0ODhmYTc5MmU2NWYyNDhlMTg2ZTBmNA==
 SHA512:
-  metadata.gz: 5d669aa4b09bcb31e1842e04e1c1bf41784a1b08a86e92c53ff75e8238548d1c9b2300cbba91e5bbe53bd31f7117536c2fd19d14edeb084c0b78360d0942ae69
-  data.tar.gz: 49bfb6006923c877b2cffb459ca692ed9b1acdc05f61af11bdbc7ce36e94c14dc637c04cebb7082b1986c46eeedd3ae214e5c8620f074664bee9d4f6b02e1211
+  metadata.gz: !binary |-
+    NjUxZDRjNmQwZjE5NjJiMzM4ZDk1ZTMzM2Q5ZDExMTEyMTMyOWNhNTVhYWM2
+    NjFkNDJmYmU1YWNhOTE4NjJlMWIzMTUwNTRiNjk3MWRjMzJmYWYwNDk5NjM0
+    MGE3Nzk4MmE1NDY0OWU5ZDhjNDczMzc3YTIyMDEzNjE4MjhlNDQ=
+  data.tar.gz: !binary |-
+    MjJkZmE5ZWNjYjA5ZDk3MjU1YjRkMWM1ODllNzUwNzQ2NzgxOWYyZWQ4Y2I3
+    YzI0YzQwMDU1NTY1ZWI4OGMzM2MxN2ViNWNkZTUwOTg4NGY3ZDgxZTBkM2Vi
+    MzAzZWZiNmNlZmEzZGQyODU4MWI5Nzc0ZTkyOWIwMjU4ZDc3NWI=

data/.gitignore

@@ -0,0 +1 @@
+/lib/libecp.so

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/libecp"]
+	path = ext/libecp
+	url = https://github.com/coinfloor/libecp.git

data/LICENCE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/Makefile

@@ -0,0 +1,18 @@
+OS := $(shell uname -s)
+
+lib/libecp.so : ext/libecp/libecp.so
+ifeq ($(OS),Darwin)
+	install $< $@
+else
+	install -sT $< $@
+endif
+
+ext/libecp/libecp.so ::
+	$(MAKE) -C ext/libecp libecp.so
+
+.PHONY : install clean
+
+install : lib/libecp.so
+
+clean :
+	$(MAKE) -C ext/libecp clean

data/README.md

@@ -0,0 +1,46 @@
+# Ruby LibECP
+
+Ruby LibECP is a wrapper around LibECP, an elliptic-curve cryptography library
+for producing and verifying ECDSA signatures.
+
+
+## Installation
+
+Use the gem in a project managed with Bundler adding it into Gemfile:
+
+    gem "cf-ruby-libecp"
+
+### Build
+
+This gem is a native extension gem. The native library will be compiled on your
+platform automatically at install time.
+
+The required packages to build the gem are:
+
+- GMP, a multiprecision arithmetic library.
+- GCC, a compiler for C, C++, Java, Fortan and other program code that can be
+used in Unix.
+
+#### Debian-based distributions
+
+    $ sudo apt-get install libgmp3-dev build-essential
+
+#### OS X with Homebrew
+
+    $ brew install gmp
+
+#### OS X with MacPorts
+
+    $ sudo port install gmp
+
+
+## Usage example
+
+    require "libecp"
+
+    LibEcp.private_key(LibEcp.gen_uid(1234), "coinfloor")
+
+
+## Licence
+
+Released under the Apache License Version 2.0.

data/ext/libecp/.gitignore

@@ -0,0 +1,2 @@
+*.o
+/libecp.so

data/ext/libecp/Makefile

@@ -0,0 +1,31 @@
+OS := $(shell uname -s)
+
+CPPFLAGS := -std=c99 $(CPPFLAGS)
+CFLAGS := -O3 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -Wno-parentheses $(CFLAGS)
+LDLIBS += -lgmp
+ifeq ($(OS),Linux)
+LDFLAGS := -Wl,-O1,--gc-sections $(LDFLAGS)
+else
+ifeq ($(OS),Darwin)
+CPPFLAGS += -I/opt/local/include
+LDFLAGS := -Wl,-dead_strip $(LDFLAGS) -L/opt/local/lib
+endif
+endif
+
+.PHONY : all clean
+
+all : libecp.so
+
+clean :
+	rm -f *.o libecp.so
+
+
+ecp.o : ecp.c ecp.h
+
+libecp.o : libecp.c libecp.h ecp.h
+
+libecp.so : libecp.o ecp.o
+
+
+%.so : %.o
+	$(LINK.o) -shared $^ $(LOADLIBES) $(LDLIBS) -o $@

data/ext/libecp/README.md

@@ -0,0 +1,30 @@
+## Licence
+```
+Copyright 2014-2015 Coinfloor LTD.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+## Prerequisites
+
+```
+$ sudo apt-get install build-essential libgmp3-dev
+```
+
+## libecp
+
+### Build
+
+```
+$ make libecp.so
+```

data/ext/libecp/ecp.c

@@ -0,0 +1,480 @@
+/*
+Copyright 2014-2015 Coinfloor LTD.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "ecp.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+#include <signal.h>
+
+#if __GNU_MP__ < 5
+#include <string.h>
+static inline void mpn_copyi(mp_limb_t *rp, const mp_limb_t *s1p, mp_size_t n) {
+	memcpy(rp, s1p, n * sizeof(mp_limb_t));
+}
+static inline void mpn_zero(mp_limb_t *rp, mp_size_t n) {
+	memset(rp, 0, n * sizeof(mp_limb_t));
+}
+#endif
+
+const mp_limb_t secp224k1_p[MP_NLIMBS(29)] = {
+	MP_LIMB_C(0xFFFFE56D, 0xFFFFFFFE), MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF),
+	MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF), MP_LIMB_C(0xFFFFFFFF, 0x00)
+};
+const mp_limb_t secp224k1_a[MP_NLIMBS(29)] = {
+	MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000),
+	MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00)
+};
+const mp_limb_t secp224k1_G[3][MP_NLIMBS(29)] = {
+	{
+		MP_LIMB_C(0xB6B7A45C, 0x0F7E650E), MP_LIMB_C(0xE47075A9, 0x69A467E9),
+		MP_LIMB_C(0x30FC28A1, 0x4DF099DF), MP_LIMB_C(0xA1455B33, 0x00)
+	},
+	{
+		MP_LIMB_C(0x556D61A5, 0xE2CA4BDB), MP_LIMB_C(0xC0B0BD59, 0xF7E319F7),
+		MP_LIMB_C(0x82CAFBD6, 0x7FBA3442), MP_LIMB_C(0x7E089FED, 0x00)
+	},
+	{
+		MP_LIMB_C(0x00000001, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000),
+		MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00)
+	}
+};
+const mp_limb_t secp224k1_n[MP_NLIMBS(29)] = {
+	MP_LIMB_C(0x769FB1F7, 0xCAF0A971), MP_LIMB_C(0xD2EC6184, 0x0001DCE8),
+	MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x01)
+};
+
+const mp_limb_t secp256k1_p[MP_NLIMBS(32)] = {
+	MP_LIMB_C(0xFFFFFC2F, 0xFFFFFFFE), MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF),
+	MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF), MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF)
+};
+const mp_limb_t secp256k1_a[MP_NLIMBS(32)] = {
+	MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000),
+	MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000)
+};
+const mp_limb_t secp256k1_G[3][MP_NLIMBS(32)] = {
+	{
+		MP_LIMB_C(0x16F81798, 0x59F2815B), MP_LIMB_C(0x2DCE28D9, 0x029BFCDB),
+		MP_LIMB_C(0xCE870B07, 0x55A06295), MP_LIMB_C(0xF9DCBBAC, 0x79BE667E)
+	},
+	{
+		MP_LIMB_C(0xFB10D4B8, 0x9C47D08F), MP_LIMB_C(0xA6855419, 0xFD17B448),
+		MP_LIMB_C(0x0E1108A8, 0x5DA4FBFC), MP_LIMB_C(0x26A3C465, 0x483ADA77)
+	},
+	{
+		MP_LIMB_C(0x00000001, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000),
+		MP_LIMB_C(0x00000000, 0x00000000), MP_LIMB_C(0x00000000, 0x00000000)
+	}
+};
+const mp_limb_t secp256k1_n[MP_NLIMBS(32)] = {
+	MP_LIMB_C(0xD0364141, 0xBFD25E8C), MP_LIMB_C(0xAF48A03B, 0xBAAEDCE6),
+	MP_LIMB_C(0xFFFFFFFE, 0xFFFFFFFF), MP_LIMB_C(0xFFFFFFFF, 0xFFFFFFFF)
+};
+
+static inline bool mpn_zero_p(const mp_limb_t n[], size_t l) {
+	for (size_t i = 0; i < l; ++i) {
+		if (n[i] != 0) {
+			return false;
+		}
+	}
+	return true;
+}
+
+static inline bool mpn_one_p(const mp_limb_t n[], size_t l) {
+	return l > 0 && n[0] == 1 && mpn_zero_p(n + 1, l - 1);
+}
+
+static inline bool mpn_even_p(const mp_limb_t n[], size_t l) {
+	return l == 0 || (n[0] & 1) == 0;
+}
+
+void bytes_to_mpn(mp_limb_t mpn[], const uint8_t bytes[], size_t n) {
+	if (n == 0) {
+		return;
+	}
+	while (n > sizeof(mp_limb_t)) {
+		mp_limb_t limb = 0;
+#if GMP_LIMB_BITS >= 64
+		limb |= (mp_limb_t) (bytes[n - 8]) << 56;
+		limb |= (mp_limb_t) (bytes[n - 7]) << 48;
+		limb |= (mp_limb_t) (bytes[n - 6]) << 40;
+		limb |= (mp_limb_t) (bytes[n - 5]) << 32;
+#endif
+#if GMP_LIMB_BITS >= 32
+		limb |= (mp_limb_t) (bytes[n - 4]) << 24;
+		limb |= (mp_limb_t) (bytes[n - 3]) << 16;
+		limb |= (mp_limb_t) (bytes[n - 2]) << 8;
+		limb |= (mp_limb_t) (bytes[n - 1]);
+#endif
+		*mpn++ = limb;
+		n -= sizeof(mp_limb_t);
+	}
+	mp_limb_t limb = 0;
+	switch (n) {
+#if GMP_LIMB_BITS >= 64
+		case 8:
+			limb |= (mp_limb_t) (bytes[n - 8]) << 56;
+		case 7:
+			limb |= (mp_limb_t) (bytes[n - 7]) << 48;
+		case 6:
+			limb |= (mp_limb_t) (bytes[n - 6]) << 40;
+		case 5:
+			limb |= (mp_limb_t) (bytes[n - 5]) << 32;
+#endif
+#if GMP_LIMB_BITS >= 32
+		case 4:
+			limb |= (mp_limb_t) (bytes[n - 4]) << 24;
+		case 3:
+			limb |= (mp_limb_t) (bytes[n - 3]) << 16;
+		case 2:
+			limb |= (mp_limb_t) (bytes[n - 2]) << 8;
+		case 1:
+			limb |= (mp_limb_t) (bytes[n - 1]);
+#endif
+	}
+	*mpn = limb;
+}
+
+void mpn_to_bytes(uint8_t bytes[], const mp_limb_t mpn[], size_t n) {
+	if (n == 0) {
+		return;
+	}
+	while (n > sizeof(mp_limb_t)) {
+		mp_limb_t limb = *mpn++;
+#if GMP_LIMB_BITS >= 64
+		bytes[n - 8] = (uint8_t) (limb >> 56);
+		bytes[n - 7] = (uint8_t) (limb >> 48);
+		bytes[n - 6] = (uint8_t) (limb >> 40);
+		bytes[n - 5] = (uint8_t) (limb >> 32);
+#endif
+#if GMP_LIMB_BITS >= 32
+		bytes[n - 4] = (uint8_t) (limb >> 24);
+		bytes[n - 3] = (uint8_t) (limb >> 16);
+		bytes[n - 2] = (uint8_t) (limb >> 8);
+		bytes[n - 1] = (uint8_t) (limb);
+#endif
+		n -= sizeof(mp_limb_t);
+	}
+	mp_limb_t limb = *mpn;
+	switch (n) {
+#if GMP_LIMB_BITS >= 64
+		case 8:
+			bytes[n - 8] = (uint8_t) (limb >> 56);
+		case 7:
+			bytes[n - 7] = (uint8_t) (limb >> 48);
+		case 6:
+			bytes[n - 6] = (uint8_t) (limb >> 40);
+		case 5:
+			bytes[n - 5] = (uint8_t) (limb >> 32);
+#endif
+#if GMP_LIMB_BITS >= 32
+		case 4:
+			bytes[n - 4] = (uint8_t) (limb >> 24);
+		case 3:
+			bytes[n - 3] = (uint8_t) (limb >> 16);
+		case 2:
+			bytes[n - 2] = (uint8_t) (limb >> 8);
+		case 1:
+			bytes[n - 1] = (uint8_t) (limb);
+#endif
+	}
+}
+
+static mp_limb_t * fp_add(mp_limb_t r[], const mp_limb_t n1[], const mp_limb_t n2[], const mp_limb_t p[], size_t l) {
+	if (mpn_add_n(r, n1, n2, l) || mpn_cmp(r, p, l) >= 0) {
+		mpn_sub_n(r, r, p, l);
+	}
+	return r;
+}
+
+static mp_limb_t * fp_sub(mp_limb_t r[], const mp_limb_t n1[], const mp_limb_t n2[], const mp_limb_t p[], size_t l) {
+	if (mpn_sub_n(r, n1, n2, l)) {
+		mpn_add_n(r, r, p, l);
+	}
+	return r;
+}
+
+static mp_limb_t * fp_dbl(mp_limb_t r[], const mp_limb_t n[], const mp_limb_t p[], size_t l) {
+	if (mpn_lshift(r, n, l, 1) || mpn_cmp(r, p, l) >= 0) {
+		mpn_sub_n(r, r, p, l);
+	}
+	return r;
+}
+
+static mp_limb_t * fp_mul(mp_limb_t r[], const mp_limb_t n1[], const mp_limb_t n2[], const mp_limb_t p[], size_t l) {
+	mpn_zero(r, l);
+	bool active = false;
+	for (size_t i = l; i > 0;) {
+		mp_limb_t w = n2[--i];
+		for (size_t j = sizeof(mp_limb_t) * 8; j > 0; --j) {
+			if (active) {
+				fp_dbl(r, r, p, l);
+			}
+			if ((mp_limb_signed_t) (w) < 0) {
+				fp_add(r, r, n1, p, l);
+				active = true;
+			}
+			w <<= 1;
+		}
+	}
+	return r;
+}
+
+static mp_limb_t * fp_sqr(mp_limb_t r[], const mp_limb_t n[], const mp_limb_t p[], size_t l) {
+	return fp_mul(r, n, n, p, l);
+}
+
+static mp_limb_t * fp_inv(mp_limb_t r[], const mp_limb_t n[], const mp_limb_t p[], size_t l) {
+	if (mpn_zero_p(n, l)) {
+		raise(SIGFPE);
+	}
+	mp_limb_t u[l], v[l], s[l];
+	mpn_copyi(u, n, l), mpn_copyi(v, p, l);
+	mpn_zero(r, l), mpn_zero(s, l);
+	r[0] = 1;
+	for (;;) {
+		if (mpn_one_p(u, l)) {
+			return r;
+		}
+		if (mpn_one_p(v, l)) {
+			mpn_copyi(r, s, l);
+			return r;
+		}
+		while (mpn_even_p(u, l)) {
+			mpn_rshift(u, u, l, 1);
+			if (mpn_even_p(r, l)) {
+				mpn_rshift(r, r, l, 1);
+			}
+			else {
+				mp_limb_t c = mpn_add_n(r, r, p, l) << sizeof(mp_limb_t) * 8 - 1;
+				mpn_rshift(r, r, l, 1);
+				r[l - 1] |= c;
+			}
+		}
+		while (mpn_even_p(v, l)) {
+			mpn_rshift(v, v, l, 1);
+			if (mpn_even_p(s, l)) {
+				mpn_rshift(s, s, l, 1);
+			}
+			else {
+				mp_limb_t c = mpn_add_n(s, s, p, l) << sizeof(mp_limb_t) * 8 - 1;
+				mpn_rshift(s, s, l, 1);
+				s[l - 1] |= c;
+			}
+		}
+		if (mpn_cmp(u, v, l) >= 0) {
+			mpn_sub_n(u, u, v, l);
+			fp_sub(r, r, s, p, l);
+		}
+		else {
+			mpn_sub_n(v, v, u, l);
+			fp_sub(s, s, r, p, l);
+		}
+	}
+}
+
+static inline mp_limb_t * ecp_copy(mp_limb_t R[], const mp_limb_t N[], size_t l) {
+	mpn_copyi(&R[0], &N[0], l), mpn_copyi(&R[l], &N[l], l), mpn_copyi(&R[l * 2], &N[l * 2], l);
+	return R;
+}
+
+static mp_limb_t * ecp_dbl(mp_limb_t R[], const mp_limb_t N[], const mp_limb_t a[], const mp_limb_t p[], size_t l) {
+	const mp_limb_t *x = &N[0], *y = &N[l], *z = &N[l * 2];
+	mp_limb_t *xr = &R[0], *yr = &R[l], *zr = &R[l * 2];
+	if (mpn_zero_p(z, l)) {
+		mpn_zero(xr, l), mpn_zero(yr, l), mpn_zero(zr, l);
+		return R;
+	}
+	mp_limb_t t0[l], t1[l], t2[l], t3[l];
+	fp_add(t0, t0, fp_dbl(t1, fp_sqr(t0, x, p, l), p, l), p, l);
+	if (!mpn_zero_p(a, l)) {
+		fp_add(t0, t0, fp_mul(t1, a, fp_sqr(t2, fp_sqr(t1, z, p, l), p, l), p, l), p, l);
+	}
+	fp_dbl(t1, fp_sqr(t1, y, p, l), p, l);
+	fp_dbl(t2, fp_mul(t2, x, t1, p, l), p, l);
+	fp_dbl(t3, fp_sqr(t3, t1, p, l), p, l);
+	fp_sub(xr, fp_sqr(xr, t0, p, l), fp_dbl(t1, t2, p, l), p, l);
+	fp_sub(yr, fp_mul(yr, t0, fp_sub(t1, t2, xr, p, l), p, l), t3, p, l);
+	fp_dbl(zr, fp_mul(zr, y, z, p, l), p, l);
+	return R;
+}
+
+static mp_limb_t * ecp_add_aff(mp_limb_t R[], const mp_limb_t N1[], const mp_limb_t N2[], const mp_limb_t a[], const mp_limb_t p[], size_t l) {
+	const mp_limb_t *x1 = &N1[0], *y1 = &N1[l], *z1 = &N1[l * 2], *x2 = &N2[0], *y2 = &N2[l];
+	assert(mpn_one_p(&N2[l * 2], l));
+	mp_limb_t *xr = &R[0], *yr = &R[l], *zr = &R[l * 2];
+	mp_limb_t t0[l], t1[l], t2[l], t3[l], t4[l];
+	fp_sqr(t0, z1, p, l);
+	fp_mul(t1, x2, t0, p, l);
+	fp_mul(t2, z1, t0, p, l);
+	fp_mul(t0, y2, t2, p, l);
+	if (mpn_cmp(t1, x1, l) == 0) {
+		if (mpn_cmp(t0, y1, l) == 0) {
+			return ecp_dbl(R, N1, a, p, l);
+		}
+		mpn_zero(xr, l), mpn_zero(yr, l), mpn_zero(zr, l);
+		xr[0] = yr[0] = 1;
+		return R;
+	}
+	fp_sub(t2, t1, x1, p, l);
+	fp_sub(t1, t0, y1, p, l);
+	fp_sqr(t0, t2, p, l);
+	fp_mul(t3, t0, t2, p, l);
+	fp_mul(t4, x1, t0, p, l);
+	fp_sub(xr, fp_sub(xr, fp_sqr(xr, t1, p, l), t3, p, l), fp_dbl(t0, t4, p, l), p, l);
+	fp_sub(yr, fp_mul(yr, t1, fp_sub(t4, t4, xr, p, l), p, l), fp_mul(t0, y1, t3, p, l), p, l);
+	fp_mul(zr, z1, t2, p, l);
+	return R;
+}
+
+static mp_limb_t * ecp_add(mp_limb_t R[], const mp_limb_t N1[], const mp_limb_t N2[], const mp_limb_t a[], const mp_limb_t p[], size_t l) {
+	const mp_limb_t *x1 = &N1[0], *y1 = &N1[l], *z1 = &N1[l * 2], *x2 = &N2[0], *y2 = &N2[l], *z2 = &N2[l * 2];
+	mp_limb_t *xr = &R[0], *yr = &R[l], *zr = &R[l * 2];
+	if (mpn_zero_p(z1, l)) {
+		if (mpn_zero_p(z2, l)) {
+			mpn_zero(xr, l), mpn_zero(yr, l), mpn_zero(zr, l);
+			return R;
+		}
+		return ecp_copy(R, N2, l);
+	}
+	if (mpn_zero_p(z2, l)) {
+		return ecp_copy(R, N1, l);
+	}
+	if (mpn_one_p(z2, l)) {
+		return ecp_add_aff(R, N1, N2, a, p, l);
+	}
+	mp_limb_t t0[l], t1[l], t2[l], t3[l], t4[l], t5[l], t6[l];
+	fp_sqr(t0, z1, p, l);
+	fp_mul(t1, x2, t0, p, l);
+	fp_mul(t2, z1, t0, p, l);
+	fp_mul(t0, y2, t2, p, l);
+	fp_sqr(t2, z2, p, l);
+	fp_mul(t3, x1, t2, p, l);
+	fp_mul(t4, z2, t2, p, l);
+	fp_mul(t2, y1, t4, p, l);
+	if (mpn_cmp(t3, t1, l) == 0) {
+		if (mpn_cmp(t2, t0, l) == 0) {
+			return ecp_dbl(R, N1, a, p, l);
+		}
+		mpn_zero(xr, l), mpn_zero(yr, l), mpn_zero(zr, l);
+		xr[0] = yr[0] = 1;
+		return R;
+	}
+	fp_sub(t4, t1, t3, p, l);
+	fp_sub(t1, t0, t2, p, l);
+	fp_sqr(t0, t4, p, l);
+	fp_mul(t5, t4, t0, p, l);
+	fp_mul(t6, t3, t0, p, l);
+	fp_sub(xr, fp_sub(xr, fp_sqr(xr, t1, p, l), t5, p, l), fp_dbl(t0, t6, p, l), p, l);
+	fp_sub(yr, fp_mul(yr, t1, fp_sub(t6, t6, xr, p, l), p, l), fp_mul(t0, t2, t5, p, l), p, l);
+	fp_mul(zr, t4, fp_mul(t0, z1, z2, p, l), p, l);
+	return R;
+}
+
+static mp_limb_t * ecp_mul_(mp_limb_t R[], const mp_limb_t n1[], const mp_limb_t N2[], const mp_limb_t a[], const mp_limb_t p[], size_t l, mp_limb_t * (*add)(mp_limb_t [], const mp_limb_t [], const mp_limb_t [], const mp_limb_t [], const mp_limb_t [], size_t)) {
+	bool active = false;
+	size_t swaps = 0;
+	mp_limb_t Ss[l * 3], *S = Ss, *T;
+	for (size_t i = l; i > 0;) {
+		mp_limb_t w = n1[--i];
+		for (size_t j = sizeof(mp_limb_t) * 8; j > 0; --j) {
+			if (active) {
+				ecp_dbl(S, R, a, p, l);
+				T = S, S = R, R = T, ++swaps;
+			}
+			if ((mp_limb_signed_t) (w) < 0) {
+				if (active) {
+					(*add)(S, R, N2, a, p, l);
+					T = S, S = R, R = T, ++swaps;
+				}
+				else {
+					ecp_copy(R, N2, l);
+					active = true;
+				}
+			}
+			w <<= 1;
+		}
+	}
+	if (swaps & 1) {
+		return ecp_copy(S, R, l);
+	}
+	return R;
+}
+
+static mp_limb_t * ecp_mul(mp_limb_t R[], const mp_limb_t n1[], const mp_limb_t N2[], const mp_limb_t a[], const mp_limb_t p[], size_t l) {
+	return ecp_mul_(R, n1, N2, a, p, l, mpn_one_p(&N2[l * 2], l) ? &ecp_add_aff : (mp_limb_t * (*)(mp_limb_t [], const mp_limb_t [], const mp_limb_t [], const mp_limb_t [], const mp_limb_t [], size_t)) &ecp_add);
+}
+
+static mp_limb_t * ecp_proj(mp_limb_t R[], const mp_limb_t N[], const mp_limb_t p[], size_t l) {
+	const mp_limb_t *x = &N[0], *y = &N[l], *z = &N[l * 2];
+	mp_limb_t *xr = &R[0], *yr = &R[l], *zr = &R[l * 2];
+	mp_limb_t t0[l], t1[l], t2[l];
+	fp_mul(t2, t0, fp_sqr(t1, fp_inv(t0, z, p, l), p, l), p, l);
+	fp_mul(xr, x, t1, p, l);
+	fp_mul(yr, y, t2, p, l);
+	mpn_zero(zr, l), zr[0] = 1;
+	return R;
+}
+
+void ecp_pubkey(mp_limb_t Q[], const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t d[], size_t l) {
+	mp_limb_t R[3][l];
+	ecp_proj(Q, ecp_mul(*R, d, G, a, p, l), p, l);
+}
+
+void ecp_sign(mp_limb_t r[], mp_limb_t s[], const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t n[], const mp_limb_t d[], const mp_limb_t z[], size_t l) {
+	FILE *random = fopen("/dev/urandom", "r");
+	for (;;) {
+		mp_limb_t k[l];
+		for (size_t r = l; r > 0;) {
+			r -= fread(&k[l - r], sizeof(mp_limb_t), r, random);
+		}
+		mp_limb_t R[3][l], S[3][l];
+		ecp_proj(*R, ecp_mul(*S, k, G, a, p, l), p, l);
+		if (mpn_cmp(R[0], n, l) >= 0) {
+			mpn_sub_n(R[0], R[0], n, l);
+		}
+		if (!mpn_zero_p(R[0], l)) {
+			mp_limb_t t0[l], t1[l];
+			fp_mul(s, fp_inv(t0, k, n, l), fp_add(t1, z, fp_mul(t1, R[0], d, n, l), n, l), n, l);
+			if (!mpn_zero_p(s, l)) {
+				mpn_copyi(r, R[0], l);
+				break;
+			}
+		}
+	}
+	fclose(random);
+}
+
+bool ecp_verify(const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t n[], const mp_limb_t Q[], const mp_limb_t z[], const mp_limb_t r[], const mp_limb_t s[], size_t l) {
+	if (mpn_zero_p(r, l) || mpn_zero_p(s, l) || mpn_cmp(r, n, l) >= 0 || mpn_cmp(s, n, l) >= 0) {
+		return false;
+	}
+	mp_limb_t w[l];
+	fp_inv(w, s, n, l);
+	mp_limb_t u1[l], u2[l];
+	fp_mul(u1, z, w, n, l), fp_mul(u2, r, w, n, l);
+	mp_limb_t Rp[3][l], T0[3][l], T1[3][l], T2[3][l];
+	ecp_add(*T2, ecp_mul(*T0, u1, G, a, p, l), ecp_mul(*T1, u2, Q, a, p, l), a, p, l);
+	if (mpn_zero_p(T2[2], l)) {
+		return false;
+	}
+	ecp_proj(*Rp, *T2, p, l);
+	if (mpn_cmp(Rp[0], n, l) >= 0) {
+		mpn_sub_n(Rp[0], Rp[0], n, l);
+	}
+	return mpn_cmp(Rp[0], r, l) == 0;
+}

data/ext/libecp/ecp.h

@@ -0,0 +1,47 @@
+/*
+Copyright 2014-2015 Coinfloor LTD.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <gmp.h>
+
+#if GMP_LIMB_BITS == 64
+#define MP_LIMB_C(lo, hi) (UINT64_C(lo) | UINT64_C(hi) << 32)
+#elif GMP_LIMB_BITS == 32
+#define MP_LIMB_C(lo, hi) UINT32_C(lo), UINT32_C(hi)
+#else
+#error "unsupported limb size"
+#endif
+
+#define MP_NLIMBS(n) (((n) + sizeof(mp_limb_t) - 1) / sizeof(mp_limb_t))
+
+
+extern const mp_limb_t secp224k1_p[MP_NLIMBS(29)], secp224k1_a[MP_NLIMBS(29)], secp224k1_G[3][MP_NLIMBS(29)], secp224k1_n[MP_NLIMBS(29)];
+
+extern const mp_limb_t secp256k1_p[MP_NLIMBS(32)], secp256k1_a[MP_NLIMBS(32)], secp256k1_G[3][MP_NLIMBS(32)], secp256k1_n[MP_NLIMBS(32)];
+
+
+void bytes_to_mpn(mp_limb_t mpn[], const uint8_t bytes[], size_t n);
+
+void mpn_to_bytes(uint8_t bytes[], const mp_limb_t mpn[], size_t n);
+
+void ecp_pubkey(mp_limb_t Q[], const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t d[], size_t l);
+
+void ecp_sign(mp_limb_t r[], mp_limb_t s[], const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t n[], const mp_limb_t d[], const mp_limb_t z[], size_t l);
+
+bool ecp_verify(const mp_limb_t p[], const mp_limb_t a[], const mp_limb_t G[], const mp_limb_t n[], const mp_limb_t Q[], const mp_limb_t z[], const mp_limb_t r[], const mp_limb_t s[], size_t l);

data/ext/libecp/libecp.c

@@ -0,0 +1,61 @@
+/*
+Copyright 2014-2015 Coinfloor LTD.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include "libecp.h"
+
+#include "ecp.h"
+
+#pragma GCC visibility push(default)
+
+void ecp_pubkey_u8(uint8_t Q[], const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t d[], size_t l) {
+	mp_limb_t p_[MP_NLIMBS(l)], a_[MP_NLIMBS(l)], G_[3][MP_NLIMBS(l)], d_[MP_NLIMBS(l)];
+	bytes_to_mpn(p_, p, l);
+	bytes_to_mpn(a_, a, l);
+	bytes_to_mpn(G_[0], &G[0], l), bytes_to_mpn(G_[1], &G[l], l), bytes_to_mpn(G_[2], &G[l * 2], l);
+	bytes_to_mpn(d_, d, l);
+	mp_limb_t Q_[3][MP_NLIMBS(l)];
+	ecp_pubkey(*Q_, p_, a_, *G_, d_, MP_NLIMBS(l));
+	mpn_to_bytes(&Q[0], Q_[0], l), mpn_to_bytes(&Q[l], Q_[1], l), mpn_to_bytes(&Q[l * 2], Q_[2], l);
+}
+
+void ecp_sign_u8(uint8_t r[], uint8_t s[], const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t n[], const uint8_t d[], const uint8_t z[], size_t l) {
+	mp_limb_t p_[MP_NLIMBS(l)], a_[MP_NLIMBS(l)], G_[3][MP_NLIMBS(l)], n_[MP_NLIMBS(l)], d_[MP_NLIMBS(l)], z_[MP_NLIMBS(l)];
+	bytes_to_mpn(p_, p, l);
+	bytes_to_mpn(a_, a, l);
+	bytes_to_mpn(G_[0], &G[0], l), bytes_to_mpn(G_[1], &G[l], l), bytes_to_mpn(G_[2], &G[l * 2], l);
+	bytes_to_mpn(n_, n, l);
+	bytes_to_mpn(d_, d, l);
+	bytes_to_mpn(z_, z, l);
+	mp_limb_t r_[MP_NLIMBS(l)], s_[MP_NLIMBS(l)];
+	ecp_sign(r_, s_, p_, a_, *G_, n_, d_, z_, MP_NLIMBS(l));
+	mpn_to_bytes(r, r_, l);
+	mpn_to_bytes(s, s_, l);
+}
+
+bool ecp_verify_u8(const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t n[], const uint8_t Q[], const uint8_t z[], const uint8_t r[], const uint8_t s[], size_t l) {
+	mp_limb_t p_[MP_NLIMBS(l)], a_[MP_NLIMBS(l)], G_[3][MP_NLIMBS(l)], n_[MP_NLIMBS(l)], Q_[3][MP_NLIMBS(l)], z_[MP_NLIMBS(l)], r_[MP_NLIMBS(l)], s_[MP_NLIMBS(l)];
+	bytes_to_mpn(p_, p, l);
+	bytes_to_mpn(a_, a, l);
+	bytes_to_mpn(G_[0], &G[0], l), bytes_to_mpn(G_[1], &G[l], l), bytes_to_mpn(G_[2], &G[l * 2], l);
+	bytes_to_mpn(n_, n, l);
+	bytes_to_mpn(Q_[0], &Q[0], l), bytes_to_mpn(Q_[1], &Q[l], l), bytes_to_mpn(Q_[2], &Q[l * 2], l);
+	bytes_to_mpn(z_, z, l);
+	bytes_to_mpn(r_, r, l);
+	bytes_to_mpn(s_, s, l);
+	return ecp_verify(p_, a_, *G_, n_, *Q_, z_, r_, s_, MP_NLIMBS(l));
+}
+
+#pragma GCC visibility pop

data/ext/libecp/libecp.h

@@ -0,0 +1,33 @@
+/*
+Copyright 2014-2015 Coinfloor LTD.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void ecp_pubkey_u8(uint8_t Q[], const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t d[], size_t l);
+
+void ecp_sign_u8(uint8_t r[], uint8_t s[], const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t n[], const uint8_t d[], const uint8_t z[], size_t l);
+
+bool ecp_verify_u8(const uint8_t p[], const uint8_t a[], const uint8_t G[], const uint8_t n[], const uint8_t Q[], const uint8_t z[], const uint8_t r[], const uint8_t s[], size_t l);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif

data/lib/libecp.rb

@@ -15,7 +15,7 @@ module LibEcp
   attach_function :ecp_sign_u8, [:pointer, :pointer, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :size_t], :void
   attach_function :ecp_verify_u8, [:buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :buffer_in, :size_t], :bool
 
-  # Get the byte string of a, g, p and n
+  # Get the byte string of a, G, p and n
   p = "\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE\xFF\xFF\xE5m".force_encoding("ASCII-8BIT")
   a = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".force_encoding("ASCII-8BIT")
   g = "\x00\xA1E[3M\xF0\x99\xDF0\xFC(\xA1i\xA4g\xE9\xE4pu\xA9\x0F~e\x0E\xB6\xB7\xA4\\\x00~\b\x9F\xED\x7F\xBA4B\x82\xCA\xFB\xD6\xF7\xE3\x19\xF7\xC0\xB0\xBDY\xE2\xCAK\xDBUma\xA5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01".force_encoding("ASCII-8BIT")

data/libecp.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name        = "cf-ruby-libecp"
+  s.version     = "0.2.0"
+  s.summary     = "Ruby LibECP Wrapper"
+  s.description = "Ruby LibECP is a wrapper around LibECP, an elliptic-curve cryptography library for producing and verifying ECDSA signatures."
+  s.email       = "development@coinfloor.co.uk"
+  s.authors     = ["Coinfloor LTD"]
+  s.homepage    = "https://github.com/coinfloor/ruby-libecp"
+  s.license     = "Apache License Version 2.0"
+
+  s.require_paths = %w(lib)
+  s.files         = `git ls-files`.split("\n") +
+                    `git submodule --quiet update --init ; cd ext/libecp ; git ls-files`.split("\n").map { |f| "ext/libecp/" + f }
+  s.extensions   << "configure"
+
+  s.add_dependency "ffi",  "~> 1.9", ">= 1.9.3"
+
+  s.required_ruby_version = ">= 1.9.3"
+end

metadata

@@ -1,43 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: cf-ruby-libecp
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Coinfloor LTD
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-19 00:00:00.000000000 Z
+date: 2015-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.9'
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.9.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.9'
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.9.3
-description: LibECP is a C++ elliptic curve cryptography library for signing, verifying
-  signatures and generating keys.
+description: Ruby LibECP is a wrapper around LibECP, an elliptic-curve cryptography
+  library for producing and verifying ECDSA signatures.
 email: development@coinfloor.co.uk
 executables: []
-extensions: []
+extensions:
+- configure
 extra_rdoc_files: []
 files:
+- .gitignore
+- .gitmodules
+- LICENCE
+- Makefile
+- README.md
+- configure
+- ext/libecp/.gitignore
+- ext/libecp/Makefile
+- ext/libecp/README.md
+- ext/libecp/ecp.c
+- ext/libecp/ecp.h
+- ext/libecp/libecp.c
+- ext/libecp/libecp.h
 - lib/libecp.rb
+- libecp.gemspec
 homepage: https://github.com/coinfloor/ruby-libecp
 licenses:
 - Apache License Version 2.0
@@ -48,18 +63,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Ruby LibECP wrapper
+summary: Ruby LibECP Wrapper
 test_files: []