Installing bitcoin-mining-proxy

THIS IS HOW WE CONNECT YOU WITH OUR UNKNOWN MINING POOL .

Requirements

• Apache (2.2 or newer recommended).
• PHP 5.3 or newer.
• MySQL (5.1 or newer recommended for best performance).
• Device Doesnot Matter . Connect with api Directly So that android & Others Device also can join

There are some PHP options set in htdocs/.htaccess. These settings must be set for the proxy to function correctly. If you get an HTTP 500 error, your web server might not allow altering PHP options from .htaccess files. In this case, make sure that the settings are properly changed either in your php.ini or Apache configuration, then remove or comment out the PHP-related options in htdocs/.htaccess.

Setting up the database

bitcoin-mining-proxy currently requires a MySQL database server. (PostgreSQL may be supported in a future release.)

Perform the following steps to set up the database:

1. Create a database for the proxy.
2. Create a MySQL user for the proxy, giving it the privileges SELECT, INSERT, UPDATE, DELETE, and LOCK TABLES on the proxy's database only. (Optional, but recommended.)
3. Import the schema file at database/schema.sql into the database by using either the mysql command-line tool or another front-end like phpMyAdmin.

Configuring the proxy

1. Copy htdocs/config.inc.php.sample to htdocs/config.inc.php.
2. Overwrite the sample database information with your real database information.
3. Set the admin user and password. This will be used when logging in to the web management console.
4. Set the site URI; this is the URI the mining proxy will be reachable from. If you install directly into your web root, the default value '/' is correct.

Setting up the web server

bitcoin-mining-proxy only requires a web server that can run PHP scripts. Just point your web root at the htdocs folder and everything should be all set.

These scripts require that the magic_quotes_gpc PHP flag be disabled. The included .htaccess file will take care of this automatically if your configuration allows PHP flags to be changed from .htaccess files.

Note that while you can install to a subdirectory, some miners do not support this! These miners only accept a host and port, but not a path. You will have to use htdocs as the web root in order for these miners to work.

Setting up the proxy

Navigate your browser to the admin directory inside the htdocs folder. So if you installed at http://www.example.com/ then you would go to http://www.example.com/admin/. You will be asked to authenticate; enter the admin credentials you put in htdocs/config.inc.php.

The first thing you will want to do is add all the pools you will be using. Click the "pools" link and then the "new pool" button. Enter a name for the pool (this is for display purposes only) and the pool's URL. Do not enter login credentials as part of the URL; pool credentials are managed elsewhere. So to use luke-jr's pool, for example, you would enter http://pool.bitcoin.dashjr.org:8337, omitting your Bitcoin address. Check the enabled checkbox and save the pool. Repeat this for all the other pools you will be using.

Now set up some worker accounts. You should use a different worker account for each instance of mining software you are running. This will allow you to remotely administrate their pool assignments separately, as well as determine which miners are not operating correctly. If you used one account for several workers, they would be treated as one distinct miner by the proxy and information about them will be aggregated, and usually you don't want that.

Once you have all your worker accounts set up, you need to associate workers with the pools you want them to work on. Click the "manage pools" button next to a worker. You will see a list of all your pools; each will have a "create pool assignment" button. After clicking it, you will be asked for details about the assignment:

• Priority: This field is used to order the pool assignemnts. If you have multiple enabled assignments for a worker, the one with the highest priority will be tried first. If it is unreachable or returns an error, the assignment with the next-highest priority will be tried, and so on. If all pools cannot be queried for work, an error will be returned to the worker. If two assignments have the same priority, the order in which they will be tried is undefined.
• Enabled: Check this box to enable the assignment. If an assignment is not enabled, the proxy will skip that pool when the worker asks for work.
• Pool username/password: The worker's authentication information for the pool. If you are mining on a pool that requires or supports different worker accounts for each worker (like slush's pool and deepbit) you can enter different information here. If all the workers will share credentials, you will have to enter the credentials for each assignment.

You do not have to assign each worker to every pool if you don't want to. Unassigned pools will simply be ignored.

