monero_wallet_gen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2cf58ea72ce7098e281262607375aa246024c5f3257e1bfa0542dbd2f7902593
+  data.tar.gz: 7953f8164d12a674074333ae0679ba731e00f0cb33bc141871d16e272e244951
+SHA512:
+  metadata.gz: 8bc9aca179ee42034d757817ceeacf5f43b9d748d96b564fb78c82445b5f15fb605c19e5a118c2f4bf531672731b01d6257d75eb2899876bf2fa6f0b75c00706
+  data.tar.gz: 4b2b1ccbcd31ba4caf5cbad170f55fb9126ac8dc930768fe27632a0e9a46ef72fcb80a40a980e316ffe55c868854377725a6abe9ce97db6d1375042dc6aacee6

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in monero_wallet_gen.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Evan Rolfe
+
+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,14 @@
+# Monero Address Generator
+Lets you generate a fully functional monero address which you can send money to.
+
+## Installation
+Install the gem:
+```bash
+gem install monero_wallet_gen
+```
+
+And require it from your ruby file:
+```ruby
+require 'monero_wallet_gen'
+```
+## Usage

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "monero_wallet_gen"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/monero_wallet_gen.rb

@@ -0,0 +1,133 @@
+require 'zlib'
+require 'digest/sha3'
+require 'monero_wallet_gen/version'
+require 'monero_wallet_gen/base58'
+require 'monero_wallet_gen/ed25519'
+require 'monero_wallet_gen/words'
+
+module MoneroWalletGen
+  NETBYTE_STANDARD = '12'
+  NETBYTE_TESTNET = '35'
+
+  def self.generate(testnet: false)
+    hex = sc_reduce32(mn_random)
+    generate_from_private_key(hex, testnet: testnet)
+  end
+
+  def self.generate_from_private_key(hex, testnet: false)
+    mn = mn_encode(hex)
+    priv_spend_key = hex
+    priv_view_key = sc_reduce32(cn_fast_hash(hex))
+    pub_spend_key = priv_key_to_pub(priv_spend_key)
+    pub_view_key = priv_key_to_pub(priv_view_key)
+    netbyte = testnet ? NETBYTE_TESTNET : NETBYTE_STANDARD
+    address = get_public_address(netbyte, pub_spend_key, pub_view_key)
+
+    {
+      priv_spend_key: priv_spend_key,
+      priv_view_key: priv_view_key,
+      pub_spend_key: pub_spend_key,
+      pub_view_key: pub_view_key,
+      address: address,
+      mnemonic: mn
+    }
+  end
+
+  def self.little_endian(str)
+    output = []
+    (0..str.length).step(2) do |i|
+      substr = str[i..i+1]
+      output << substr
+    end
+    output.reverse.join
+  end
+
+  def self.hex_to_int(hex)
+    le_hex = little_endian(hex)
+    le_hex.to_i(16)
+  end
+
+  def self.int_to_hex(n)
+    be_hex = n.to_s(16).rjust(64, '0')
+    little_endian(be_hex)
+  end
+
+  # Takes a 32-byte integer and outputs the integer modulo q. Same code as above,
+  # except skipping the 64→32 byte step.
+  def self.sc_reduce32(hex)
+    l = 2**252 + 27742317777372353535851937790883648493
+    n = hex_to_int(hex)
+    reduced = (n % l)
+    int_to_hex(reduced)
+  end
+
+  def self.random_integer_digits(digits)
+    digits.times.map{ rand(10) }.join.to_i
+  end
+
+  def self.mn_random
+    # Generate array of random integers
+    array = 8.times.map { random_integer_digits(10) }
+
+    # Convert to 8-bit hex
+    array.map do |n|
+      ('0000000' + n.to_s(16))[-8..-1]
+    end.join
+  end
+
+  def self.mn_encode(message)
+    n = WORDS.length
+
+    (0..message.length-1).step(8) do |i|
+      if i == 0
+        message = little_endian(message[i..i+7]) + message[i+8..-1]
+      else
+        message = message[0..i-1] + little_endian(message[i..i+7]) + message[i+8..-1]
+      end
+    end
+
+    words = []
+    limit = message.length / 8 - 1
+    (0..limit).to_a.each do |i|
+      word = message[8*i..8*i+7]
+      x = word.to_i(16)
+      w1 = (x % n)
+      w2 = ((x / n).to_i + w1) % n
+      w3 = (((x / n) / n).to_i + w2) % n
+
+      words += [ WORDS[w1], WORDS[w2], WORDS[w3] ]
+    end
+
+    trimmed_words = words.map { |word| word[0..2] }.join
+    checksum = Zlib.crc32(trimmed_words)
+    checkword = words[checksum % words.length]
+    words << checkword
+    words.join(' ')
+  end
+
+  def self.hex_to_bin(hex)
+    output = []
+    (0..hex.length-1).step(2) do |i|
+      substr = hex[i..i+1]
+      output << substr.to_i(16)
+    end
+    output.pack('C*')
+  end
+
+  def self.cn_fast_hash(hex)
+    bin = hex_to_bin(hex)
+    Digest::SHA3.hexdigest(bin, 256)
+  end
+
+  def self.priv_key_to_pub(hex)
+    point = Ed25519::scalarmultbase(hex_to_int(hex))
+    Ed25519::encode_point(point).unpack('H*').first.to_s
+  end
+
+  def self.get_public_address(netbyte, pub_spend_key, pub_view_key, pid = '')
+    pre_address = netbyte + pub_spend_key + pub_view_key
+    hashed = cn_fast_hash(pre_address)
+    hex_address = pre_address + hashed[0..7]
+    Base58::encode(hex_address)
+  end
+end

