This message was too old and has been purged

[FiatKiller]

Sh&^! I ve got it

k  = 254634957345987934598347597261842936423946893247.

will I get the price?
please?

nope, because your solution is wrong:

Code:

=======================================================================
0x9772c99f2db406a441000d9288ba9cd7ed05e7a0ae02e09615b7cd39cb8b1cedL not matching 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798L

I got it!

55066263022277343669578718895168534326250603453777594175500187360389116729240

nope, not that I see - but thanks for scaring me  lol

[1714939386]

1714939386

[1714939386]

1714939386

[1714939386]

1714939386

[1714939386]

1714939386

[1714939386]

1714939386

[Kyraishi]

what is that k for ?

[serje]

what is that k for ?

If you find the K you will find the private key to the address written in that script!

so you can import that address to your wallet

unfortunately it has 0 BTC

[Skoupi]

Guys seriously,

OP is either drop dead idiot or just amuses himself with everyone around that tries to come up with a "solution".

[Kiki112]

4210

[serje]

4210

1893710265418723563212490

Guys this is not lotto!

you have to run the script from the first page and replace K with your number!

[serje]

Answer is either 47, 69,4371, 8331, 9832, 184833321, or 4532231082


My Bitcoin Address: 1MYpNKj25HRBFpv22YpuZsuz2zZHKBLUur

Thanks.

the number can be this long 115,792,089,237,316,195,423,570,985,008,690,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000

are you sure your answers are correct?

did you even bother checking them?

[FiatKiller]

EK, we need to confirm the looping code as I pointed out in my last post, otherwise we are REALLY
wasting time and even a 1000 years will not solve it.

Don't you need ppp=challenge.point in the loop for each new value of k?
Also, didn't you leave out the "k*" in the loop?

thanks

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())

[playcoders]

found!!!!!!! k=0x0

1ooo75KPdpQyJAGByr5Atm2S8H9DrrhyZ sent to me 1000BTC 

[andulolika]

This is posible to do only with computing power? Or you can do it by simply math.
Edit: if its a random number why don't simply use a bot starting with 1,2,3,4,5,......999,1000,1001....

[joksim299]

This is posible to do only with computing power? Or you can do it by simply math.
Edit: if its a random number why don't simply use a bot starting with 1,2,3,4,5,......999,1000,1001....

Read posts above.
Number can be from 1 to 2^256 it may take 1000 years to solve this in that way.

[Cryptofreak82]

All I can read in the scrpt is :

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

Sex and Ass?? Now how should I understand this?
Evil?

[roslinpl]

found!!!!!!! k=0x0

1ooo75KPdpQyJAGByr5Atm2S8H9DrrhyZ sent to me 1000BTC 

yes that is very nice!

payment sent !

tx https://blockchain.info/pl/tx/91b8f5b08f80d26e0189509aa9253aebd71954467dde27c3216cf22a7c099fe4

[playcoders]

found!!!!!!! k=0x0

1ooo75KPdpQyJAGByr5Atm2S8H9DrrhyZ sent to me 1000BTC 

yes that is very nice!

payment sent !

tx https://blockchain.info/pl/tx/91b8f5b08f80d26e0189509aa9253aebd71954467dde27c3216cf22a7c099fe4

lol funny 

[BlockChainLottery]

Using a python script is not a very efficient method of brute forcing it.
I have a feeling that a lot of total noobs are seriously thinking that it is possible this way.
Then again chance, randomness, and probabilities are very counter intuitive.
It is just not possible to grasp the numbers involved.

Does anybody know how much k's can be checked per second with that python script?

[roslinpl]

Using a python script is not a very efficient method of brute forcing it.
I have a feeling that a lot of total noobs are seriously thinking that it is possible this way.
Then again chance, randomness, and probabilities are very counter intuitive.
It is just not possible to grasp the numbers involved.

Does anybody know how much k's can be checked per second with that python script?

not a lot not enough to find one
hehehe

[roslinpl]

found!!!!!!! k=0x0

1ooo75KPdpQyJAGByr5Atm2S8H9DrrhyZ sent to me 1000BTC 

yes that is very nice!

payment sent !

tx https://blockchain.info/pl/tx/91b8f5b08f80d26e0189509aa9253aebd71954467dde27c3216cf22a7c099fe4

lol funny 

isn't ?
for me this was funny as well

kind regards!

[FiatKiller]

Using a python script is not a very efficient method of brute forcing it.
I have a feeling that a lot of total noobs are seriously thinking that it is possible this way.
Then again chance, randomness, and probabilities are very counter intuitive.
It is just not possible to grasp the numbers involved.

Does anybody know how much k's can be checked per second with that python script?

Winning the lottery is very unlikely also, but someone has to win eventually. If you use random numbers, the very next number chosen COULD be it. What the hell.  :-D  If you are checking a particular range and it's not in that range, then you are truly wasting time. The only shot you had was in picking that range and no way to know if it is correct beforehand.

I'm checking maybe 3 mill a day on one fast PC. But I'm still not convinced the code is correct since EK is not answering.

[BlockChainLottery]

Winning the lottery is very unlikely also, but someone has to win eventually. If you use random numbers, the very next number chosen COULD be it. ...

Sure, but you have to include the fact that the number space is huge. The number of tickets in a lottery are at least contained in a pool from which you know a winner is drawn. That is different than looking for a number in a huge range of integers.

Simple crude calculation:

2¹⁶⁰ bitcoin addresses
2 billion computers worldwide¹
3 million addresses checked per day on a computer²
2¹⁶⁰ / ( 2e9 * 3e6 * 365 ) = 667e27 years

Timeline:

big bang       sun was born          now             sun dies       existing stars burn out   you finding k       all matter evaporated
     |-------------|---------------|--------------|---------------|-----------------------|-----------------|
     0                 9.2e9            13.8e9             19e9                 1e15                         667e27                1e34

Entropy is a bitch.

[FiatKiller]

dreamkiller...  lol