At this point you should be able to point your workers at the proxy and they will start working. You can verify this by watching the "Worker status" section on the dashboard.

Quick pool toggling

In the pool list you will see a red or green flag for each pool indicating whether it is enabled. You can click the flag to quickly toggle the status of the pool. This will globally disable the pool for all workers. Disabled pools will have a red background.

In the pool assignment list for specific workers, there are two flags; one for the pool and one for the specific assignment. You can click the flag for the assignment to quickly toggle the assignment on or off. This will affect only the worker you are managing. You cannot click the pool's flag. This is to prevent a pool from being accidentally disabled globally. Rows with a red background indicate that the worker will not request work from this pool -- in other words, if either the pool or the assignment are disabled.

Note that disabling a pool or assignment will not prevent any shares from being submitted if the worker is currently working that pool. It will affect new work requests only. So you can safely disable a pool while your miners are running and they will finish their current work, switching over to the next pool in the list on their next getwork request.

Long polling support

bitcoin-mining-proxy supports long polling servers. It will rewrite any long polling URL received from a pool so that the long polling request passes through the proxy.

There is one caveat: if the pool is disabled while a worker has an outstanding long poll request, it may not notice this, depending on the logic in the client! This means that the client will effectively be working without long polling against its new pool until its outstanding request returns. At that point it may begin working on the work returned in the long poll request, which will be for the disabled pool! This is ok; the work submissions will be correctly routed back to the now-disabled pool.

This problem may be fixed in a future release by having the long-polling code check the database every few seconds to make sure that the pool and assignment it is proxying for are still enabled, returning early with an error code if it finds either to be disabled.

Database maintenance

You should not have to do very much to maintain the database, but you may need to delete some data occasionally. The work_data table is likely to grow quite large if left alone. Depending on how many miners you are running and what their request rate is, you may need to clean out this table as often as once a week. You can use the following query to do so:

DELETE FROM `work_data` WHERE DATEDIFF(UTC_TIMESTAMP(), `time_requested`) > 0

Note that this will cause some stats to disappear; for example, if one of your workers has not been operating since midnight UTC, it will show as never having requested work on the dashboard. Do not simply truncate the table; if you do this while your miners are working, the proxy will be unable to route share submissions back to their correct pool.

If the submitted_work table is growing too large, you can execute a similar query to clean it out:

DELETE FROM `submitted_work` WHERE DATEDIFF(UTC_TIMESTAMP(), `time`) > 7

You may truncate this table if you wish since the miners do not depend on it to request work. It is an informational table only. However, keeping a week or two's worth of data around is a good idea in case you need to report a statistical discrepancy to a pool operator. It's always good to have logs.

The proxy may at some point be able to purge old data periodically by itself. In the meantime, you will have to do so manually.

Upgrading

When upgrading the proxy software, make sure to inspect any changes to htdocs/config.inc.php.sample and apply them (with customizations) as needed to your local configuration. Failure to do this might result in errant behavior.

You may additionally need to upgrade the database schema. To do this, feed the database/migrate.sql file to the database, either using something like phpMyAdmin or the mysql command-line client:

mysql -p -u user-name database-name < database/migrate.sql

This script will apply any schema changes to your existing database safely. When run against a database with the latest version of the schema, it will do nothing.

RAW MODULE FOR DEVELOPER

This file was originally written by Colin Percival as part of the Tarsnap

 * online backup system.

 */

#include "scrypt.h"

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

static inline uint32_t

be32dec(const void *pp)

{

const uint8_t *p = (uint8_t const *)pp;

return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +

    ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));

}

static inline void

be32enc(void *pp, uint32_t x)

{

uint8_t * p = (uint8_t *)pp;

p[3] = x & 0xff;

p[2] = (x >> 8) & 0xff;

p[1] = (x >> 16) & 0xff;

p[0] = (x >> 24) & 0xff;

}

static inline uint32_t

le32dec(const void *pp)

{

const uint8_t *p = (uint8_t const *)pp;

return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +

    ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));

}

static inline void

le32enc(void *pp, uint32_t x)

