func encodeBase58Check(val []byte) []byte {
const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
// payload
p := make([]byte, 1+len(val)) // version byte (0x00) + val
copy(p[1:], val)
h1 := sha256.Sum256(p)
h2 := sha256.Sum256(h1[:])
// value as []byte
v := make([]byte, len(p)+4) // payload + first 4 bytes of h2
copy(v, p)
copy(v[len(p):], h2[:4])
var res []byte
x := new(big.Int).SetBytes(v)
y := big.NewInt(58)
m, zero := new(big.Int), new(big.Int)
// convert to base58
for x.Cmp(zero) > 0 {
x, m = x.DivMod(x, y, m)
res = append(res, alphabet[m.Int64()])
}
// append '1' for each leading zero byte in value
for i := 0; v[i] == 0; i++ {
res = append(res, alphabet[0])
}
// reverse
for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
res[i], res[j] = res[j], res[i]
}
return res
}
func EncodeBase58(ba []byte) []byte {
if len(ba) == 0 {
return nil
}
// Expected size increase from base58 conversion is approximately 137%, use 138% to be safe
ri := len(ba) * 138 / 100
ra := make([]byte, ri+1)
x := new(big.Int).SetBytes(ba) // ba is big-endian
x.Abs(x)
y := big.NewInt(58)
m := new(big.Int)
for x.Sign() > 0 {
x, m = x.DivMod(x, y, m)
ra[ri] = base58[int32(m.Int64())]
ri--
}
// Leading zeroes encoded as base58 zeros
for i := 0; i < len(ba); i++ {
if ba[i] != 0 {
break
}
ra[ri] = '1'
ri--
}
return ra[ri+1:]
}
// Base58Encode encodes a byte slice to a modified base58 string.
func Base58Encode(b []byte, alphabet string) string {
x := new(big.Int)
x.SetBytes(b)
answer := make([]byte, 0)
for x.Cmp(bigZero) > 0 {
mod := new(big.Int)
x.DivMod(x, bigRadix, mod)
answer = append(answer, alphabet[mod.Int64()])
}
// leading zero bytes
for _, i := range b {
if i != 0 {
break
}
answer = append(answer, alphabet[0])
}
// reverse
alen := len(answer)
for i := 0; i < alen/2; i++ {
answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i]
}
return string(answer)
}
//Verify verifies the proof file server send.
func (sw *Swizzle) Verify(p Proof) (bool, error) {
proof, ok := p.(*SwizzleProof)
if !ok {
return false, errors.New("use SwizzleProof instance for proof")
}
var rhs big.Int
var dummy big.Int
ch := sw.lastChallenge
for i := 0; i < sw.chunks; i++ {
f, err := keyedPRFBig(sw.fKey, sw.prime, i)
if err != nil {
return false, err
}
v, err := keyedPRFBig(ch.Key, ch.Vmax, i)
if err != nil {
return false, err
}
rhs.Add(&rhs, dummy.Mul(v, f))
}
for j := 0; j < ch.Sectors; j++ {
alpha, err := keyedPRFBig(sw.alphaKey, sw.prime, j)
if err != nil {
return false, err
}
rhs.Add(&rhs, dummy.Mul(alpha, &proof.Mu[j]))
}
dummy.DivMod(&rhs, sw.prime, &rhs)
if proof.Sigma.Cmp(&rhs) == 0 {
return true, nil
}
return false, nil
}
// BigComma produces a string form of the given big.Int in base 10
// with commas after every three orders of magnitude.
func BigComma(b *big.Int) string {
sign := ""
if b.Sign() < 0 {
sign = "-"
b.Abs(b)
}
athousand := big.NewInt(1000)
c := (&big.Int{}).Set(b)
_, m := oom(c, athousand)
parts := make([]string, m+1)
j := len(parts) - 1
mod := &big.Int{}
for b.Cmp(athousand) >= 0 {
b.DivMod(b, athousand, mod)
parts[j] = strconv.FormatInt(mod.Int64(), 10)
switch len(parts[j]) {
case 2:
parts[j] = "0" + parts[j]
case 1:
parts[j] = "00" + parts[j]
}
j--
}
parts[j] = strconv.Itoa(int(b.Int64()))
return sign + strings.Join(parts[j:len(parts)], ",")
}
// EncodeBigInt returns the base62 encoding of an arbitrary precision integer
func (e *Encoding) EncodeBigInt(n *big.Int) string {
var (
b = make([]byte, 0)
rem = new(big.Int)
bse = new(big.Int)
zero = new(big.Int)
)
bse.SetInt64(base)
zero.SetInt64(0)
// Progressively divide by base, until we hit zero
// store remainder each time
// Prepend as an additional character is the higher power
for n.Cmp(zero) == 1 {
n, rem = n.DivMod(n, bse, rem)
b = append([]byte{e.encode[rem.Int64()]}, b...)
}
s := string(b)
if e.padding > 0 {
s = e.pad(s, e.padding)
}
return s
}
func Sub11(xx *big.Int) big.Int {
mm := new(big.Int)
kk := big.NewInt(10)
yy := new(big.Int)
yy.DivMod(xx, kk, mm)
yy.Sub(yy, mm)
return *yy
}
// Returns a new big.Int set to the ceiling of x.
func ratCeil(x *big.Rat) *big.Int {
z := new(big.Int)
m := new(big.Int)
z.DivMod(x.Num(), x.Denom(), m)
if m.Cmp(intZero) == 1 {
z.Add(z, intOne)
}
return z
}
// total order of magnitude
// (same as above, but with no upper limit)
func oom(n, b *big.Int) (float64, int) {
mag := 0
m := &big.Int{}
for n.Cmp(b) >= 0 {
n.DivMod(n, b, m)
mag++
}
return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
}
func SumBig(n *big.Int, base int) (sum int) {
i := new(big.Int).Set(n)
b := new(big.Int).SetUint64(uint64(base))
r := new(big.Int)
for i.BitLen() > 0 {
i.DivMod(i, b, r)
sum += int(r.Uint64())
}
return
}
// EncodeToString returns the base-encoded string representation
// of the given bytes.
func (enc *Encoding) EncodeToString(b []byte) string {
n := new(big.Int)
r := new(big.Int)
n.SetBytes(b)
var result []byte
for n.Cmp(zero) > 0 {
n, r = n.DivMod(n, enc.base, r)
result = append([]byte{enc.alphabet[r.Int64()]}, result...)
}
return string(result)
}
// order of magnitude (to a max order)
func oomm(n, b *big.Int, maxmag int) (float64, int) {
mag := 0
m := &big.Int{}
for n.Cmp(b) >= 0 {
n.DivMod(n, b, m)
mag++
if mag == maxmag && maxmag >= 0 {
break
}
}
return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag
}
// TODO: Pass in result, so it can be reused.
func reverse(n *big.Int) (result *big.Int) {
result = big.NewInt(0)
var work big.Int
work.Set(n)
tmp := big.NewInt(0)
for work.Cmp(zero) != 0 {
work.DivMod(&work, ten, tmp)
result.Mul(result, ten)
result.Add(result, tmp)
}
return
}
func NumberEncode(number string, alphabet []byte) string {
token := make([]byte, 0, 12)
x, ok := new(big.Int).SetString(number, 10)
if !ok {
return ""
}
y := big.NewInt(int64(len(alphabet)))
m := new(big.Int)
for x.Sign() > 0 {
x, m = x.DivMod(x, y, m)
token = append(token, alphabet[int(m.Int64())])
}
return string(token)
}
func EncodeAlphabet(alphabet, bs []byte) string {
base := big.NewInt(int64(len(alphabet)))
result := make([]byte, 0)
num := new(big.Int).SetBytes(bs)
rem := new(big.Int)
for num.Sign() != 0 {
num.DivMod(num, base, rem)
result = append(result, alphabet[rem.Int64()])
}
return string(result)
}
func digitSum(num *big.Int) (sum int) {
zero := big.NewInt(0)
ten := big.NewInt(10)
var work big.Int
work.Set(num)
tmp := big.NewInt(0)
for work.Cmp(zero) > 0 {
work.DivMod(&work, ten, tmp)
sum += int(tmp.Int64())
}
return
}
func sumDigitsFac(num int64) int64 {
n := new(big.Int)
n.MulRange(1, num)
ten := big.NewInt(10)
d := new(big.Int)
var sum int64
for n.BitLen() > 0 {
n.DivMod(n, ten, d)
sum += d.Int64()
}
return sum
}
func digitCount(n *big.Int) int {
zero := big.NewInt(0)
ten := big.NewInt(10)
var work big.Int
work.Set(n)
tmp := big.NewInt(0)
count := 0
for work.Cmp(zero) > 0 {
work.DivMod(&work, ten, tmp)
count += 1
}
return count
}
//Prove make the proof from the file and SwizzleChallenge which is send by a client.
func (ch *SwizzleChallenge) Prove(file io.ReadSeeker, tag Tag) (Proof, error) {
var dummy big.Int
swtag, ok := tag.(*SwizzleTag)
if !ok {
return nil, errors.New("use SwizzleTag instance for tag")
}
sectorSize := (ch.Vmax.BitLen() + 7) >> 3
proof := &SwizzleProof{}
proof.Mu = make([]big.Int, ch.Sectors)
proof.Sigma = new(big.Int)
buffer := make([]byte, sectorSize)
var mij big.Int
for i := 0; i < ch.Chunks; i++ {
v, err := keyedPRFBig(ch.Key, ch.Vmax, i)
if err != nil {
return nil, err
}
for j := 0; j < ch.Sectors; j++ {
n, err := file.Read(buffer)
if err != nil {
return nil, err
}
if n > 0 {
mij.SetBytes(buffer)
proof.Mu[j].Add(&proof.Mu[j], dummy.Mul(v, &mij))
}
if n != sectorSize {
break
}
}
defer func() {
if e := recover(); e != nil {
logging.Println(len(swtag.Sigmas))
logging.Println(i)
}
}()
proof.Sigma.Add(proof.Sigma, dummy.Mul(v, swtag.Sigmas[i]))
}
for j := 0; j < ch.Sectors; j++ {
dummy.DivMod(&proof.Mu[j], ch.Vmax, &proof.Mu[j])
}
dummy.DivMod(proof.Sigma, ch.Vmax, proof.Sigma)
return proof, nil
}
// Encode encodes src, appending to dst. Be sure to use the returned
// new value of dst.
func (self *encodingAlphabet) EncodeBig(dst []byte, src *big.Int) []byte {
start := len(dst)
n := new(big.Int)
n.Set(src)
radix := big.NewInt(58)
zero := big.NewInt(0)
for n.Cmp(zero) > 0 {
mod := new(big.Int)
n.DivMod(n, radix, mod)
dst = append(dst, self.alphabet[mod.Int64()])
}
for i, j := start, len(dst)-1; i < j; i, j = i+1, j-1 {
dst[i], dst[j] = dst[j], dst[i]
}
return dst
}
func sumDigitsPow(base, exp int64) int64 {
b := big.NewInt(base)
e := big.NewInt(exp)
n := new(big.Int)
n.Exp(b, e, nil)
ten := big.NewInt(10)
d := new(big.Int)
var sum int64
for n.BitLen() > 0 {
n.DivMod(n, ten, d)
sum += d.Int64()
}
return sum
}
// Encode encodes src, appending to dst. Be sure to use the returned
// new value of dst.
func Base36Encode(dst []byte, src *big.Int) []byte {
start := len(dst)
n := new(big.Int)
n.Set(src)
radix := big.NewInt(alphabetSize)
zero := big.NewInt(0)
for n.Cmp(zero) > 0 {
mod := new(big.Int)
n.DivMod(n, radix, mod)
dst = append(dst, alphabet[mod.Int64()])
}
for i, j := start, len(dst)-1; i < j; i, j = i+1, j-1 {
dst[i], dst[j] = dst[j], dst[i]
}
return dst
}
func ConvertTo62(raw []byte) string {
bi := big.Int{}
bi.SetBytes(raw)
rem := big.NewInt(0)
base := big.NewInt(62)
zero := big.NewInt(0)
result := ""
for bi.Cmp(zero) > 0 {
_, rem = bi.DivMod(&bi, base, rem)
result += string(alphabet[int(rem.Uint64())])
}
for len(result) < 22 {
result += "0"
}
return reverse(result)
}
//Encode makes a sigmas which iis sent to server.
func (sw *Swizzle) Encode(file io.ReadSeeker, n int) (Tag, error) {
var dummy big.Int
tag := SwizzleTag{}
tag.Sigmas = make([]*big.Int, 0)
sectorSize := (sw.prime.BitLen() + 7) >> 3
chunkID := 0
buffer := make([]byte, sectorSize)
var mij big.Int
alphas := make([]*big.Int, sw.sectors)
for j := 0; j < sw.sectors; j++ {
alpha, err := keyedPRFBig(sw.alphaKey, sw.prime, j)
if err != nil {
return nil, err
}
alphas[j] = alpha
}
for done := false; !done; chunkID++ {
sigma, err := keyedPRFBig(sw.fKey, sw.prime, chunkID)
if err != nil {
return nil, err
}
for j := 0; j < sw.sectors; j++ {
n, err := file.Read(buffer)
if err != nil {
return nil, err
}
if n > 0 {
mij.SetBytes(buffer)
sigma.Add(sigma, dummy.Mul(alphas[j], &mij))
}
if n != sectorSize {
done = true
break
}
}
dummy.DivMod(sigma, sw.prime, sigma)
tag.Sigmas = append(tag.Sigmas, sigma)
}
sw.chunks = chunkID
return &tag, nil
}
// EncodeBigToBase58 encodes src, appending to dst. Be sure to use the returned
// new value of dst.
func EncodeBigToBase58(dst []byte, src *big.Int) []byte {
start := len(dst)
n := new(big.Int)
n.Set(src)
radix := big.NewInt(58)
zero := big.NewInt(0)
for n.Cmp(zero) > 0 {
mod := new(big.Int)
n.DivMod(n, radix, mod)
dst = append(dst, alphabet[mod.Int64()])
}
// reverse string
for i, j := start, len(dst)-1; i < j; i, j = i+1, j-1 {
dst[i], dst[j] = dst[j], dst[i]
}
return dst
}
func (e *Encoding) enc(dst []byte, x *big.Int, src []byte) []byte {
if dst == nil {
dst = make([]byte, EncodedLen(x.BitLen()))
}
i := len(dst)
for x.Cmp(zero) > 0 {
i--
mod := new(big.Int)
x.DivMod(x, radix, mod)
dst[i] = e.encode[mod.Uint64()]
}
if e.padChar != NoPadding {
for src[i] == 0x00 {
i--
dst[i] = byte(e.padChar)
}
}
return dst[i:]
}
// Bytes encodes the written bytes to C4 ID format.
func (id *ID) Bytes() []byte {
var bigNum big.Int
bigID := big.Int(*id)
bigNum.Set(&bigID)
bigBase := big.NewInt(base)
bigZero := big.NewInt(0)
bigMod := new(big.Int)
var encoded []byte
for bigNum.Cmp(bigZero) > 0 {
bigNum.DivMod(&bigNum, bigBase, bigMod)
encoded = append([]byte{charset[bigMod.Int64()]}, encoded...)
}
// padding
diff := idlen - 2 - len(encoded)
encoded = append(bytes.Repeat(lowbyte, diff), encoded...)
// c4... prefix
encoded = append(prefix, encoded...)
return encoded
}
func Encodeb58(a []byte) (s string) {
idx := len(a)*138/100 + 1
buf := make([]byte, idx)
bn := new(big.Int).SetBytes(a)
var mo *big.Int
for bn.Cmp(bn0) != 0 {
bn, mo = bn.DivMod(bn, bn58, new(big.Int))
idx--
buf[idx] = b58set[mo.Int64()]
}
for i := range a {
if a[i] != 0 {
break
}
idx--
buf[idx] = b58set[0]
}
s = string(buf[idx:])
return
}
func Trial(n *big.Int) (primes []*big.Int, composites []*big.Int) {
var z big.Int
var m big.Int
bigp := big.NewInt(0)
for _, p := range smallPrimes {
for {
// reuse the existing bigint
bigp.SetInt64(p)
z.DivMod(n, bigp, &m)
if m.Sign() != 0 {
break
}
n.Set(&z)
primes = append(primes, bigp)
// create a new bigint, since we just stored the one we were using
bigp = big.NewInt(0)
}
if n.Cmp(one) == 0 {
break
}
}
if n.Cmp(one) > 0 {
if n.ProbablyPrime(10) {
primes = append(primes, n)
} else {
composites = append(composites, n)
}
}
return primes, composites
}
func TestTruncateRound(t *testing.T) {
var (
bsec = new(big.Int)
bnsec = new(big.Int)
bd = new(big.Int)
bt = new(big.Int)
br = new(big.Int)
bq = new(big.Int)
b1e9 = new(big.Int)
)
b1e9.SetInt64(1e9)
testOne := func(ti, tns, di int64) bool {
t0 := Unix(ti, int64(tns)).UTC()
d := Duration(di)
if d < 0 {
d = -d
}
if d <= 0 {
d = 1
}
// Compute bt = absolute nanoseconds.
sec, nsec := abs(t0)
bsec.SetInt64(sec)
bnsec.SetInt64(nsec)
bt.Mul(bsec, b1e9)
bt.Add(bt, bnsec)
// Compute quotient and remainder mod d.
bd.SetInt64(int64(d))
bq.DivMod(bt, bd, br)
// To truncate, subtract remainder.
// br is < d, so it fits in an int64.
r := br.Int64()
t1 := t0.Add(-Duration(r))
// Check that time.Truncate works.
if trunc := t0.Truncate(d); trunc != t1 {
t.Errorf("Time.Truncate(%s, %s) = %s, want %s\n"+
"%v trunc %v =\n%v want\n%v",
t0.Format(RFC3339Nano), d, trunc, t1.Format(RFC3339Nano),
absString(t0), int64(d), absString(trunc), absString(t1))
return false
}
// To round, add d back if remainder r > d/2 or r == exactly d/2.
// The commented out code would round half to even instead of up,
// but that makes it time-zone dependent, which is a bit strange.
if r > int64(d)/2 || r+r == int64(d) /*&& bq.Bit(0) == 1*/ {
t1 = t1.Add(Duration(d))
}
// Check that time.Round works.
if rnd := t0.Round(d); rnd != t1 {
t.Errorf("Time.Round(%s, %s) = %s, want %s\n"+
"%v round %v =\n%v want\n%v",
t0.Format(RFC3339Nano), d, rnd, t1.Format(RFC3339Nano),
absString(t0), int64(d), absString(rnd), absString(t1))
return false
}
return true
}
// manual test cases
for _, tt := range truncateRoundTests {
testOne(tt.t.Unix(), int64(tt.t.Nanosecond()), int64(tt.d))
}
// exhaustive near 0
for i := 0; i < 100; i++ {
for j := 1; j < 100; j++ {
testOne(unixToZero, int64(i), int64(j))
testOne(unixToZero, -int64(i), int64(j))
if t.Failed() {
return
}
}
}
if t.Failed() {
return
}
// randomly generated test cases
cfg := &quick.Config{MaxCount: 100000}
if testing.Short() {
cfg.MaxCount = 1000
}
// divisors of Second
f1 := func(ti int64, tns int32, logdi int32) bool {
d := Duration(1)
a, b := uint(logdi%9), (logdi>>16)%9
d <<= a
for i := 0; i < int(b); i++ {
d *= 5
}
return testOne(ti, int64(tns), int64(d))
}
quick.Check(f1, cfg)
// multiples of Second
f2 := func(ti int64, tns int32, di int32) bool {
d := Duration(di) * Second
if d < 0 {
d = -d
}
return testOne(ti, int64(tns), int64(d))
}
quick.Check(f2, cfg)
// halfway cases
f3 := func(tns, di int64) bool {
di &= 0xfffffffe
if di == 0 {
di = 2
}
tns -= tns % di
if tns < 0 {
tns += di / 2
} else {
tns -= di / 2
}
return testOne(0, tns, di)
}
quick.Check(f3, cfg)
// full generality
f4 := func(ti int64, tns int32, di int64) bool {
return testOne(ti, int64(tns), di)
}
quick.Check(f4, cfg)
}