codex-storage
/
nim-libp2p
mirror of https://github.com/codex-storage/nim-libp2p.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
nim-libp2p/libp2p/base32.nim

286 lines
10 KiB
Nim
Raw Blame History

## 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 BASE32 encoding and decoding procedures.
## This module supports RFC4648's BASE32.
type
Base32Status* {.pure.} = enum
Error,
Success,
Incorrect,
Overrun
Base32Alphabet* = object
decode*: array[128, int8]
encode*: array[32, uint8]
Base32Upper* = object
## Type to use RFC4648 alphabet in uppercase without padding
Base32Lower* = object
## Type to use RFC4648 alphabet in lowercase without padding
Base32UpperPad* = object
## Type to use RFC4648 alphabet in uppercase with padding
Base32LowerPad* = object
## Type to use RFC4648 alphabet in lowercase with padding
HexBase32Upper* = object
## Type to use RFC4648-HEX alphabet in uppercase without padding
HexBase32Lower* = object
## Type to use RFC4648-HEX alphabet in lowercase without padding
HexBase32UpperPad* = object
## Type to use RFC4648-HEX alphabet in uppercase with padding
HexBase32LowerPad* = object
## Type to use RFC4648-HEX alphabet in lowercase with padding
Base32* = Base32Upper
## By default we are using RFC4648 alphabet in uppercase without padding
Base32PadTypes* = Base32UpperPad | Base32LowerPad |
HexBase32UpperPad | HexBase32LowerPad
## All types with padding support
Base32NoPadTypes* = Base32Upper | Base32Lower | HexBase32Upper |
HexBase32Lower
## All types without padding
Base32Types* = Base32NoPadTypes | Base32PadTypes
## Supported types
Base32Error* = object of Exception
## Base32 specific exception type
proc newAlphabet32*(s: string): Base32Alphabet =
doAssert(len(s) == 32)
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
RFCUpperCaseAlphabet* = newAlphabet32("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567")
RFCLowerCaseAlphabet* = newAlphabet32("abcdefghijklmnopqrstuvwxyz234567")
HEXUpperCaseAlphabet* = newAlphabet32("0123456789ABCDEFGHIJKLMNOPQRSTUV")
HEXLowerCaseAlphabet* = newAlphabet32("0123456789abcdefghijklmnopqrstuv")
proc encodedLength*(btype: typedesc[Base32Types], length: int): int =
## Return estimated length of BASE32 encoded value for plain length
## ``length``.
let reminder = length mod 5
when btype is Base32NoPadTypes:
result = ((length div 5) * 8) + (((reminder * 8) + 4) div 5)
else:
result = ((length div 5) * 8)
if reminder != 0:
result += 8
proc decodedLength*(btype: typedesc[Base32Types], length: int): int =
## Return estimated length of decoded value of BASE32 encoded value of length
## ``length``.
let reminder = length mod 8
result = (length div 8) * 5 + ((reminder * 5) div 8)
proc convert5to8(inbytes: openarray[byte], outbytes: var openarray[char],
length: int): int {.inline.} =
if length >= 1:
outbytes[0] = chr(inbytes[0] shr 3)
outbytes[1] = chr((inbytes[0] and 7'u8) shl 2)
result = 2
if length >= 2:
outbytes[1] = chr(cast[byte](outbytes[1]) or cast[byte](inbytes[1] shr 6))
outbytes[2] = chr((inbytes[1] shr 1) and 31'u8)
outbytes[3] = chr((inbytes[1] and 1'u8) shl 4)
result = 4
if length >= 3:
outbytes[3] = chr(cast[byte](outbytes[3]) or (inbytes[2] shr 4))
outbytes[4] = chr((inbytes[2] and 15'u8) shl 1)
result = 5
if length >= 4:
outbytes[4] = chr(cast[byte](outbytes[4]) or (inbytes[3] shr 7))
outbytes[5] = chr((inbytes[3] shr 2) and 31'u8)
outbytes[6] = chr((inbytes[3] and 3'u8) shl 3)
result = 7
if length >= 5:
outbytes[6] = chr(cast[byte](outbytes[6]) or (inbytes[4] shr 5))
outbytes[7] = chr(inbytes[4] and 31'u8)
result = 8
proc convert8to5(inbytes: openarray[byte], outbytes: var openarray[byte],
length: int): int {.inline.} =
if length >= 2:
outbytes[0] = inbytes[0] shl 3
outbytes[0] = outbytes[0] or (inbytes[1] shr 2)
result = 1
if length >= 4:
outbytes[1] = (inbytes[1] and 3'u8) shl 6
outbytes[1] = outbytes[1] or (inbytes[2] shl 1)
outbytes[1] = outbytes[1] or (inbytes[3] shr 4)
result = 2
if length >= 5:
outbytes[2] = (inbytes[3] and 15'u8) shl 4
outbytes[2] = outbytes[2] or (inbytes[4] shr 1)
result = 3
if length >= 7:
outbytes[3] = (inbytes[4] and 1'u8) shl 7
outbytes[3] = outbytes[3] or (inbytes[5] shl 2)
outbytes[3] = outbytes[3] or (inbytes[6] shr 3)
result = 4
if length >= 8:
outbytes[4] = (inbytes[6] and 7'u8) shl 5
outbytes[4] = outbytes[4] or (inbytes[7] and 31'u8)
result = 5
proc encode*(btype: typedesc[Base32Types], inbytes: openarray[byte],
outstr: var openarray[char], outlen: var int): Base32Status =
## Encode array of bytes ``inbytes`` using BASE32 encoding and store
## result to ``outstr``. On success ``Base32Status.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
## ``Base32Status.Overrun`` will be returned and ``outlen`` will be set to
## number of characters required.
when (btype is Base32Upper) or (btype is Base32UpperPad):
const alphabet = RFCUpperCaseAlphabet
elif (btype is Base32Lower) or (btype is Base32LowerPad):
const alphabet = RFCLowerCaseAlphabet
elif (btype is HexBase32Upper) or (btype is HexBase32UpperPad):
const alphabet = HEXUpperCaseAlphabet
elif (btype is HexBase32Lower) or (btype is HexBase32LowerPad):
const alphabet = HEXLowerCaseAlphabet
if len(inbytes) == 0:
outlen = 0
return Base32Status.Success
let length = btype.encodedLength(len(inbytes))
if length > len(outstr):
outlen = length
return Base32Status.Overrun
let reminder = len(inbytes) mod 5
let limit = len(inbytes) - reminder
var i, k: int
while i < limit:
discard convert5to8(inbytes.toOpenArray(i, i + 4),
outstr.toOpenArray(k, k + 7), 5)
for j in 0..7:
outstr[k + j] = chr(alphabet.encode[ord(outstr[k + j])])
k += 8
i += 5
if reminder != 0:
let left = convert5to8(inbytes.toOpenArray(i, i + reminder - 1),
outstr.toOpenArray(k, length - 1), reminder)
for j in 0..(left - 1):
outstr[k] = chr(alphabet.encode[ord(outstr[k])])
inc(k)
when (btype is Base32UpperPad) or (btype is Base32LowerPad) or
(btype is HexBase32UpperPad) or (btype is HexBase32LowerPad):
while k < len(outstr):
outstr[k] = '='
inc(k)
outlen = k
result = Base32Status.Success
proc encode*(btype: typedesc[Base32Types],
inbytes: openarray[byte]): string {.inline.} =
## Encode array of bytes ``inbytes`` using BASE32 encoding and return
## encoded string.
if len(inbytes) == 0:
result = ""
else:
var length = 0
result = newString(btype.encodedLength(len(inbytes)))
if btype.encode(inbytes, result, length) == Base32Status.Success:
result.setLen(length)
else:
result = ""
proc decode*[T: byte|char](btype: typedesc[Base32Types], instr: openarray[T],
outbytes: var openarray[byte], outlen: var int): Base32Status =
## Decode BASE32 string and store array of bytes to ``outbytes``. On success
## ``Base32Status.Success`` will be returned and ``outlen`` will be set
## to number of bytes stored.
##
## ## If length of ``outbytes`` is not enough to store decoded bytes, then
## ``Base32Status.Overrun`` will be returned and ``outlen`` will be set to
## number of bytes required.
when (btype is Base32Upper) or (btype is Base32UpperPad):
const alphabet = RFCUpperCaseAlphabet
elif (btype is Base32Lower) or (btype is Base32LowerPad):
const alphabet = RFCLowerCaseAlphabet
elif (btype is HexBase32Upper) or (btype is HexBase32UpperPad):
const alphabet = HEXUpperCaseAlphabet
elif (btype is HexBase32Lower) or (btype is HexBase32LowerPad):
const alphabet = HEXLowerCaseAlphabet
if len(instr) == 0:
outlen = 0
return Base32Status.Success
let length = btype.decodedLength(len(instr))
if length > len(outbytes):
outlen = length
return Base32Status.Overrun
var inlen = len(instr)
when (btype is Base32PadTypes):
for i in countdown(inlen - 1, 0):
if instr[i] != '=':
break
dec(inlen)
let reminder = inlen mod 8
let limit = inlen - reminder
var buffer: array[8, byte]
var i, k: int
while i < limit:
for j in 0..<8:
if (cast[byte](instr[i + j]) and 0x80'u8) != 0:
outlen = 0
return Base32Status.Incorrect
let ch = alphabet.decode[cast[int8](instr[i + j])]
if ch == -1:
outlen = 0
return Base32Status.Incorrect
buffer[j] = cast[byte](ch)
discard convert8to5(buffer, outbytes.toOpenArray(k, k + 4), 8)
k += 5
i += 8
var left = 0
if reminder != 0:
if reminder == 1 or reminder == 3 or reminder == 6:
outlen = 0
return Base32Status.Incorrect
for j in 0..<reminder:
if (cast[byte](instr[i + j]) and 0x80'u8) != 0:
outlen = 0
result = Base32Status.Incorrect
return
let ch = alphabet.decode[cast[int8](instr[i + j])]
if ch == -1:
outlen = 0
result = Base32Status.Incorrect
return
buffer[j] = cast[byte](ch)
left = convert8to5(buffer.toOpenArray(0, reminder - 1),
outbytes.toOpenArray(k, length - 1), reminder)
outlen = k + left
result = Base32Status.Success
proc decode*[T: byte|char](btype: typedesc[Base32Types],
instr: openarray[T]): seq[byte] =
## Decode BASE32 string ``instr`` and return sequence of bytes as result.
if len(instr) == 0:
result = newSeq[byte]()
else:
var length = 0
result = newSeq[byte](btype.decodedLength(len(instr)))
if btype.decode(instr, result, length) == Base32Status.Success:
result.setLen(length)
else:
raise newException(Base32Error, "Incorrect base32 string")
Reference in New Issue View Git Blame Copy Permalink