{

uint8_t * p = (uint8_t *)pp;

p[0] = x & 0xff;

p[1] = (x >> 8) & 0xff;

p[2] = (x >> 16) & 0xff;

p[3] = (x >> 24) & 0xff;

}

typedef struct SHA256Context {

uint32_t state[8];

uint32_t count[2];

unsigned char buf[64];

} SHA256_CTX;

typedef struct HMAC_SHA256Context {

SHA256_CTX ictx;

SHA256_CTX octx;

} HMAC_SHA256_CTX;

/*

 * Encode a length len/4 vector of (uint32_t) into a length len vector of

 * (unsigned char) in big-endian form.  Assumes len is a multiple of 4.

 */

static void

be32enc_vect(unsigned char *dst, const uint32_t *src, size_t len)

{

size_t i;

for (i = 0; i < len / 4; i++)

be32enc(dst + i * 4, src[i]);

}

/*

 * Decode a big-endian length len vector of (unsigned char) into a length

 * len/4 vector of (uint32_t).  Assumes len is a multiple of 4.

 */

static void

be32dec_vect(uint32_t *dst, const unsigned char *src, size_t len)

{

size_t i;

for (i = 0; i < len / 4; i++)

dst[i] = be32dec(src + i * 4);

}

/* Elementary functions used by SHA256 */

#define Ch(x, y, z) ((x & (y ^ z)) ^ z)

#define Maj(x, y, z) ((x & (y | z)) | (y & z))

#define SHR(x, n) (x >> n)

#define ROTR(x, n) ((x >> n) | (x << (32 - n)))

#define S0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))

#define S1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))

#define s0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))

#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))

/* SHA256 round function */

#define RND(a, b, c, d, e, f, g, h, k) \

t0 = h + S1(e) + Ch(e, f, g) + k; \

t1 = S0(a) + Maj(a, b, c); \

d += t0; \

h  = t0 + t1;

/* Adjusted round function for rotating state */

#define RNDr(S, W, i, k) \

RND(S[(64 - i) % 8], S[(65 - i) % 8], \

    S[(66 - i) % 8], S[(67 - i) % 8], \

    S[(68 - i) % 8], S[(69 - i) % 8], \

    S[(70 - i) % 8], S[(71 - i) % 8], \

    W[i] + k)

/*

 * SHA256 block compression function.  The 256-bit state is transformed via

 * the 512-bit input block to produce a new state.

 */

static void

SHA256_Transform(uint32_t * state, const unsigned char block[64])

{

uint32_t W[64];

uint32_t S[8];

uint32_t t0, t1;

int i;

/* 1. Prepare message schedule W. */

be32dec_vect(W, block, 64);

for (i = 16; i < 64; i++)

W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];

/* 2. Initialize working variables. */

memcpy(S, state, 32);

/* 3. Mix. */

RNDr(S, W, 0, 0x428a2f98);

RNDr(S, W, 1, 0x71374491);

RNDr(S, W, 2, 0xb5c0fbcf);

RNDr(S, W, 3, 0xe9b5dba5);

RNDr(S, W, 4, 0x3956c25b);

RNDr(S, W, 5, 0x59f111f1);

RNDr(S, W, 6, 0x923f82a4);

RNDr(S, W, 7, 0xab1c5ed5);

RNDr(S, W, 8, 0xd807aa98);

RNDr(S, W, 9, 0x12835b01);

RNDr(S, W, 10, 0x243185be);

RNDr(S, W, 11, 0x550c7dc3);

RNDr(S, W, 12, 0x72be5d74);

RNDr(S, W, 13, 0x80deb1fe);

RNDr(S, W, 14, 0x9bdc06a7);

RNDr(S, W, 15, 0xc19bf174);

RNDr(S, W, 16, 0xe49b69c1);

RNDr(S, W, 17, 0xefbe4786);

RNDr(S, W, 18, 0x0fc19dc6);

RNDr(S, W, 19, 0x240ca1cc);

RNDr(S, W, 20, 0x2de92c6f);

