This message was too old and has been purged

[roslinpl]

I am starting to think you do not have the 1,000 BTC for this bounty.  Am I right?

Assuming you do not have it - and I pretty sure you don't - I will not be working on this project.

yep

Show us money!! Then we will work

[Mitchell]

I am starting to think you do not have the 1,000 BTC for this bounty.  Am I right?

Assuming you do not have it - and I pretty sure you don't - I will not be working on this project.

He has proven over and over again that he has the money to pay for the bounties he setup. I doubt that he even reads your post since the shit you pulled in his last bounty thread. Yes, 1.000BTC is a lot and yes signing an address would be good, but being a douche and pushing him to do something won't help.

My 2 cents.

[Evil-Knievel]

This message was too old and has been purged

[BurtW]

How about half.  Put half in an escrow account?

[BurtW]

the shit you pulled in his last bounty thread.

By "shit" you mean simply asking him to pay the bounty or at least explain why not?  He did eventually pay it and all ended well.  This is a much bigger bounty of about $600,000 as I type this so it is a whole different ball game.

[starsoccer9]

Is their anyway to make the python script simply loop and keep adding + 1 to k? Or choose a random number for k?

[Mitchell]

the shit you pulled in his last bounty thread.

By "shit" you mean simply asking him to pay the bounty or at least explain why not?  He did eventually pay it and all ended well.  This is a much bigger bounty of about $600,000 as I type this so it is a whole different ball game.

"Spamming" a post in 4 different topics, stating that his creditably goes down and meanwhile heating up the discussion in the bounty thread isn't the way to go (this is how I have experienced it). But oh well, that is the past. We will see what the future holds for us.

[Evil-Knievel]

This message was too old and has been purged

[starsoccer9]

Is their anyway to make the python script simply loop and keep adding + 1 to k? Or choose a random number for k?

Yes, this would be the following code. This will however (at least I think so) not be very promising:

Code:

#! /usr/bin/env python

import random
import array
import cPickle
import struct

class CurveFp( object ):
  def __init__( self, p, a, b ):
    self.__p = p
    self.__a = a
    self.__b = b

  def p( self ):
    return self.__p

  def a( self ):
    return self.__a

  def b( self ):
    return self.__b

  def contains_point( self, x, y ):
    return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

