bitcoin-cigs 0.0.3 → 0.0.4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bitcoin-cigs (0.0.3)
+    bitcoin-cigs (0.0.4)
 
 GEM
   remote: http://rubygems.org/

data/README.md

@@ -2,9 +2,42 @@
 
 ## Installation
 
-    gem install bitcoin-cigs
+```sh
+~$ gem install bitcoin-cigs
+```
+
+## Command Line
+
+Usage:
+```sh
+~$ bitcoin-cigs 
+Usage: bitcoin-cigs command [arguments ...] [options ...]
+
+Commands
+     verify bitcoin-address signature [message-file]
+     sign private-key [message-file]
+
+Options
+    -m, --message MESSAGE            Message can also be read from STDIN
+    -S, --no-strip                   Do not strip leading and trailing whitespace from message (stripped by default)
+```
+
+Examples:
+```sh
+~$ # Sign with -m message parameter
+~$ bitcoin-cigs sign 5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX -m 'this is a message'
+HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=
+~$ 
+~$ # Verify with message from STDIN
+~$ echo 'this is a message' | bitcoin-cigs verify 11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9 HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=
+~$ 
+~$ # Verify with message from file
+~$ echo 'this is a message' > message.txt
+~$ bitcoin-cigs verify 11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9 HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4= message.txt
+~$ 
+```
 