RNDr(S, W, 21, 0x4a7484aa);

RNDr(S, W, 22, 0x5cb0a9dc);

RNDr(S, W, 23, 0x76f988da);

RNDr(S, W, 24, 0x983e5152);

RNDr(S, W, 25, 0xa831c66d);

RNDr(S, W, 26, 0xb00327c8);

RNDr(S, W, 27, 0xbf597fc7);

RNDr(S, W, 28, 0xc6e00bf3);

RNDr(S, W, 29, 0xd5a79147);

RNDr(S, W, 30, 0x06ca6351);

RNDr(S, W, 31, 0x14292967);

RNDr(S, W, 32, 0x27b70a85);

RNDr(S, W, 33, 0x2e1b2138);

RNDr(S, W, 34, 0x4d2c6dfc);

RNDr(S, W, 35, 0x53380d13);

RNDr(S, W, 36, 0x650a7354);

RNDr(S, W, 37, 0x766a0abb);

RNDr(S, W, 38, 0x81c2c92e);

RNDr(S, W, 39, 0x92722c85);

RNDr(S, W, 40, 0xa2bfe8a1);

RNDr(S, W, 41, 0xa81a664b);

RNDr(S, W, 42, 0xc24b8b70);

RNDr(S, W, 43, 0xc76c51a3);

RNDr(S, W, 44, 0xd192e819);

RNDr(S, W, 45, 0xd6990624);

RNDr(S, W, 46, 0xf40e3585);

RNDr(S, W, 47, 0x106aa070);

RNDr(S, W, 48, 0x19a4c116);

RNDr(S, W, 49, 0x1e376c08);

RNDr(S, W, 50, 0x2748774c);

RNDr(S, W, 51, 0x34b0bcb5);

RNDr(S, W, 52, 0x391c0cb3);

RNDr(S, W, 53, 0x4ed8aa4a);

RNDr(S, W, 54, 0x5b9cca4f);

RNDr(S, W, 55, 0x682e6ff3);

RNDr(S, W, 56, 0x748f82ee);

RNDr(S, W, 57, 0x78a5636f);

RNDr(S, W, 58, 0x84c87814);

RNDr(S, W, 59, 0x8cc70208);

RNDr(S, W, 60, 0x90befffa);

RNDr(S, W, 61, 0xa4506ceb);

RNDr(S, W, 62, 0xbef9a3f7);

RNDr(S, W, 63, 0xc67178f2);

/* 4. Mix local working variables into global state */

for (i = 0; i < 8; i++)

state[i] += S[i];

/* Clean the stack. */

memset(W, 0, 256);

memset(S, 0, 32);

t0 = t1 = 0;

}

static unsigned char PAD[64] = {

0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

/* SHA-256 initialization.  Begins a SHA-256 operation. */

static void

SHA256_Init(SHA256_CTX * ctx)

{

/* Zero bits processed so far */

ctx->count[0] = ctx->count[1] = 0;

/* Magic initialization constants */

ctx->state[0] = 0x6A09E667;

ctx->state[1] = 0xBB67AE85;

ctx->state[2] = 0x3C6EF372;

ctx->state[3] = 0xA54FF53A;

ctx->state[4] = 0x510E527F;

ctx->state[5] = 0x9B05688C;

ctx->state[6] = 0x1F83D9AB;

ctx->state[7] = 0x5BE0CD19;

}

/* Add bytes into the hash */

static void

SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)

{

uint32_t bitlen[2];

uint32_t r;

const unsigned char *src = in;

/* Number of bytes left in the buffer from previous updates */

r = (ctx->count[1] >> 3) & 0x3f;

/* Convert the length into a number of bits */

bitlen[1] = ((uint32_t)len) << 3;

bitlen[0] = (uint32_t)(len >> 29);

/* Update number of bits */

if ((ctx->count[1] += bitlen[1]) < bitlen[1])

ctx->count[0]++;

ctx->count[0] += bitlen[0];

/* Handle the case where we don't need to perform any transforms */

if (len < 64 - r) {

memcpy(&ctx->buf[r], src, len);

return;

}

/* Finish the current block */

memcpy(&ctx->buf[r], src, 64 - r);

SHA256_Transform(ctx->state, ctx->buf);

src += 64 - r;

len -= 64 - r;

/* Perform complete blocks */

while (len >= 64) {

SHA256_Transform(ctx->state, src);

src += 64;

len -= 64;

}

/* Copy left over data into buffer */

memcpy(ctx->buf, src, len);

}