data/lib/monero_wallet_gen/base58.rb

@@ -0,0 +1,86 @@
+module MoneroWalletGen
+  module Base58
+    ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('').map { |c| c.ord }
+    B58BASE = 58
+    UINT64MAX = 2**64
+    ENCODED_BLOCK_SIZES = [0, 2, 3, 5, 6, 7, 9, 10, 11]
+    FULL_BLOCK_SIZE = 8
+    FULL_ENCODED_BLOCK_SIZE = 11
+
+    def self.hex_to_bin(hex)
+      raise ArgumentError, 'Hex string has invalid length!' if hex.length % 2 != 0
+
+      (0..(hex.length / 2 - 1)).to_a.map do |i|
+        hex[i*2..i*2+1].to_i(16)
+      end
+    end
+
+    def self.bin_to_hex(bin)
+      bin.map do |x|
+        x.to_s(16).rjust(2, '0')
+      end.join
+    end
+
+    def self.str_to_bin(str)
+      str.split('').map { |c| c.ord }
+    end
+
+    def self.bin_to_str(bin)
+      bin.map { |x| x.chr }.join
+    end
+
+    def self.uint8be_to_64(data)
+      raise ArgumentError 'Invalid input length' if data.length < 1 || data.length > 8
+
+      data.reduce(0) { |result, x| result = result << 8 | x }
+    end
+
+    def self.uint64_to_8be(x, size)
+      result = size.times.map { '0' }
+
+      raise ArgumentError 'Invalid input length' if size < 1 || size > 8
+
+      (size-1).downto(0) do |i|
+        result[i] = x % 2 ** 8
+        x = x / 2 ** 8
+      end
+      result
+    end
+
+    def self.encode_block(data, buffer, index)
+      num = uint8be_to_64(data)
+      i = ENCODED_BLOCK_SIZES[data.length] - 1
+
+      while(num > 0) do
+        remainder = num % B58BASE
+        num = num / B58BASE
+        buffer[index+i] = ALPHABET[remainder];
+        i -= 1
+      end
+
+      buffer
+    end
+
+    def self.encode(hex)
+      data = hex_to_bin(hex)
+
+      full_block_count = data.length / FULL_BLOCK_SIZE
+      last_block_size = data.length % FULL_BLOCK_SIZE
+      res_size = full_block_count * FULL_ENCODED_BLOCK_SIZE + ENCODED_BLOCK_SIZES[last_block_size]
+
+      result = res_size.times.map { ALPHABET[0] }
+
+      (0..full_block_count-1).to_a.each do |i|
+        result = encode_block(
+          data[(i*FULL_BLOCK_SIZE)..(i*FULL_BLOCK_SIZE+FULL_BLOCK_SIZE-1)], result, i * FULL_ENCODED_BLOCK_SIZE
+        )
+      end
+
+      if last_block_size > 0
+        res = encode_block(data[(full_block_count*FULL_BLOCK_SIZE)..(full_block_count*FULL_BLOCK_SIZE+last_block_size - 1)], result, full_block_count * FULL_ENCODED_BLOCK_SIZE)
+      end
+
+      bin_to_str(result)
+    end
+  end
+end

data/lib/monero_wallet_gen/ed25519.rb