-## Examples
+## Ruby API
 
 Sign a message:
 ```ruby

data/lib/bitcoin-cigs.rb

@@ -1 +1 @@
-require 'bitcoin_cigs'
+require File.join(File.dirname(__FILE__), 'bitcoin_cigs.rb')

data/lib/bitcoin_cigs.rb

@@ -1,15 +1,16 @@
-require 'bitcoin_cigs/error'
-require 'bitcoin_cigs/crypto_helper'
-require 'bitcoin_cigs/base_58'
-require 'bitcoin_cigs/curve_fp'
-require 'bitcoin_cigs/point'
-require 'bitcoin_cigs/public_key'
-require 'bitcoin_cigs/private_key'
-require 'bitcoin_cigs/signature'
-require 'bitcoin_cigs/ec_key'
+%w(error crypto_helper base_58 curve_fp point public_key private_key signature ec_key).each do |f|
+  require File.join(File.dirname(__FILE__), 'bitcoin_cigs', f)
+end
 
 module BitcoinCigs
-  PRIVATE_KEY_PREFIX = 0x80
+  PRIVATE_KEY_PREFIX = {
+    :mainnet => 0x80,
+    :testnet => 0xEF
+  }
+  NETWORK_VERSION = {
+    :mainnet => 0x00,
+    :testnet => 0x6F
+  }
   
   P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
   R = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
@@ -24,17 +25,19 @@ module BitcoinCigs
   class << self
     include ::BitcoinCigs::CryptoHelper
     
-    def verify_message(address, signature, message)
+    def verify_message(address, signature, message, options = {:network => :mainnet})
       begin
-        verify_message!(address, signature, message)
+        verify_message!(address, signature, message, options)
         true
       rescue ::BitcoinCigs::Error
         false
       end
     end
     
-    def verify_message!(address, signature, message)
-      network_version = str_to_num(decode58(address)) >> (8 * 24)
+    def verify_message!(address, signature, message, options = {:network => :mainnet})
+      decoded_address = decode58(address)
+      raise ::BitcoinCigs::Error.new("Incorrect address or message for signature.") if decoded_address.nil?
+      network_version = str_to_num(decoded_address) >> (8 * 24)
 
       message = calculate_hash(format_message_to_sign(message))
 
@@ -79,29 +82,29 @@ module BitcoinCigs
       
     
       public_key = ::BitcoinCigs::PublicKey.new(g, q, compressed)
-      addr = public_key_to_bc_address(public_key.ser(), network_version)
+      addr = public_key_to_bc_address(public_key.ser(), NETWORK_VERSION[options[:network]])
       raise ::BitcoinCigs::Error.new("Incorrect address or message for signature.") if address != addr
       
       nil
     end
     
-    def sign_message(wallet_key, message)
+    def sign_message(wallet_key, message, options = {:network => :mainnet})
       begin
-        sign_message!(wallet_key, message)
+        sign_message!(wallet_key, message, options)
       rescue ::BitcoinCigs::Error
         nil
       end
     end
     
-    def sign_message!(wallet_key, message)
-      private_key = convert_wallet_format_to_bytes!(wallet_key)
+    def sign_message!(wallet_key, message, options = {:network => :mainnet})
+      private_key = convert_wallet_format_to_bytes!(wallet_key, options[:network])
       
       msg_hash = sha256(sha256(format_msg_to_sign(message)))
       
       ec_key = ::BitcoinCigs::EcKey.new(str_to_num(private_key))
       private_key = ec_key.private_key
       public_key = ec_key.public_key
-      addr = public_key_to_bc_address(get_pub_key(ec_key, ec_key.public_key.compressed))
+      addr = public_key_to_bc_address(get_pub_key(ec_key, ec_key.public_key.compressed), NETWORK_VERSION[options[:network]])
       
       sig = private_key.sign(msg_hash, random_k)
       raise ::BitcoinCigs::Error.new("Unable to sign message") unless public_key.verify(msg_hash, sig)
@@ -113,7 +116,7 @@ module BitcoinCigs
         sign_64 = encode64(sign)
         
         begin
-          verify_message!(addr, sign_64, message)
+          verify_message!(addr, sign_64, message, options)
           return sign_64
         rescue ::BitcoinCigs::Error
           next
@@ -123,11 +126,11 @@ module BitcoinCigs
       raise ::BitcoinCigs::Error, "Unable to construct recoverable key"
     end
     
-    def convert_wallet_format_to_bytes!(input)
-      bytes = if is_wallet_import_format?(input)
-        decode_wallet_import_format(input)
-      elsif is_compressed_wallet_import_format?(input)
-        decode_compressed_wallet_import_format(input)
+    def convert_wallet_format_to_bytes!(input, network)
+      bytes = if is_wallet_import_format?(input, network)
+        decode_wallet_import_format(input, network)
+      elsif is_compressed_wallet_import_format?(input, network)
+        decode_compressed_wallet_import_format(input, network)
       elsif is_mini_format?(input)
         sha256(input)
       elsif is_hex_format?(input)
@@ -170,28 +173,30 @@ module BitcoinCigs
       decode_hex(key)
     end
 
-    def decode_wallet_import_format(input)
-      bytes = decode58(input)[1..-1]
+    def decode_wallet_import_format(input, network)
+      bytes = decode58(input)#[1..-1]
+      #puts "ASDF #{bytes.unpack('H*')}"
+      #puts bytes.bytes.collect {|e| e.to_i}.join(" ")
       hash = bytes[0..32]
       
       checksum = sha256(sha256(hash))
-      raise ::BitcoinCigs::Error.new("Wallet checksum invalid") if bytes[33..-1] != checksum[0...4]
+      raise ::BitcoinCigs::Error.new("Wallet checksum invalid") if bytes[33..37] != checksum[0..3]
 
       version, hash = hash[0], hash[1..-1]
-      raise ::BitcoinCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX
+      raise ::BitcoinCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX[network]
       
       hash
     end
     
-    def decode_compressed_wallet_import_format(input)
+    def decode_compressed_wallet_import_format(input, network)
       bytes = decode58(input)
       hash = bytes[0...34]
       
       checksum = sha256(sha256(hash))
-      raise ::BitcoinCigs::Error.new("Wallet checksum invalid") if bytes[34..-1] != checksum[0...4]
+      raise ::BitcoinCigs::Error.new("Wallet checksum invalid") if bytes[34..37] != checksum[0..3]
 
       version, hash = hash[0], hash[1..32]
-      raise ::BitcoinCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX
+      raise ::BitcoinCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX[network]
       
       hash
     end
@@ -202,13 +207,13 @@ module BitcoinCigs
     end
     
     # 51 characters base58 starting with 5
-    def is_wallet_import_format?(key)
-      /^5[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/ =~ key
+    def is_wallet_import_format?(key, network)
+      /^#{network == :mainnet ? '5' : '9'}[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{50}$/ =~ key
     end
     
     # 52 characters base58 starting with L or K
-    def is_compressed_wallet_import_format?(key)
-      /^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/ =~ key
+    def is_compressed_wallet_import_format?(key, network)
+      /^[network == :mainnet ? 'LK' : 'c'][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/ =~ key
     end
     
     # 44 characters
@@ -239,7 +244,7 @@ module BitcoinCigs
       "\x18Bitcoin Signed Message:\n#{message.length.chr}#{message}"
     end
     
-    def public_key_to_bc_address(public_key, network_version = 0)
+    def public_key_to_bc_address(public_key, network_version)
       h160 = hash_160(public_key)
       
       hash_160_to_bc_address(h160, network_version)

data/lib/bitcoin_cigs/base_58.rb

@@ -4,42 +4,81 @@ module BitcoinCigs
     CHAR_SIZE = CHARS.size
 
     def self.decode(s)
-      value = s.chars.reverse_each.each_with_index.inject(0) { |acc, (ch, i)| acc + (CHARS.index(ch) || -1) * (CHAR_SIZE ** i) }
-      
-      result = []
-      while value >= 256
-        div = value / 256
-        mod = value % 256
-        result.unshift(mod.chr)
-        value = div
+      int_val = 0
+      s.reverse.split('').each_with_index do |char, index|
+        char_index = CHARS.index(char)
+        return nil if char_index.nil?
+        int_val += char_index * (CHAR_SIZE ** index)
       end
-      result.unshift(value.chr)
-      
-      pad_size = s.chars.inject(0) { |acc, ch| acc + (CHARS[0] == ch ? 1 : 0) }
       
-      result.unshift(0.chr * pad_size)
+      leading_zeros = /^#{CHARS[0]}*/.match(s).to_s.size
       
-      result.join
+      ["#{"\x00\x00" * leading_zeros}#{int_val.to_s(16)}"].pack('H*')
     end
     
     def self.encode(s)
-      value = 0
+      int_val = s.unpack('H*').first.to_i(16)
       
-      value = s.chars.reverse_each.each_with_index.inject(0) { |acc, (ch, i)| acc + (256 ** i) * ch.ord }
-
-      result = []
-      while value >= CHAR_SIZE
-        div, mod = value / CHAR_SIZE, value % CHAR_SIZE
-        result.unshift(CHARS[mod])
-        value = div
+      base58_val = ''
+      while int_val >= CHAR_SIZE
+        mod = int_val % CHAR_SIZE
+        base58_val = CHARS[mod,1] + base58_val
+        int_val = (int_val - mod) / CHAR_SIZE
       end
-      result.unshift(CHARS[value])
-
-      pad_size = s.chars.inject(0) { |acc, ch| acc + (ch == "\0" ? 1 : 0) }
       
-      result.unshift(CHARS[0] * pad_size)
-
-      result.join
+      result = CHARS[int_val, 1] + base58_val
+      
+      s.chars.each do |char|
+        if char == "\x00"
+          result = CHARS[0] + result
+        else
+          break
+        end
+      end
+      
+      result
     end
+    
+    # def self.encode(s)
+    #   int_val = s.unpack('H*').first.to_i(16)
+    #   
+    #   var bi = BigInteger.fromByteArrayUnsigned(input);
+    #   var chars = [];
+    # 
+    #   while (bi.compareTo(B58.base) >= 0) {
+    #     var mod = bi.mod(B58.base);
+    #     chars.unshift(B58.alphabet[mod.intValue()]);
+    #     bi = bi.subtract(mod).divide(B58.base);
+    #   }
+    #   chars.unshift(B58.alphabet[bi.intValue()]);
+    # 
+    #   for (var i = 0; i < input.length; i++) {
+    #     if (input[i] == 0x00) {
+    #       chars.unshift(B58.alphabet[0]);
+    #     } else break;
+    #   }
+    # 
+    #   return chars.join('');
+    # end
+    
+    # def self.encode(s)
+    #   value = 0
+    #   
+    #   value = s.chars.reverse_each.each_with_index.inject(0) { |acc, (ch, i)| acc + (256 ** i) * ch.ord }
+    # 
+    #   result = []
+    #   while value >= CHAR_SIZE
+    #     div, mod = value / CHAR_SIZE, value % CHAR_SIZE
+    #     result.unshift(CHARS[mod])
+    #     value = div
+    #   end
+    #   result.unshift(CHARS[value])
+    # 
+    #   pad_size = s.chars.inject(0) { |acc, ch| acc + (ch == "\0" ? 1 : 0) }
+    #   
+    #   result.unshift(CHARS[0] * pad_size)
+    # 
+    #   result.join
+    # end
   end
 end

data/lib/bitcoin_cigs/version.rb

@@ -1,3 +1,3 @@
 module BitcoinCigs
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/bitcoin_cigs/base_58_spec.rb

@@ -9,13 +9,13 @@ describe BitcoinCigs::Base58 do
     
     context "with valid data" do
       it "decodes properly" do
-        expect(Base64.encode64(subject).strip).to eq("ABgIZ4vqJRDJAqbMPNKKwHNFFgMWIJM1kQ==")
+        expect(subject.unpack('H*').first).to eq("001808678bea2510c902a6cc3cd28ac0734516031620933591")
       end
     end
   end
   
   describe "encode" do
-    let(:data) { Base64.decode64("ABgIZ4vqJRDJAqbMPNKKwHNFFgMWIJM1kQ==") }
+    let(:data) { ["001808678bea2510c902a6cc3cd28ac0734516031620933591"].pack('H*') }
     
     subject { BitcoinCigs::Base58.encode(data) }
     

data/spec/bitcoin_cigs_spec.rb

@@ -1,20 +1,33 @@
 require 'spec_helper'
 
 describe BitcoinCigs do
-  let(:wallet_key) { "5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX" }
-  let(:address) { "11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9" }
-  let(:original_address) { "11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9" }
-  let(:private_key) { ["39678A14ECA8479B3C58DCD25A5C94BE768389E823435C4DDFCAEB13519AB10E"].pack('H*') }
-  let(:signature) { "HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=" }
+  def self.use_mainnet
+    let(:wallet_key) { "5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX" }
+    let(:address) { "11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9" }
+    let(:original_address) { "11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9" }
+    let(:private_key) { ["39678A14ECA8479B3C58DCD25A5C94BE768389E823435C4DDFCAEB13519AB10E"].pack('H*') }
+    let(:signature) { "HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=" }
+    let(:network) { :mainnet }
+  end
+  
+  def self.use_testnet
+    let(:wallet_key) { "92FqDytA43K8unrrZgpzMddhmEbMMRNhBJAU59a3MkYfsUgH8st" }
+    let(:address) { "mh9nRF1ZSqLJB3hbUjPLmfDHdnGUURdYdK" }
+    let(:original_address) { "mh9nRF1ZSqLJB3hbUjPLmfDHdnGUURdYdK" }
+    let(:private_key) { ["585C660C887913E5F40B8E34D99C62766443F9D043B1DE1DFDCC94E386BC6DF6"].pack('H*') }
+    let(:signature) { "HIZQbBLAGJLhSZ310FCQMAo9l1X2ysxyt0kXkf6KcBN3znl2iClC6V9wz9Nkn6mMDUaq4kRlgYQDUUlsm29Bl0o=" }
+    let(:network) { :testnet }
+  end
   
+  use_mainnet
   let(:message) { "this is a message" }
   
   describe "sign_message!" do
-    subject { BitcoinCigs.sign_message!(wallet_key, message) }
+    subject { BitcoinCigs.sign_message!(wallet_key, message, :network => network) }
     
     context "with valid data" do
       it "generates the correct signature" do
-        expect(BitcoinCigs.verify_message(address, subject, message)).to be_true
+        expect(BitcoinCigs.verify_message(address, subject, message, :network => network)).to be_true
       end
     end
     
@@ -25,6 +38,16 @@ describe BitcoinCigs do
         expect { subject }.to raise_error(::BitcoinCigs::Error, "Unknown Wallet Format")
       end
     end
+    
+    context "with testnet" do
+      use_testnet
+      
+      context "with valid data" do
+        it "generates the correct signature" do
+          expect(BitcoinCigs.verify_message(address, subject, message, :network => network)).to be_true
+        end
+      end
+    end
   end
   
   describe "sign_message" do
@@ -46,7 +69,7 @@ describe BitcoinCigs do
   end
   
   describe "convert_wallet_format_to_bytes!" do
-    subject { BitcoinCigs.convert_wallet_format_to_bytes!(wallet_key) }
+    subject { BitcoinCigs.convert_wallet_format_to_bytes!(wallet_key, network) }
     
     context "with wallet import format" do
       let(:wallet_key) { "5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX" }
@@ -54,6 +77,16 @@ describe BitcoinCigs do
       it "converts to correct bytes" do
         expect(subject).to eq(private_key)
       end
+      
+      context "with testnet" do
+        use_testnet
+        
+        let(:wallet_key) { "92FqDytA43K8unrrZgpzMddhmEbMMRNhBJAU59a3MkYfsUgH8st" }
+        
+        it "converts to correct bytes" do
+          expect(subject).to eq(private_key)
+        end
+      end
     end
     
     context "with compressed wallet import format" do
@@ -62,6 +95,16 @@ describe BitcoinCigs do
       it "converts to correct bytes" do
         expect(subject).to eq(private_key)
       end
+
+      context "with testnet" do
+        use_testnet
+        
+        let(:wallet_key) { "cQYTrJ4nxRD3v1R3mGnpA4gzvEzcq8akLSknVJpqQbCnZeD6WfNC" }
+        
+        it "converts to correct bytes" do
+          expect(subject).to eq(private_key)
+        end
+      end
     end
     
     context "with mini format" do
@@ -91,7 +134,7 @@ describe BitcoinCigs do
   end
   
   describe "verify_message!" do
-    subject { BitcoinCigs.verify_message!(address, signature, message) }
+    subject { BitcoinCigs.verify_message!(address, signature, message, :network => network) }
     
     context "with valid data" do
       it "verifies valid message" do
@@ -122,13 +165,23 @@ describe BitcoinCigs do
         expect { subject }.to raise_error(::BitcoinCigs::Error, "Incorrect address or message for signature.")
       end
     end
+    
+    context "with testnet" do
+      use_testnet
+      
+      context "with valid data" do
+        it "verifies valid message" do
+          expect(subject).to be_nil
+        end
+      end
+    end
   end
   
-  describe "verify_message!" do
+  describe "verify_message" do
     subject { BitcoinCigs.verify_message(address, signature, message) }
     
     context "with valid data" do
-      it "verifies valid message" do
+      it "returns true" do
         expect(subject).to be_true
       end
     end
@@ -136,7 +189,7 @@ describe BitcoinCigs do
     context "with invalid data" do
       let(:address) { "invalid" }
       
-      it "raises ::BitcoinCigs::Error" do
+      it "returns false" do
         expect(subject).to be_false
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitcoin-cigs
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -96,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: bitcoin-cigs
-rubygems_version: 1.8.25
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Create and Verify Bitcoin Signatures