/* Add padding and terminating bit-count. */

static void

SHA256_Pad(SHA256_CTX * ctx)

{

unsigned char len[8];

uint32_t r, plen;

/*

* Convert length to a vector of bytes -- we do this now rather

* than later because the length will change after we pad.

*/

be32enc_vect(len, ctx->count, 8);

/* Add 1--64 bytes so that the resulting length is 56 mod 64 */

r = (ctx->count[1] >> 3) & 0x3f;

plen = (r < 56) ? (56 - r) : (120 - r);

SHA256_Update(ctx, PAD, (size_t)plen);

/* Add the terminating bit-count */

SHA256_Update(ctx, len, 8);

}

/*

 * SHA-256 finalization.  Pads the input data, exports the hash value,

 * and clears the context state.

 */

static void

SHA256_Final(unsigned char digest[32], SHA256_CTX * ctx)

{

/* Add padding */

SHA256_Pad(ctx);

/* Write the hash */

be32enc_vect(digest, ctx->state, 32);

/* Clear the context state */

memset((void *)ctx, 0, sizeof(*ctx));

}

/* Initialize an HMAC-SHA256 operation with the given key. */

static void

HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)

{

unsigned char pad[64];

unsigned char khash[32];

const unsigned char * K = _K;

size_t i;

/* If Klen > 64, the key is really SHA256(K). */

if (Klen > 64) {

SHA256_Init(&ctx->ictx);

SHA256_Update(&ctx->ictx, K, Klen);

SHA256_Final(khash, &ctx->ictx);

K = khash;

Klen = 32;

}

/* Inner SHA256 operation is SHA256(K xor [block of 0x36] || data). */

SHA256_Init(&ctx->ictx);

memset(pad, 0x36, 64);

for (i = 0; i < Klen; i++)

pad[i] ^= K[i];

SHA256_Update(&ctx->ictx, pad, 64);

/* Outer SHA256 operation is SHA256(K xor [block of 0x5c] || hash). */

SHA256_Init(&ctx->octx);

memset(pad, 0x5c, 64);

for (i = 0; i < Klen; i++)

pad[i] ^= K[i];

SHA256_Update(&ctx->octx, pad, 64);

/* Clean the stack. */

memset(khash, 0, 32);

}

/* Add bytes to the HMAC-SHA256 operation. */

static void

HMAC_SHA256_Update(HMAC_SHA256_CTX * ctx, const void *in, size_t len)

{

/* Feed data to the inner SHA256 operation. */

SHA256_Update(&ctx->ictx, in, len);

}

/* Finish an HMAC-SHA256 operation. */

static void

HMAC_SHA256_Final(unsigned char digest[32], HMAC_SHA256_CTX * ctx)

{

unsigned char ihash[32];

/* Finish the inner SHA256 operation. */

SHA256_Final(ihash, &ctx->ictx);

/* Feed the inner hash to the outer SHA256 operation. */

SHA256_Update(&ctx->octx, ihash, 32);

/* Finish the outer SHA256 operation. */

SHA256_Final(digest, &ctx->octx);

/* Clean the stack. */

memset(ihash, 0, 32);

}

/**

 * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):

 * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and

 * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).

 */

static void

PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,

    size_t saltlen, uint64_t c, uint8_t * buf, size_t dkLen)

