# Very useless bash source file doing b64(en/de)coding in pure bash
# A proof of concept, but very slow!
# Some tricks: there is all you need to work with binary under bash....

export -a _Base64_pot=({A..Z} {a..z} {0..9} + /)
export AsciiStr="" _Base64_refstr
printf -v _Base64_refstr "%s" ${_Base64_pot[@]}

for _Base64_i in {0..255};do printf -v _Base64_q "\\%03o" $_Base64_i
    printf -v _Base64_q "%b" "$_Base64_q" ;AsciiStr+="$_Base64_q" ;done
unset _Base64_i _Base64_q

doBase64 () { 
    local _pos _func='{ local _octal;
       printf -v _octal "%016o" $1 ;printf ${2:+-v} $2 "%s" "';
    for _pos in {0..14..2} ;do
        printf -v _func '%s${_Base64_pot[8#${_octal:%d:2}]}' "$_func" $_pos;
    done;
    _func+='"; }';
    eval "doBase64()" $_func;
    doBase64 $@
}

getAscii() { # using ``printf "%q"'' was not appropriate.
    local char var=${1:-ASCII_CHAR};
    ! LANG=C IFS= read -rd '' -n 1 char && printf -v $var '' && return 1;
    if [ ${#char} -eq 0 ]; then
        printf -v $var 0;
    else
        char="${char//\\/\\\\}";
        char="${char//[*]/[*]}";
        char="${AsciiStr%${char//[?]/[?]}*}";
        printf -v $var $((1+${#char}));
    fi
}
b64Encode () { # Encode 6 bytes at a time -> 8 Base64 chars
    local byte i s out='' lfil='AAAAAAAA' efil='========' end=8;
    while getAscii byte; do
	s=$(((10#$byte)<<+40)) # 1st byte, left shifted by 40 bits
	for i in {1..5};do     # next 5 bytes
            if getAscii byte ;then  # shifted by 32, 24, 16, 8 and 0 bits
		(( s |= $byte << ( 8 * ( 5 - i ) ) ))
	    else  # End of input compute `=` sign for delimiting source
		doBase64 $s s
		end=$(( 2 + ( i - 1 ) * 4 / 3 ))
		s=${s:0:end}${efil:end}
		out+=${s//====} # drop ``===='': std b64 work by 3 bytes, not 6
		break 2
	    fi
	done
	doBase64 $s s
	out+=$s
        [ ${#out} -ge 70 ] && echo $out && out= # could be changed, but why?
	byte=
    done
    echo $out
}
b64Encode2 () { # Seem quicker, but not so much
    local b1 b2 b3 b4 b5 b6 i s out='' lfil='AAAAAAAA' efil='========' end=8;
    while getAscii b1; do
	if ! getAscii b2 ;then
	    doBase64 $(( b1<<+40 | b2<<+32 )) s
	    out+=${s:0:2}${efil:0:2}
	    break 2
	fi
	if ! getAscii b3 ;then
	    doBase64 $(( b1<<+40 | b2<<+32 | b3<<+24 )) s
	    out+=${s:0:3}${efil:0:1}
	    break 2
	fi
	if ! getAscii b4 ;then
	    doBase64 $(( b1<<+40 | b2<<+32 | b3<<+24 | b4<<+16 )) s
	    out+=${s:0:4}
	    break 2
	fi
	if ! getAscii b5 ;then
	    doBase64 $(( b1<<+40 | b2<<+32 | b3<<+24 | b4<<+16 | b5<<+8 )) s
	    out+=${s:0:6}${efil:0:2}
	    break 2
	fi
	if ! getAscii b6 ;then
	    doBase64 $(( b1<<+40|b2<<+32|b3<<+24|b4<<+16|b5<<+8|b6 )) s
	    out+=${s:0:7}${efil:0:1}
	    break 2
	fi
	doBase64 $(( b1<<+40 | b2<<+32 | b3<<+24 | b4<<+16 | b5<<+8 | b6 )) s
	out+=$s
        [ ${#out} -ge 70 ] && echo $out && out=
	byte=
    done
    echo $out
}
b64Decode () {
    local _Base64_in _val _s1 _s2 _s3 _s4
    while read -n4 _Base64_in;do
	[ "$_Base64_in" ] || continue
	_s1=${_Base64_refstr%${_Base64_in:0:1}*} _s2=${_Base64_refstr%${_Base64_in:1:1}*}
	_s3=${_Base64_refstr%${_Base64_in:2:1}*} _s4=${_Base64_refstr%${_Base64_in:3:1}*}
	_val=$((( ( ${#_s1} % 64 ) << +18 ) | ( ( ${#_s2} % 64 ) << +12 ) |
		( ( ${#_s3} % 64 ) <<  +6 ) | (   ${#_s4} % 64 )         ))
	printf -v _val "\\%03o" $(( (_val>>16) & 255 )) \
	    $(( (_val>>8) & 255 )) $(( _val & 255 ))
	_Base64_in=${_Base64_in//=}
	printf "%b" ${_val:0:4*(${#_Base64_in}-1)}
    done
}
b64Decode0 () { # this one is more sexy, but not quicker.
    local _Base64_in _val _i _s
    while read -n4 _Base64_in;do
	[ "$_Base64_in" ] || continue
	_val=0
	for _i in {0..3};do
	    _s=${_Base64_refstr%${_Base64_in:_i:1}*}
	    (( _val |= ( ${#_s} % 64 ) << ( 6 * ( 3 - _i ) ) ))
	done
	printf -v _val "\\%03o" $(( (_val>>16) & 255 )) \
	    $(( (_val>>8) & 255 )) $(( _val & 255 ))
	_Base64_in=${_Base64_in//=}
	printf "%b" ${_val:0:4*(${#_Base64_in}-1)}
    done
}
b64Decode_by_tr() {  # A lot quicker, but require a fork to ``tr''
    local _Bash64_refstr _Base64_in _val
    printf -v _Bash64_refstr "%s" {0..9} {a..z} {A..Z} @ _
    while read -n4 _Base64_in;do
	[ "$_Base64_in" ] || continue 
	printf -v _val "\\%03o" $(( 64#${_Base64_in//=/0} >> 16 & 255 )) \
	    $(( 64#${_Base64_in//=/0} >> 8 & 255 )) $(( 64#${_Base64_in//=/0} & 255 ))
	_Base64_in=${_Base64_in//=}
	printf "%b" ${_val:0:4*(${#_Base64_in}-1)}	
    done < <(
	tr $_Base64_refstr $_Bash64_refstr
    )
}