class Point( object ):
  def __init__( self, curve, x, y, order = None ):
    self.__curve = curve
    self.__x = x
    self.__y = y
    self.__order = order
    if self.__curve: assert self.__curve.contains_point( x, y )
    if order: assert self * order == INFINITY
 
  def __add__( self, other ):
    if other == INFINITY: return self
    if self == INFINITY: return other
    assert self.__curve == other.__curve
    if self.__x == other.__x:
      if ( self.__y + other.__y ) % self.__curve.p() == 0:
        return INFINITY
      else:
        return self.double()

    p = self.__curve.p()
    l = ( ( other.__y - self.__y ) * \
          inverse_mod( other.__x - self.__x, p ) ) % p
    x3 = ( l * l - self.__x - other.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def negative (self):
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    return negative_self

  def __mul__( self, other ):
    def leftmost_bit( x ):
      assert x > 0
      result = 1L
      while result <= x: result = 2 * result
      return result / 2

    e = other
    if self.__order: e = e % self.__order
    if e == 0: return INFINITY
    if self == INFINITY: return INFINITY
    assert e > 0
    e3 = 3 * e
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    i = leftmost_bit( e3 ) / 2
    result = self
    while i > 1:
      result = result.double()
      if ( e3 & i ) != 0 and ( e & i ) == 0: result = result + self
      if ( e3 & i ) == 0 and ( e & i ) != 0: result = result + negative_self
      i = i / 2
    return result

  def __rmul__( self, other ):
    return self * other

  def __str__( self ):
    if self == INFINITY: return "infinity"
    return "(%d,%d)" % ( self.__x, self.__y )

  def double( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    l = ( ( 3 * self.__x * self.__x + a ) * \
          inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def halve( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    
    # next three lines must be reverted somehow, then I am a multi millionaire :-)
    # as a=0 in this case, I have eliminated it!
    l = ( ( 3 * self.__x * self.__x ) * inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p


    return Point( self.__curve, x3, y3 )

  def x( self ):
    return self.__x

  def y( self ):
    return self.__y

  def curve( self ):
    return self.__curve
  
  def order( self ):
    return self.__order
    
INFINITY = Point( None, None, None )

def inverse_mod( a, m ):
  if a < 0 or m <= a: a = a % m
  c, d = a, m
  uc, vc, ud, vd = 1, 0, 0, 1
  while c != 0:
    q, c, d = divmod( d, c ) + ( c, )
    uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
  assert d == 1
  if ud > 0: return ud
  else: return ud + m

_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L

class Public_key( object ):
  def __init__( self, generator, point ):
    self.curve = generator.curve()
    self.generator = generator
    self.point = point
    n = generator.order()
    if not n:
      raise RuntimeError, "Generator point must have order."
    if not n * point == INFINITY:
      raise RuntimeError, "Generator point order is bad."
    if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
      raise RuntimeError, "Generator point has x or y out of range."


sex = CurveFp( _p, _a, _b )
ass = Point( sex, _Gx, _Gy, _r )
g = ass

if __name__ == "__main__":
  print '======================================================================='
  ### generate privkey
  challenge = Public_key(g, Point( sex, 0x4641b45737ee8e11ae39899060160507d61a30928b0d3e37b6aede29b4ed807bL, 0xb61b706b81dbb5512c556dfd16815cced84e2fa12b5c8b6440057355f0df2a12L))
  ppp=challenge.point

  # find the correct k
  k=random.randrange(1,2**255)
  # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  ppp=ppp + k*g

  while True:
    ppp=ppp+g
    k=k+1
    if ppp.x() == g.x():
      print "found!!!!!!! k=" + hex(k)
    else:
      print hex(ppp.x())  + " not matching " + hex(g.x())

Are you sure that will actully stop when it finds something? Just because from looking quickly it seems like even if i find it it will keep going. Also it needs to print out K when I get K
Also i assume K= a real number meaning 1 or 5959493 and not 58484.4835.

[Evil-Knievel]

This message was too old and has been purged

[roslinpl]

Is their anyway to make the python script simply loop and keep adding + 1 to k? Or choose a random number for k?

Yes, this would be the following code. This will however (at least I think so) not be very promising:

Code:

#! /usr/bin/env python

import random
import array
import cPickle
import struct

class CurveFp( object ):
  def __init__( self, p, a, b ):
    self.__p = p
    self.__a = a
    self.__b = b

  def p( self ):
    return self.__p

  def a( self ):
    return self.__a

  def b( self ):
    return self.__b

  def contains_point( self, x, y ):
    return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

class Point( object ):
  def __init__( self, curve, x, y, order = None ):
    self.__curve = curve
    self.__x = x
    self.__y = y
    self.__order = order
    if self.__curve: assert self.__curve.contains_point( x, y )
    if order: assert self * order == INFINITY
 
  def __add__( self, other ):
    if other == INFINITY: return self
    if self == INFINITY: return other
    assert self.__curve == other.__curve
    if self.__x == other.__x:
      if ( self.__y + other.__y ) % self.__curve.p() == 0:
        return INFINITY
      else:
        return self.double()

    p = self.__curve.p()
    l = ( ( other.__y - self.__y ) * \
          inverse_mod( other.__x - self.__x, p ) ) % p
    x3 = ( l * l - self.__x - other.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def negative (self):
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    return negative_self

  def __mul__( self, other ):
    def leftmost_bit( x ):
      assert x > 0
      result = 1L
      while result <= x: result = 2 * result
      return result / 2

    e = other
    if self.__order: e = e % self.__order
    if e == 0: return INFINITY
    if self == INFINITY: return INFINITY
    assert e > 0
    e3 = 3 * e
    negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
    i = leftmost_bit( e3 ) / 2
    result = self
    while i > 1:
      result = result.double()
      if ( e3 & i ) != 0 and ( e & i ) == 0: result = result + self
      if ( e3 & i ) == 0 and ( e & i ) != 0: result = result + negative_self
      i = i / 2
    return result

  def __rmul__( self, other ):
    return self * other

  def __str__( self ):
    if self == INFINITY: return "infinity"
    return "(%d,%d)" % ( self.__x, self.__y )

  def double( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    l = ( ( 3 * self.__x * self.__x + a ) * \
          inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
    return Point( self.__curve, x3, y3 )

  def halve( self ):
    if self == INFINITY:
      return INFINITY

    p = self.__curve.p()
    a = self.__curve.a()
    
    # next three lines must be reverted somehow, then I am a multi millionaire :-)
    # as a=0 in this case, I have eliminated it!
    l = ( ( 3 * self.__x * self.__x ) * inverse_mod( 2 * self.__y, p ) ) % p
    x3 = ( l * l - 2 * self.__x ) % p
    y3 = ( l * ( self.__x - x3 ) - self.__y ) % p


    return Point( self.__curve, x3, y3 )

  def x( self ):
    return self.__x

  def y( self ):
    return self.__y

  def curve( self ):
    return self.__curve
  
  def order( self ):
    return self.__order
    
INFINITY = Point( None, None, None )

def inverse_mod( a, m ):
  if a < 0 or m <= a: a = a % m
  c, d = a, m
  uc, vc, ud, vd = 1, 0, 0, 1
  while c != 0:
    q, c, d = divmod( d, c ) + ( c, )
    uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
  assert d == 1
  if ud > 0: return ud
  else: return ud + m

_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L

class Public_key( object ):
  def __init__( self, generator, point ):
    self.curve = generator.curve()
    self.generator = generator
    self.point = point
    n = generator.order()
    if not n:
      raise RuntimeError, "Generator point must have order."
    if not n * point == INFINITY:
      raise RuntimeError, "Generator point order is bad."
    if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
      raise RuntimeError, "Generator point has x or y out of range."


sex = CurveFp( _p, _a, _b )
ass = Point( sex, _Gx, _Gy, _r )
g = ass

if __name__ == "__main__":
  print '======================================================================='
  ### generate privkey
  challenge = Public_key(g, Point( sex, 0x4641b45737ee8e11ae39899060160507d61a30928b0d3e37b6aede29b4ed807bL, 0xb61b706b81dbb5512c556dfd16815cced84e2fa12b5c8b6440057355f0df2a12L))
  ppp=challenge.point

  # find the correct k
  k=random.randrange(1,2**255)
  # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  ppp=ppp + k*g

  while True:
    ppp=ppp+g
    k=k+1
    if ppp.x() == g.x():
      print "found!!!!!!! k=" + hex(k)
    else:
      print hex(ppp.x())  + " not matching " + hex(g.x())

Are you sure that will actully stop when it finds something? Just because from looking quickly it seems like even if i find it it will keep going.
Also i assume K= a real number meaning 1 or 5959493 and not 58484.4835

I post code for this a while ago
And it will stop but anyway...

Code:

(...)

# find the correct k
  k=1200000000000000000000000000000000000000000000000000000000000000000000000000000
  aNumber=1

  while aNumber==1:

    ppp=ppp + k*g
    if ppp.x() == g.x():

      print "HORRAY! You are the WINNER !! :) You just won 500BTC but you must wait till guys will buy them and transfer to your wallet, because they did not have them yet"

      print "K=", k 
      aNumber=2
      
    else:
  
      k=k-1
      print k

[Evil-Knievel]

This message was too old and has been purged

[starsoccer9]

Just as a hint: Python is realllllly slow, so if you really like to start bruteforcing I would suggest to use a C++ implementation. I could provide one tomorrow, but it is not very promising. Better would be some mathematical approach 

If you could make a GPU/open cl that would work out well. Anyways ill wait and see over night. Worse case I waisted some eletricity and cpu cores. Best case I made 1k BTC.

Any chance you can prove you have the 1k coins?

[BurtW]

He already answered your question.

Any chance you can prove you have the 1k coins?

Hi,

I personally do not own 1,000 BTC, but I am working in a project which has more than enough scientific funding to pay out the winner. So the payout is guaranteed.

So no, he does not have it.

[Tonka Branded Truck]

Hello Evil I'm very curious about this private key thing.

Public Key = Hash Public Key = Private Key ?

How many digits does the Private key have?

How many possible combination does private key have?

How many possible combination does public key have?

[roslinpl]

Just as a hint: Python is realllllly slow, so if you really like to start bruteforcing I would suggest to use a C++ implementation. I could provide one tomorrow, but it is not very promising. Better would be some mathematical approach 

No we dont think we will bruteforce it.

I think - that this is not possible at all.

Maybe possible IF you show price
so we can truely see what we are fighting for.

[hoian0809]

N/A

[akhan789]

I would like to work on this but i'm a java developer. Would prefer a java implementation if you have one. I have a few ideas I would like to try out...

[roslinpl]

I give my wallet password to someone who will wind a right 'k'
Wallet address 1GAEbiUxnxrVfusm4RZeucuVPLqiVorpaD


BUT ! Code must be implemented in LOGO.
http://en.wikipedia.org/wiki/Logo_(programming_language)

[Tonka Branded Truck]

I give my wallet password to someone who will wind a right 'k'
Wallet address 1GAEbiUxnxrVfusm4RZeucuVPLqiVorpaD


BUT ! Code must be implemented in LOGO.
http://en.wikipedia.org/wiki/Logo_(programming_language)

Your wallet is empty.