nim-libp2p/libp2p/base58.nim

240 lines
7.3 KiB
Nim
Raw Normal View History

2018-11-23 22:06:06 +00:00
## Nim-Libp2p
## Copyright (c) 2018 Status Research & Development GmbH
## Licensed under either of
## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
## * MIT license ([LICENSE-MIT](LICENSE-MIT))
## at your option.
## This file may not be copied, modified, or distributed except according to
## those terms.
## This module implements BASE58 encoding and decoding procedures.
## This module supports two variants of BASE58 encoding (Bitcoin and Flickr).
type
Base58Status* {.pure.} = enum
Error,
Success,
Incorrect,
Overrun
Base58Alphabet* = object
decode*: array[128, int8]
encode*: array[58, uint8]
BTCBase58* = object
## Type to use Bitcoin alphabet
FLCBase58* = object
## Type to use Flickr alphabet
Base58* = BtcBase58
## By default we are using Bitcoin alphabet
Base58C* = BTCBase58 | FLCBase58
## Supported types
Base58Error* = object of Exception
## Base58 specific exception type
proc newAlphabet58*(s: string): Base58Alphabet =
doAssert(len(s) == 58)
for i in 0..<len(s):
result.encode[i] = cast[uint8](s[i])
for i in 0..<len(result.decode):
result.decode[i] = -1
for i in 0..<len(result.encode):
result.decode[int(result.encode[i])] = int8(i)
const
BTCAlphabet* = newAlphabet58("123456789ABCDEFGHJKLMNPQRSTUV" &
"WXYZabcdefghijkmnopqrstuvwxyz")
FlickrAlphabet* = newAlphabet58("123456789abcdefghijkmnopqrstu" &
"vwxyzABCDEFGHJKLMNPQRSTUVWXYZ")
proc encodedLength*(btype: typedesc[Base58C], length: int): int =
## Return estimated length of BASE58 encoded value for plain length
## ``length``.
result = (length * 138) div 100 + 1
proc decodedLength*(btype: typedesc[Base58C], length: int): int =
## Return estimated length of decoded value of BASE58 encoded value of length
## ``length``.
result = length + 4
2018-11-23 22:06:06 +00:00
proc encode*(btype: typedesc[Base58C], inbytes: openarray[byte],
outstr: var openarray[char], outlen: var int): Base58Status =
## Encode array of bytes ``inbytes`` using BASE58 encoding and store
## result to ``outstr``. On success ``Base58Status.Success`` will be returned
## and ``outlen`` will be set to number of characters stored inside of
## ``outstr``. If length of ``outstr`` is not enough then
## ``Base58Status.Overrun`` will be returned and ``outlen`` will be set to
## number of characters required.
when btype is BTCBase58:
const alphabet = BTCAlphabet
elif btype is FLCBase58:
const alphabet = FlickrAlphabet
let binsz = len(inbytes)
var zcount = 0
while zcount < binsz and inbytes[zcount] == 0x00'u8:
inc(zcount)
let size = ((binsz - zcount) * 138) div 100 + 1
var buffer = newSeq[uint8](size)
var hi = size - 1
var i = zcount
var j = size - 1
while i < binsz:
var carry = uint32(inbytes[i])
j = size - 1
while (j > hi) or (carry != 0'u32):
carry = carry + uint32(256'u32 * buffer[j])
buffer[j] = cast[byte](carry mod 58)
carry = carry div 58
dec(j)
hi = j
inc(i)
j = 0
while (j < size) and (buffer[j] == 0x00'u8):
inc(j)
let needed = zcount + size - j
outlen = needed
if len(outstr) < needed:
result = Base58Status.Overrun
else:
for k in 0..<zcount:
outstr[k] = cast[char](alphabet.encode[0])
i = zcount
while j < size:
outstr[i] = cast[char](alphabet.encode[buffer[j]])
inc(j)
inc(i)
result = Base58Status.Success
proc encode*(btype: typedesc[Base58C],
inbytes: openarray[byte]): string {.inline.} =
## Encode array of bytes ``inbytes`` using BASE58 encoding and return
## encoded string.
var size = (len(inbytes) * 138) div 100 + 1
result = newString(size)
if btype.encode(inbytes, result.toOpenArray(0, size - 1),
size) == Base58Status.Success:
result.setLen(size)
else:
result = ""
2018-11-23 22:06:06 +00:00
proc decode*[T: byte|char](btype: typedesc[Base58C], instr: openarray[T],
2018-11-23 22:06:06 +00:00
outbytes: var openarray[byte], outlen: var int): Base58Status =
## Decode BASE58 string and store array of bytes to ``outbytes``. On success
## ``Base58Status.Success`` will be returned and ``outlen`` will be set
## to number of bytes stored.
##
## Length of ``outbytes`` must be equal or more then ``len(instr) + 4``.
##
## If ``instr`` has characters which are not part of BASE58 alphabet, then
## ``Base58Status.Incorrect`` will be returned and ``outlen`` will be set to
## ``0``.
##
## If length of ``outbytes`` is not enough to store decoded bytes, then
## ``Base58Status.Overrun`` will be returned and ``outlen`` will be set to
## number of bytes required.
when btype is BTCBase58:
const alphabet = BTCAlphabet
elif btype is FLCBase58:
const alphabet = FlickrAlphabet
if len(instr) == 0:
outlen = 0
return Base58Status.Success
let binsz = len(instr) + 4
if len(outbytes) < binsz:
outlen = binsz
return Base58Status.Overrun
var bytesleft = binsz mod 4
var zeromask: uint32
if bytesleft != 0:
zeromask = cast[uint32](0xFFFF_FFFF'u32 shl (bytesleft * 8))
let size = (binsz + 3) div 4
var buffer = newSeq[uint32](size)
var zcount = 0
while zcount < len(instr) and instr[zcount] == cast[char](alphabet.encode[0]):
inc(zcount)
for i in zcount..<len(instr):
if (cast[byte](instr[i]) and 0x80'u8) != 0:
outlen = 0
result = Base58Status.Incorrect
return
let ch = alphabet.decode[int8(instr[i])]
if ch == -1:
outlen = 0
result = Base58Status.Incorrect
return
var c = cast[uint32](ch)
for j in countdown(size - 1, 0):
let t = cast[uint64](buffer[j]) * 58 + c
c = cast[uint32]((t and 0x3F_0000_0000'u64) shr 32)
buffer[j] = cast[uint32](t and 0xFFFF_FFFF'u32)
if c != 0:
outlen = 0
result = Base58Status.Incorrect
return
if (buffer[0] and zeromask) != 0:
outlen = 0
result = Base58Status.Incorrect
return
var boffset = 0
var joffset = 0
if bytesleft == 3:
outbytes[boffset] = cast[uint8]((buffer[0] and 0xFF_0000'u32) shr 16)
inc(boffset)
bytesleft = 2
if bytesleft == 2:
outbytes[boffset] = cast[uint8]((buffer[0] and 0xFF00'u32) shr 8)
inc(boffset)
bytesleft = 1
if bytesleft == 1:
outbytes[boffset] = cast[uint8]((buffer[0] and 0xFF'u32))
inc(boffset)
joffset = 1
while joffset < size:
outbytes[boffset + 0] = cast[byte]((buffer[joffset] shr 0x18) and 0xFF)
outbytes[boffset + 1] = cast[byte]((buffer[joffset] shr 0x10) and 0xFF)
outbytes[boffset + 2] = cast[byte]((buffer[joffset] shr 0x8) and 0xFF)
outbytes[boffset + 3] = cast[byte](buffer[joffset] and 0xFF)
boffset += 4
inc(joffset)
outlen = binsz
var m = 0
while m < binsz:
if outbytes[m] != 0x00:
if zcount > m:
result = Base58Status.Overrun
return
break
inc(m)
dec(outlen)
if m < binsz:
moveMem(addr outbytes[zcount], addr outbytes[binsz - outlen], outlen)
outlen += zcount
result = Base58Status.Success
proc decode*(btype: typedesc[Base58C], instr: string): seq[byte] =
## Decode BASE58 string ``instr`` and return sequence of bytes as result.
if len(instr) > 0:
var size = len(instr) + 4
result = newSeq[byte](size)
if btype.decode(instr, result, size) == Base58Status.Success:
result.setLen(size)
else:
raise newException(Base58Error, "Incorrect base58 string")