[quote name=“wrapper” post=“55370” timestamp=“1390788543”]
From the 18th to the 27th January the Litecoin Hash rate has reduced drastically from 120 to 60 GHash/s.
This has left the difficulty at a rate equivelent to 114 GHash/s. Thus punishing loyal Litecoin miners by leaving the difficulty twice as high as it should be.
https://coinplorer.com/Charts/Difficulty/LTC
[/quote]
doesn’t it auto retarget the difficulty?
[quote name=“wrapper” post=“54971” timestamp=“1390665492”]
I also cannot understand why our hash rate has gone down?. I note the varying hash is being used? is it being combined with pool DDoS? to drive down the Difficulty?
https://coinplorer.com/Charts/Difficulty/FTC
[/quote]
coin hopping pools.
Previously when I mine at give-me-coins, I am only averaging at 20-30 FTC daily.
I am getting 55-80 right now depending on the price, by exchanging the Bitcoins earned for FTC.
Same thing happening to Darkcoin price now loll…
I’m glad I bought 2k of it when it was at 0.001
http://www.meetup.com/BitcoinSingapore/events/161199572/
a little off topic, but any Feathercoin community going to this Bitcoin meetup in Singapore? :-*
We can pop by and say hi ;D
Wish I can attend >:(
I’m like 17403.7 km away from the UK ???
BIP38 is a ridiculously tough encryption, it is also memory intensive!
I tried bruteforcing one a few days back with a C# implementation and it takes 0.25 seconds to decrypt one on a fourth generation quad core i5 processor. Memory usage = 300MB. Despite my best effort to optimize the code… (100% CPU utilization).
Having a password of at least 6 character will ensure that it’ll take 8000 years on a single machine. (72 ^ 6 tries)
Great! I support that since its safe.
public Exception DecryptWithPassphrase(string passphrase) {
// check for null entry
if (passphrase == null || passphrase == "") {
return new ArgumentException("Passphrase is required");
}
Bip38Intermediate intermediate = new Bip38Intermediate(passphrase, _ownerentropy, LotSequencePresent);
// derive the 64 bytes we need
// get ECPoint from passpoint
PublicKey pk = new PublicKey(intermediate.passpoint);
byte[] addresshashplusownerentropy = Util.ConcatenateByteArrays(_addressHash, intermediate.ownerentropy);
// derive encryption key material
byte[] derived = new byte[64];
SCrypt.ComputeKey(intermediate.passpoint, addresshashplusownerentropy, 1024, 1, 1, 1, derived);
byte[] derivedhalf2 = new byte[32];
Array.Copy(derived, 32, derivedhalf2, 0, 32);
byte[] unencryptedpubkey = new byte[33];
// recover the 0x02 or 0x03 prefix
unencryptedpubkey[0] = (byte)(_encryptedpointb[0] ^ (derived[63] & 0x01));
// decrypt
var aes = Aes.Create();
aes.KeySize = 256;
aes.Mode = CipherMode.ECB;
aes.Key = derivedhalf2;
ICryptoTransform decryptor = aes.CreateDecryptor();
decryptor.TransformBlock(_encryptedpointb, 1, 16, unencryptedpubkey, 1);
decryptor.TransformBlock(_encryptedpointb, 1, 16, unencryptedpubkey, 1);
decryptor.TransformBlock(_encryptedpointb, 1 + 16, 16, unencryptedpubkey, 17);
decryptor.TransformBlock(_encryptedpointb, 1 + 16, 16, unencryptedpubkey, 17);
// xor out the padding
for (int i = 0; i < 32; i++) unencryptedpubkey[i + 1] ^= derived[i];
// reconstitute the ECPoint
var ps = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
ECPoint point;
try {
point = ps.Curve.DecodePoint(unencryptedpubkey);
// multiply passfactor. Result is going to be compressed.
ECPoint pubpoint = point.Multiply(new BigInteger(1, intermediate.passfactor));
// Do we want it uncompressed? then we will have to uncompress it.
if (IsCompressedPoint==false) {
pubpoint = ps.Curve.CreatePoint(pubpoint.X.ToBigInteger(), pubpoint.Y.ToBigInteger(), false);
}
// Convert to bitcoin address and check address hash.
PublicKey generatedaddress = new PublicKey(pubpoint);
// get addresshash
UTF8Encoding utf8 = new UTF8Encoding(false);
Sha256Digest sha256 = new Sha256Digest();
byte[] generatedaddressbytes = utf8.GetBytes(generatedaddress.AddressBase58);
sha256.BlockUpdate(generatedaddressbytes, 0, generatedaddressbytes.Length);
byte[] addresshashfull = new byte[32];
sha256.DoFinal(addresshashfull, 0);
sha256.BlockUpdate(addresshashfull, 0, 32);
sha256.DoFinal(addresshashfull, 0);
for (int i = 0; i < 4; i++) {
if (addresshashfull[i] != _addressHash[i]) {
return new ArgumentException("This passphrase is wrong or does not belong to this confirmation code.");
}
}
this.PublicKey = generatedaddress;
} catch {
return new ArgumentException("This passphrase is wrong or does not belong to this confirmation code.");
}
return null;
}
}
#region Bruteforce
/* An array containing the characters which will be used to create the brute force keys,
* if less characters are used (e.g. only lower case chars) the faster the password is matched */
private static char[] charactersToTest =
{
'1','2','3','4','5','6','7','8','9','0',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E',
'F','G','H','I','J','K','L','M','N','O','P','Q','R',
'S','T','U','V','W','X','Y','Z','!','$','#','@','-'
};
/* The length of the charactersToTest Array is stored in a
* additional variable to increase performance */
private static int charactersToTestLength = charactersToTest.Length;
private static long computedKeys = 0;
private bool passFound = false;
private string pass = null;
private string currentComputingPass = "";
private System.Windows.Forms.Timer updateTimer;
private void button_bruteforcePrivKey_Click(object sender, EventArgs e)
{
// Disable button
button_bruteforcePrivKey.Enabled = false;
// Referencing
string privateKey = txtPrivWIF.Text; // 6PfR1Z9cEHVsHaQTzggoaZmEeQVQAqPbR6A5gd3Eop3JBTZ9oQLUi7hShs
passFound = false;
pass = null;
currentComputingPass = "";
int threads = 10;
int.TryParse(textBox_threads.Text, out threads);
if (updateTimer != null)
{
updateTimer.Stop();
updateTimer = null;
}
updateTimer = new System.Windows.Forms.Timer();
updateTimer.Interval = 100;
updateTimer.Tick += updateTimer_Tick;
updateTimer.Start();
try
{
object interpretation = StringInterpreter.Interpret(privateKey, compressed: compressToolStripMenuItem.Checked, addressType: this.AddressTypeByte);
if (interpretation is PassphraseKeyPair)
{
string passPhrase = txtPassphrase.Text;
PassphraseKeyPair ppkp = (PassphraseKeyPair)interpretation;
Task.Run(() =>
{
startBruteForce(6, ppkp);
});
}
}
catch (Exception ae)
{
MessageBox.Show(ae.Message);
}
finally
{
}
}
void updateTimer_Tick(object sender, EventArgs e)
{
label_tries.Text = computedKeys.ToString();
label_bruteforcetxt.Text = currentComputingPass;
if (pass != null)
{
txtPassphrase.Text = pass;
}
}
///
/// Starts the recursive method which will create the keys via brute force
///
/// The length of the key
private void startBruteForce(int keyLength, PassphraseKeyPair ppkp)
{
var keyChars = createCharArray(keyLength, charactersToTest[0]);
// The index of the last character will be stored for slight perfomance improvement
var indexOfLastChar = keyLength - 1;
createNewKey(0, keyChars, keyLength, indexOfLastChar, ppkp);
}
///
/// Creates a new char array of a specific length filled with the defaultChar
///
/// The length of the array
/// The char with whom the array will be filled
///
private char[] createCharArray(int length, char defaultChar)
{
return (from c in new char[length] select defaultChar).ToArray();
}
///
/// This is the main workhorse, it creates new keys and compares them to the password until the password
/// is matched or all keys of the current key length have been checked
///
/// The position of the char which is replaced by new characters currently
/// The current key represented as char array
/// The length of the key
/// The index of the last character of the key
private void createNewKey(int currentCharPosition, char[] keyChars, int keyLength, int indexOfLastChar, PassphraseKeyPair ppkp)
{
int tryingNumber = 0;
var nextCharPosition = currentCharPosition + 1;
// We are looping trough the full length of our charactersToTest array
for (int i = 0; i < charactersToTestLength; i++)
{
/* The character at the currentCharPosition will be replaced by a
* new character from the charactersToTest array => a new key combination will be created */
keyChars[currentCharPosition] = charactersToTest[i];
// The method calls itself recursively until all positions of the key char array have been replaced
if (currentCharPosition < indexOfLastChar)
{
createNewKey(nextCharPosition, keyChars, keyLength, indexOfLastChar, ppkp);
}
else
{
// A new key has been created, remove this counter to improve performance
computedKeys++;
string txt = new String(keyChars);
while (tryingNumber > 4)
{
Thread.Sleep(10);
}
tryingNumber++;
Task.Run(() =>
{
/* The char array will be converted to a string and compared to the password. If the password
* is matched the loop breaks and the password is stored as result. */
currentComputingPass = txt;
System.Diagnostics.Debug.WriteLine(txt);
if (ppkp.DecryptWithPassphrase(txt))
{
if (!passFound)
{
passFound = true;
pass = txt;
}
}
tryingNumber--;
});
if (passFound)
return;
}
}
}
#endregion
Interesting project, drop me a PM if you are looking for a Windows Phone/Windows 8 version.
I have been developing for both platform since 2011 and 2012.
http://apps.microsoft.com/webpdp/app/d0441683-afe2-4895-98d6-d9a0492482fa
Okay, its on Windows 8.1 now. I’m working to get it on Google Play, App Store and Windows Phone store…
Play the all NEW shooter game with a twist from the Mt. Gox saga in the Bitcoin world!
A continuous shooter game with a twist of the bankruptcy saga that played out during January to March 2014. The definition of ‘Goxxed’ derived from Mt. Gox, one of the biggest Bitcoin exchange website since the existence of Bitcoin on 2009. Goxxed is the act of being screwed by an online merchant, specifically due to the merchant being incompetent and amateurish. Derived from the debacle of the http://mtgox.com Bitcoin trading site’s crash and burn, resulting in chaos while they are in the midst of re-opening it.
It all boils down to poor communication, outright lies, & scapegoats.This game will never have an ending, but it just gets harder and harder as the player gets ‘goxxed’ along the way while the Bitcoins are being collected/farmed.
Lol. I am still bag holding 100k FTC, not too worried though.
Its only a matter of time before all alts are pumped when BTC maxed out. Similar to how all the “hot money” from US momentary policy spilled worldwide.
buy, wait til the BTC bubble burst before getting in
Same thing happening to Darkcoin price now loll…
I’m glad I bought 2k of it when it was at 0.001
Its fine :) Don’t worry about it. Thanks anyway!
Alright, since I’m working on a new game for Android, iOS, Windows 8 & Windows Phone AND I have lost 77 Bitcoins to Mark Karpeles asshole.
Here goes…
http://maaapersonalppace.azurewebsites.net/Games/Goxxed/ (Require a HTML5 enabled browser. Chrome, FF, Sound doesn’t play on IE11 for now, I’m looking for a fix as .wav format is way too big)
Have a laugh! and enjoy. LOL
This is still under development… but soon to be completed.
I still remember the days of “ltc on gox”, “ltc on Bitstamp once its on gox” lol.
lulz again… product first, not pre-order or I say its a scam/
Every single alt coin are losing its valuation right now (together with Bitcoin).
If you are looking for a profit, wait till the next Bitcoin pump when the ratio against BTC gets wider before trading your BTC for FTC. Then wait for FTC pump before trading back again…
See the historical trend on BTC and FTC back in November ~ Feb and you’ll get what I mean :)