digibyte-cigs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df993226b86b93297a57ad07fa01304a1d6702f5
+  data.tar.gz: 752c471cbcd1c6af8ebd8466284415ad480c101d
+SHA512:
+  metadata.gz: 8632c3d2e520af4e00d5c384eac7ef90b0f8ad7ef378ecefd248b4e4e06f10f81fa03cb6c86498808e7038f467fdae5af7e03b790c3b8c0bf2ef02507e042c8d
+  data.tar.gz: 062e367f0e1211e9ad2ec181025aaf1f672c5327f6723fd63277fa87109cb95ddf491d4c46652785de8a536905b7903e019325f3312c55405a33e7955f35820e

data/.gitignore

@@ -0,0 +1,46 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+*.gem
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+
+.DS_Store
+
+# For TextMate
+*.tmproj
+tmtags
+.tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    digibyte-cigs (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  digibyte-cigs!
+  rake (~> 10.0.4)
+  rspec (~> 2.13.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Michael Pearce
+
+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,85 @@
+# DigiByte Cigs - Smokin' Hot DigiByte Signatures
+
+## Installation
+
+```sh
+~$ gem install digibyte-cigs
+```
+
+## Command Line
+
+Usage:
+```sh
+~$ digibyte-cigs 
+Usage: digibyte-cigs command [arguments ...] [options ...]
+
+Commands
+     verify digibyte-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
+~$ digibyte-cigs sign 5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX -m 'this is a message'
+HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=
+~$ 
+~$ # Verify with message from STDIN
+~$ echo 'this is a message' | digibyte-cigs verify 11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9 HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4=
+~$ 
+~$ # Verify with message from file
+~$ echo 'this is a message' > message.txt
+~$ digibyte-cigs verify 11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9 HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4= message.txt
+~$ 
+```
+
+## Ruby API
+
+Sign a message:
+```ruby
+require 'rubygems'
+require 'digibyte-cigs'
+
+# Support for Wallet Import Format, Compressed WIF, Mini Format, Hex and Base64 wallets
+wallet_key = "5JFZuDkLgbEXK4CUEiXyyz4fUqzAsQ5QUqufdJy8MoLA9S1RdNX"
+message = "this is a message"
+
+puts "The signature is: #{DigiByteCigs.sign_message!(wallet_key, message)}"
+```
+
+Verify a message signature:
+```ruby
+require 'rubygems'
+require 'digibyte-cigs'
+
+address = "11o51X3ciSjoLWFN3sbg3yzCM8RSuD2q9"
+signature = "HIBYi2g3yFimzD/YSD9j+PYwtsdCuHR2xwIQ6n0AN6RPUVDGttgOmlnsiwx90ZSjmaWrH1/HwrINJbaP7eMA6V4="
+message = "this is a message"
+
+if DigiByteCigs.verify_message(address, signature, message)
+  puts "It looks like you own address #{address}!"
+end
+```
+
+# Credits
+
+Thanks to jackjack for pointing me to Armory's implementation of message signatures:
+https://github.com/jackjack-jj/jasvet
+
+[DigiByte Cigs](https://github.com/michaelgpearce/digibyte-cigs) is maintained by [Michael Pearce](https://github.com/michaelgpearce).
+
+# Donation
+
+If you find this software useful and wish to donate, you can do so here:
+```
+1Cyd1wG4hCXK5aRCJQu3KnnhSrrfgs7NeM
+```
+
+# Copyright
+
+Copyright (c) 2013 Michael Pearce. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run Specs'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/digibyte-cigs

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'digibyte-cigs'
+
+@options = {}
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: digibyte-cigs command [arguments ...] [options ...]"
+  opt.separator  ""
+  opt.separator  "Commands"
+  opt.separator  "     verify digibyte-address signature [message-file]"
+  opt.separator  "     sign private-key [message-file]"
+  opt.separator  ""
+  opt.separator  "Options"
+  opt.on("-m", "--message MESSAGE", "Message can also be read from STDIN") do |message|
+    @options[:message] = message
+  end
+  opt.on("-S", "--no-strip", "Do not strip leading and trailing whitespace from message (stripped by default)") do
+    @options[:no_strip] = true
+  end
+end
+
+opt_parser.parse!
+
+def message
+  message = @options[:message] || ARGF.read
+  message.strip! unless @options[:no_strip]
+  
+  message
+end
+
+begin
+  case ARGV.shift
+  when "verify"
+    address = ARGV.shift or raise ArgumentError
+    signature = ARGV.shift or raise ArgumentError
+    ::DigiByteCigs.verify_message!(address, signature, message)
+  when "sign"
+    private_key = ARGV.shift or raise ArgumentError
+    puts ::DigiByteCigs.sign_message!(private_key, message)
+  else
+    raise ArgumentError
+  end
+  exit 0
+rescue ::DigiByteCigs::Error => e
+  puts "Error: #{e}"
+  exit 2
+rescue ArgumentError
+  puts opt_parser
+  exit 1
+end

data/digibyte-cigs.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "digibyte_cigs/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "digibyte-cigs"
+  spec.version     = DigiByteCigs::VERSION
+  spec.authors  = ["Vertbase"]
+  spec.email    = ["dev@vertbase.com"]
+  spec.summary  = "Create and Verify DigiByte Signatures"
+  spec.homepage = "https://github.com/vertbase/digibyte-cigs"
+
+  spec.rubyforge_project = "digibyte-cigs"
+
+  spec.files = `git ls-files`.split("\n")
+  spec.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.require_paths = ["lib"]
+  spec.executables = ['digibyte-cigs']
+
+  spec.add_development_dependency 'rspec', '~> 2.13.0'
+  spec.add_development_dependency 'rake', '~> 10.0.4'
+end

data/lib/digibyte-cigs.rb

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

data/lib/digibyte_cigs.rb

@@ -0,0 +1,278 @@
+%w(error crypto_helper compact_int base_58 curve_fp point public_key private_key signature ec_key).each do |f|
+  require File.join(File.dirname(__FILE__), 'digibyte_cigs', f)
+end
+
+module DigiByteCigs
+  PRIVATE_KEY_PREFIX = {
+    :mainnet => 0x80,
+    :testnet => 0xEF
+  }
+  NETWORK_VERSION = {
+    :mainnet => 0x00,
+    :testnet => 0x6F
+  }
+  
+  P = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
+  R = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+  B = 0x0000000000000000000000000000000000000000000000000000000000000007
+  A = 0x0000000000000000000000000000000000000000000000000000000000000000
+  Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
+  Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
+
+  CURVE_SECP256K1 = ::DigiByteCigs::CurveFp.new(P, A, B)
+  GENERATOR_SECP256K1 = ::DigiByteCigs::Point.new(CURVE_SECP256K1, Gx, Gy, R)
+  
+  class << self
+    include ::DigiByteCigs::CryptoHelper
+    
+    def verify_message(address, signature, message, options = {:network => :mainnet})
+      begin
+        verify_message!(address, signature, message, options)
+        true
+      rescue ::DigiByteCigs::Error
+        false
+      end
+    end
+    
+    def verify_message!(address, signature, message, options = {:network => :mainnet})
+
+      decoded_address = decode58(address)
+      raise ::DigiByteCigs::Error.new("Incorrect address or message for signature.") if decoded_address.nil?
+      # network_version = str_to_num(decoded_address) >> (8 * 24)
+
+      addr = get_signature_address!(signature, message, options)
+
+      raise ::DigiByteCigs::Error.new("Incorrect address or message for signature.") if address != addr
+      
+      nil
+    end
+
+    def get_signature_address(signature, message, options = {:network => :mainnet})
+      begin
+        get_signature_address!(signature, message, options)
+      rescue ::DigiByteCigs::Error
+        false
+      end 
+    end
+
+    def get_signature_address!(signature, message, options = {:network => :mainnet})
+
+      message = calculate_hash(format_message_to_sign(message))
+
+      curve = CURVE_SECP256K1
+      g = GENERATOR_SECP256K1
+      a, b, p = curve.a, curve.b, curve.p
+      
+      order = g.order
+      
+      sig = decode64(signature)
+      raise ::DigiByteCigs::Error.new("Bad signature length") if sig.size != 65
+      raise ::DigiByteCigs::Error.new("Bad characters in signature") if signature != encode64(sig)
+      
+      hb = sig[0].ord
+      r, s = [sig[1...33], sig[33...65]].collect { |s| str_to_num(s) }
+      
+      
+      raise ::DigiByteCigs::Error.new("Bad signature first byte") if hb < 27 || hb >= 35
+      
+      compressed = false
+      if hb >= 31
+        compressed = true
+        hb -= 4
+      end
+      
+      recid = hb - 27
+      x = (r + (recid / 2) * order) % p
+      y2 = ((x ** 3 % p) + a * x + b) % p
+      yomy = sqrt_mod(y2, p)
+      if (yomy - recid) % 2 == 0
+        y = yomy
+      else
+        y = p - yomy
+      end
+      
+      r_point = ::DigiByteCigs::Point.new(curve, x, y, order)
+      e = str_to_num(message)
+      minus_e = -e % order
+      
+      inv_r = inverse_mod(r, order)
+      q = (r_point * s + g * minus_e) * inv_r
+      
+    
+      public_key = ::DigiByteCigs::PublicKey.new(g, q, compressed)
+      
+      public_key_to_bc_address(public_key.ser(), NETWORK_VERSION[options[:network]])
+    end
+    
+    def sign_message(wallet_key, message, options = {:network => :mainnet})
+      begin
+        sign_message!(wallet_key, message, options)
+      rescue ::DigiByteCigs::Error
+        nil
+      end
+    end
+    
+    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_message_to_sign(message)))
+      
+      ec_key = ::DigiByteCigs::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), NETWORK_VERSION[options[:network]])
+      
+      sig = private_key.sign(msg_hash, random_k)
+      raise ::DigiByteCigs::Error.new("Unable to sign message") unless public_key.verify(msg_hash, sig)
+      
+      4.times do |i|
+        hb = 27 + i
+        
+        sign = "#{hb.chr}#{sig.ser}"
+        sign_64 = encode64(sign)
+        
+        begin
+          verify_message!(addr, sign_64, message, options)
+          return sign_64
+        rescue ::DigiByteCigs::Error
+          next
+        end
+      end
+      
+      raise ::DigiByteCigs::Error, "Unable to construct recoverable key"
+    end
+    
+    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)
+        decode_hex(input)
+      elsif is_base_64_format?(input)
+        decode64(input)
+      else
+        raise ::DigiByteCigs::Error.new("Unknown Wallet Format")
+      end
+      
+      bytes
+    end
+    
+    private
+    
+    def format_message_to_sign(message)
+      "\x18DigiByte Signed Message:\n#{::DigiByteCigs::CompactInt.new(message.size).encode}#{message}"
+    end
+    
+    def random_k
+      k = 0
+      8.times do |i|
+        k |= (rand * 0xffffffff).to_i << (32 * i)
+      end
+      
+      k
+    end
+        
+    def get_pub_key(public_key, compressed)
+      i2o_ec_public_key(public_key, compressed)
+    end
+    
+    def i2o_ec_public_key(public_key, compressed)
+      key = if compressed
+        "#{public_key.public_key.point.y & 1 > 0 ? '03' : '02'}%064x" % public_key.public_key.point.x
+      else
+        "04%064x%064x" % [public_key.public_key.point.x, public_key.public_key.point.y]
+      end
+
+      decode_hex(key)
+    end
+
+    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 ::DigiByteCigs::Error.new("Wallet checksum invalid") if bytes[33..37] != checksum[0..3]
+
+      version, hash = hash[0], hash[1..-1]
+      raise ::DigiByteCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX[network]
+      
+      hash
+    end
+    
+    def decode_compressed_wallet_import_format(input, network)
+      bytes = decode58(input)
+      hash = bytes[0...34]
+      
+      checksum = sha256(sha256(hash))
+      raise ::DigiByteCigs::Error.new("Wallet checksum invalid") if bytes[34..37] != checksum[0..3]
+
+      version, hash = hash[0], hash[1..32]
+      raise ::DigiByteCigs::Error.new("Wallet Version #{version} not supported") if version.ord != PRIVATE_KEY_PREFIX[network]
+      
+      hash
+    end
+    
+    # 64 characters [0-9A-F]
+    def is_hex_format?(key)
+      /^[A-Fa-f0-9]{64}$/ =~ key
+    end
+    
+    # 51 characters base58 starting with 5
+    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, network)
+      /^[network == :mainnet ? 'LK' : 'c'][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/ =~ key
+    end
+    
+    # 44 characters
+    def is_base_64_format?(key)
+      /^[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789=+\/]{44}$/ =~ key
+    end
+    
+    # 22, 26 or 30 characters, always starts with an 'S'
+    def is_mini_format?(key)
+      validChars22 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{21}$/ =~ key
+      validChars26 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{25}$/ =~ key
+      validChars30 = /^S[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{29}$/ =~ key
+      
+      bytes = sha256("#{key}?")
+    
+      (bytes[0].ord === 0x00 || bytes[0].ord === 0x01) && (validChars22 || validChars26 || validChars30)
+    end
+    
+    def debug_bytes(s)
+      s.chars.collect(&:ord).join(', ')
+    end
+    
+    def calculate_hash(d)
+      sha256(sha256(d))
+    end
+    
+    def public_key_to_bc_address(public_key, network_version)
+      h160 = hash_160(public_key)
+      
+      hash_160_to_bc_address(h160, network_version)
+    end
+    
+    def hash_160_to_bc_address(h160, address_type)
+      vh160 = address_type.chr + h160
+      h = calculate_hash(vh160)
+      addr = vh160 + h[0...4]
+      
+      encode58(addr)
+    end
+    
+    def hash_160(public_key)
+      ripemd160(sha256(public_key))
+    end
+    
+  end
+end