@@ -0,0 +1,177 @@
+require 'digest/sha3'
+
+# This is a port of the pure-python implementation of Ed25519
+# http://ed25519.cr.yp.to/software.html
+
+module MoneroWalletGen
+  module Ed25519
+    B = 256
+    Q = 2**255 - 19
+    L = 2**252 + 27742317777372353535851937790883648493
+
+    def self.hash(str)
+      Digest::SHA512.digest(str)
+    end
+
+    def self.expmod(base, exponent, modulus)
+      return modulus == 1 ? 0 : begin
+        result = 1
+        base = base % modulus
+        while exponent > 0
+          result = result * base % modulus if exponent % 2 == 1
+          exponent = exponent >> 1
+          base = base * base % modulus
+        end
+      result
+      end
+    end
+
+    def self.inverse(x)
+      expmod(x,Q-2,Q)
+    end
+
+    def self.d
+      -121665 * inverse(121666)
+    end
+
+    def self.i
+      expmod(2,(Q-1)/4,Q)
+    end
+
+    def self.xrecover(y)
+      xx = (y * y - 1) * inverse(d * y * y + 1)
+      x = expmod(xx, (Q + 3) / 8, Q)
+      if (x * x - xx) % Q != 0
+        x = (x * i) % Q
+      end
+      if x % 2 != 0
+        x = Q-x
+      end
+      x
+    end
+
+    def self.edwards_add(p, q)
+      x1 = p[0]
+      y1 = p[1]
+      x2 = q[0]
+      y2 = q[1]
+
+      x3 = (x1*y2+x2*y1) * inverse(1+d*x1*x2*y1*y2)
+      y3 = (y1*y2+x1*x2) * inverse(1-d*x1*x2*y1*y2)
+      [x3 % Q,y3 % Q]
+    end
+
+    def self.base
+      by = 4 * inverse(5)
+      bx = xrecover(by)
+      [bx % Q,by % Q]
+    end
+
+    def self.scalarmult(point, e)
+      return [0,1] if e == 0
+
+      q = scalarmult(point, e / 2)
+      q = edwards_add(q,q)
+
+      if (e & 1) == 1
+        q = edwards_add(q,point)
+      end
+      q
+    end
+
+    def self.scalarmultbase(e)
+      return [0,1] if e == 0
+
+      q = scalarmult(base, e/2)
+      q = edwards_add(q,q)
+
+      if (e & 1) == 1
+        q = edwards_add(q,base)
+      end
+      q
+    end
+
+    def self.ge_scalarmult(point, e)
+      encode_point_hex(scalarmult(to_point(point), e))
+    end
+
+    def self.encode_point(p)
+      x = p[0]
+      y = p[1]
+      bits = (0..254).to_a.map do |i|
+        (y >> i) & 1
+      end
+      bits << (x & 1)
+
+      output = []
+      (0..31).to_a.each do |i|
+        sub_bits = []
+        (0..7).to_a.each do |j|
+          sub_bits << (bits[i * 8 + j] << j)
+        end
+        output << sub_bits.sum
+      end
+      output.pack('C*')
+    end
+
+    def self.encode_point_hex(p)
+      x = p[0]
+      y = p[1]
+      bits = (0..254).to_a.map do |i|
+        (y >> i) & 1
+      end
+      bits << (x & 1)
+
+      output = []
+      (0..31).to_a.each do |i|
+        sub_bits = []
+        (0..7).to_a.each do |j|
+          sub_bits << (bits[i * 8 + j] << j)
+        end
+        output << sub_bits.sum
+      end
+      output.map { |x| x.to_s(16).rjust(2, '0') }.join
+    end
+
+    def self.encode_int(y)
+      #TODO
+      #bits = [(y >> i) & 1 for i in range(b)]
+      #return ''.join([chr(sum([bits[i * 8 + j] << j for j in range(8)])) for i in range(b/8)])
+    end
+
+    def self.bit(str,i)
+      str[i / 8].ord >> (i % 8) & 1
+    end
+
+
+    def self.decode_point(str)
+      y = (0..B-2).to_a.map do |i|
+        2**i * bit(str,i)
+      end.sum
+
+      x = xrecover(y)
+
+      if x & 1 != bit(str,B-1)
+        x = Q - x
+      end
+
+      [x,y]
+    end
+
+    def self.to_point(hex)
+      output = []
+      (0..hex.length-1).step(2) do |i|
+        substr = hex[i..i+1]
+        output << substr.to_i(16)
+      end
+      bin = output.pack('C*')
+      decode_point(bin)
+    end
+
+    def self.decode_int(str)
+      (0..B).to_a.map do |i|
+        2**i * bit(str,i)
+      end.sum
+    end
+  end
+end