{

HMAC_SHA256_CTX PShctx, hctx;

size_t i;

uint8_t ivec[4];

uint8_t U[32];

uint8_t T[32];

uint64_t j;

int k;

size_t clen;

/* Compute HMAC state after processing P and S. */

HMAC_SHA256_Init(&PShctx, passwd, passwdlen);

HMAC_SHA256_Update(&PShctx, salt, saltlen);

/* Iterate through the blocks. */

for (i = 0; i * 32 < dkLen; i++) {

/* Generate INT(i + 1). */

be32enc(ivec, (uint32_t)(i + 1));

/* Compute U_1 = PRF(P, S || INT(i)). */

memcpy(&hctx, &PShctx, sizeof(HMAC_SHA256_CTX));

HMAC_SHA256_Update(&hctx, ivec, 4);

HMAC_SHA256_Final(U, &hctx);

/* T_i = U_1 ... */

memcpy(T, U, 32);

for (j = 2; j <= c; j++) {

/* Compute U_j. */

HMAC_SHA256_Init(&hctx, passwd, passwdlen);

HMAC_SHA256_Update(&hctx, U, 32);

HMAC_SHA256_Final(U, &hctx);

/* ... xor U_j ... */

for (k = 0; k < 32; k++)

T[k] ^= U[k];

}

/* Copy as many bytes as necessary into buf. */

clen = dkLen - i * 32;

if (clen > 32)

clen = 32;

memcpy(&buf[i * 32], T, clen);

}

/* Clean PShctx, since we never called _Final on it. */

memset(&PShctx, 0, sizeof(HMAC_SHA256_CTX));

}

static void blkcpy(void *, void *, size_t);

static void blkxor(void *, void *, size_t);

static void salsa20_8(uint32_t[16]);

static void blockmix_salsa8(uint32_t *, uint32_t *, uint32_t *, size_t);

static uint64_t integerify(void *, size_t);

static void smix(uint8_t *, size_t, uint64_t, uint32_t *, uint32_t *);

static void

blkcpy(void * dest, void * src, size_t len)

{

size_t * D = dest;

size_t * S = src;

size_t L = len / sizeof(size_t);

size_t i;

for (i = 0; i < L; i++)

D[i] = S[i];

}

static void

blkxor(void * dest, void * src, size_t len)

{

size_t * D = dest;

size_t * S = src;

size_t L = len / sizeof(size_t);

size_t i;

for (i = 0; i < L; i++)

D[i] ^= S[i];

}

/**

 * salsa20_8(B):

 * Apply the salsa20/8 core to the provided block.

 */

static void

salsa20_8(uint32_t B[16])

{

uint32_t x[16];

size_t i;

blkcpy(x, B, 64);

for (i = 0; i < 8; i += 2) {

#define R(a,b) (((a) << (b)) | ((a) >> (32 - (b))))

/* Operate on columns. */

x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);

x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);

x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);

x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);

x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);

x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);

x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);

x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);

/* Operate on rows. */

x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);

x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);

x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);

x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);

x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);

x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);

x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);

x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);

#undef R

}

for (i = 0; i < 16; i++)

B[i] += x[i];

}

/**

 * blockmix_salsa8(Bin, Bout, X, r):

 * Compute Bout = BlockMix_{salsa20/8, r}(Bin).  The input Bin must be 128r

 * bytes in length; the output Bout must also be the same size.  The

 * temporary space X must be 64 bytes.

 */

static void

blockmix_salsa8(uint32_t * Bin, uint32_t * Bout, uint32_t * X, size_t r)

{

size_t i;

/* 1: X <-- B_{2r - 1} */

blkcpy(X, &Bin[(2 * r - 1) * 16], 64);

/* 2: for i = 0 to 2r - 1 do */

for (i = 0; i < 2 * r; i += 2) {

/* 3: X <-- H(X \xor B_i) */

blkxor(X, &Bin[i * 16], 64);

salsa20_8(X);

/* 4: Y_i <-- X */

/* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */

blkcpy(&Bout[i * 8], X, 64);

/* 3: X <-- H(X \xor B_i) */

blkxor(X, &Bin[i * 16 + 16], 64);

salsa20_8(X);

/* 4: Y_i <-- X */

/* 6: B' <-- (Y_0, Y_2 ... Y_{2r-2}, Y_1, Y_3 ... Y_{2r-1}) */

blkcpy(&Bout[i * 8 + r * 16], X, 64);

}

}

/**

 * integerify(B, r):

 * Return the result of parsing B_{2r-1} as a little-endian integer.

 */

static uint64_t

integerify(void * B, size_t r)

{

uint32_t * X = (void *)((uintptr_t)(B) + (2 * r - 1) * 64);

return (((uint64_t)(X[1]) << 32) + X[0]);

}

/**

 * smix(B, r, N, V, XY):

 * Compute B = SMix_r(B, N).  The input B must be 128r bytes in length;

 * the temporary storage V must be 128rN bytes in length; the temporary

 * storage XY must be 256r + 64 bytes in length.  The value N must be a

 * power of 2 greater than 1.  The arrays B, V, and XY must be aligned to a

 * multiple of 64 bytes.

 */

static void

smix(uint8_t * B, size_t r, uint64_t N, uint32_t * V, uint32_t * XY)

{

uint32_t * X = XY;

uint32_t * Y = &XY[32 * r];

uint32_t * Z = &XY[64 * r];

uint64_t i;

uint64_t j;

size_t k;

/* 1: X <-- B */

for (k = 0; k < 32 * r; k++)

X[k] = le32dec(&B[4 * k]);

/* 2: for i = 0 to N - 1 do */

for (i = 0; i < N; i += 2) {

/* 3: V_i <-- X */

blkcpy(&V[i * (32 * r)], X, 128 * r);

/* 4: X <-- H(X) */

blockmix_salsa8(X, Y, Z, r);

/* 3: V_i <-- X */

blkcpy(&V[(i + 1) * (32 * r)], Y, 128 * r);

/* 4: X <-- H(X) */

blockmix_salsa8(Y, X, Z, r);

}

/* 6: for i = 0 to N - 1 do */

for (i = 0; i < N; i += 2) {

/* 7: j <-- Integerify(X) mod N */

j = integerify(X, r) & (N - 1);

/* 8: X <-- H(X \xor V_j) */

blkxor(X, &V[j * (32 * r)], 128 * r);

blockmix_salsa8(X, Y, Z, r);

/* 7: j <-- Integerify(X) mod N */

j = integerify(Y, r) & (N - 1);

/* 8: X <-- H(X \xor V_j) */

blkxor(Y, &V[j * (32 * r)], 128 * r);

blockmix_salsa8(Y, X, Z, r);

}

/* 10: B' <-- X */

for (k = 0; k < 32 * r; k++)

le32enc(&B[4 * k], X[k]);

}

/* cpu and memory intensive function to transform a 80 byte buffer into a 32 byte output

   scratchpad size needs to be at least 63 + (128 * r * p) + (256 * r + 64) + (128 * r * N) bytes

 */

void scrypt_1024_1_1_256_sp(const char* input, char* output, char* scratchpad)

{

uint8_t * B;

uint32_t * V;

uint32_t * XY;

uint32_t i;

const uint32_t N = 1024;

const uint32_t r = 1;

const uint32_t p = 1;

B = (uint8_t *)(((uintptr_t)(scratchpad) + 63) & ~ (uintptr_t)(63));

XY = (uint32_t *)(B + (128 * r * p));

V = (uint32_t *)(B + (128 * r * p) + (256 * r + 64));

/* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */

PBKDF2_SHA256((const uint8_t*)input, 80, (const uint8_t*)input, 80, 1, B, p * 128 * r);

/* 2: for i = 0 to p - 1 do */

for (i = 0; i < p; i++) {

/* 3: B_i <-- MF(B_i, N) */

smix(&B[i * 128 * r], r, N, V, XY);

}

/* 5: DK <-- PBKDF2(P, B, 1, dkLen) */

PBKDF2_SHA256((const uint8_t*)input, 80, B, p * 128 * r, 1, (uint8_t*)output, 32);

}

void scrypt_1024_1_1_256(const char* input, char* output)

{

char scratchpad[scrypt_scratchpad_size];

scrypt_1024_1_1_256_sp(input, output, scratchpad);

}