Início / coding / Perguntas / 79566585
Accepted
vamsiampolu
Asked: 2025-04-10 20:04:14 +0800 CST

Decodifique uma string base64 e codifique-a como hexadecimal usando xxd

  • 772

Primeiro, pego uma string codificada em base64 e a decodifico:

local base64_str="OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="
echo "${base64_str}" | base64 --decode > foo.txt

O tamanho do arquivo binário é 32 bytes com base em:wc -c < foo.txt

Eu costumo xxdcodificar o valor no arquivo para o formato hexadecimal:

xxd -p ./foo.txt ./foo.hex.txt

O valor hexadecimal no arquivo foo.hex.txt é:

3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66a
c13c

O tamanho do arquivo hash codificado é de 66 bytes usandowc -c < foo.hex.txt

Gostaria de pegar a string base64 e convertê-la para hexadecimal de modo que ela permaneça uma string de 32 bytes que eu possa usar com o openssl para criptografar e descriptografar usando cifras aes-256.

local iv_hex=$(base64_to_hex "${iv}")
local key_hex=$(base64_to_hex "${key}")

openssl enc -aes-256-ctr -K "${key_hex}" -iv "${iv_hex}" -in "${input_file}" -out "${output_file}"
bash

2 respostas

  1. Converter string pequena codificada em base64 para hexadecimal

    1. Redução de garfos

    A resposta aceita oferece uma solução com muitos garfos! Detesto garfos inúteis !

    Aqui está meu pequeno conversor de base64 para hexadecimal :

    b64toHex() {
    local _arLines
    mapfile -t _arLines < <(base64 -d <<< "$2" | xxd -p)
    printf -v "${1:-hexString}" %s "${_arLines[@]}"
}

    Para evitar bifurcações como essa myVar=$(myFunc args), esta função preencherá apenas uma variável e não imprimirá nada.

    b64toHex myVar "OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="
echo $myVar

    3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66ac13c

    Então você pode usar:

    b64toHex iv_hex "${iv}"
b64toHex key_hex "${key}"

    Veja no final desta página a comparação do tempo de execução.

    2. Jeito bash puro:

    Isso não depende xxdnem base64precisa ser instalado. (E sem forks, será significativamente mais rápido do que executar 3 forks! Lembre-se disso se você planeja executar isso repetidamente!)

    Disto: Script Bash - decodificar string codificada em array de bytes , no meu site: base64decoder.sh.txt , base64decoder.sh , com uma modificação muito pequena**:

    **Na linha 41:
    - ((_ar==0)) && printf -v _res %b "${_res[@]/#/\\x}"
    + ((_ar==0)) && printf -v _res %s "${_res[@]}"

    Primeiro prepare uma matriz somente leitura como:

    declare -a B64=( {A..Z} {a..z} {0..9} + / '=' )
declare -Ai 'B64R=()'
for i in "${!B64[@]}"; do B64R["${B64[i]}"]=i%64; done
declare -r B64R
unset B64

    Então b64ToHexfunção:

    b64ToHex() {
    local _4B _Tail _hVal _v _opt OPTIND
    local -i iFd _24b _ar
    while getopts "av:" _opt; do case $_opt in
        a) _ar=1;; v) _v=${OPTARG};; *) return 1;; esac; done
    shift $((OPTIND-1))
    if [[ $_v ]];then local -n _res=${_v}; else local _res; fi
    if [[ $1 ]]; then    exec {iFd}<<<"$1"          # Open Input FD from string
    else                 exec {iFd}<&0        ; fi  # Open Input FD from STDIN
    _res=()
    while read -rn4 -u $iFd _4B; do
        if [[ "$_4B" ]]; then
            _Tail=$_4B
            _24b=" B64R['${_4B::1}'] << 18 | B64R['${_4B:1:1}'] << 12 |
                   B64R['${_4B:2:1}'] << 6 | B64R['${_4B:3:1}'] "
            printf -v _hval %02x\  $((_24b>>16)) $((_24b>>8&255)) $((_24b&255))
            read -ra _hval <<<"$_hval"
            _res+=("${_hval[@]}")
        fi
    done
    exec {iFd}<&-
    _Tail=${_Tail##*([^=])}
    while [[ $_Tail ]]; do
        unset "_res[-1]"
        _Tail=${_Tail:1}
    done
    ((_ar==0)) && printf -v _res %s "${_res[@]}" && _res=("${_res[0]}")
    [[ -z $_v ]] && echo "${_res[@]}"
}

    Se o loop for conhecido por ser lento, fazer um loop de apenas 32 bytes será significativamente mais rápido e exigirá menos do sistema do que executar quatro bifurcações!

    Uso de STDIN :

    b64ToHex <<<"OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="

    3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66ac13c

    De um argumento:

    b64ToHex "OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="

    3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66ac13c

    Atribuir uma variável:

    b64ToHex -v someVar "OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw="
echo "$someVar"

    3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66ac13c

    Então, de, para variáveis:

    b64ToHex -v iv_hex "${iv}"
b64ToHex -v key_hex "${key}"

    Nota: isso é feito sem garfo.

    Para se divertir: recuperando a string base64 original, com o bash V5.1+, você pode:

    shopt -s extglob
printf %b ${someVar//??/\\x& } | base64

    OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw=

    3. Modo bash puro, mas usando bash V5.2+

    Mesmo script, mas usando patsub_replacement e mapfile, eu poderia fazer isso sem nenhum loop !

    declare -a B64=( {A..Z} {a..z} {0..9} + / '=' )
printf -v _b64_tstr '["\44{B64[%d]}"]=%%d%%%%64 ' {0..64}
# shellcheck disable=SC2059  # format is variable.
printf -v _b64_tstr "$_b64_tstr" {0..64}
declare -Ai "B64R=($_b64_tstr)"
unset B64 _b64_tstr
declare -r B64R

    b64ToHex52() {
    local _line _Tail _v _opt OPTIND _resArry
    local -i iFd _ar
    while getopts "av:" _opt; do case $_opt in
        a) _ar=1;; v) _v=${OPTARG};; *) return 1;; esac; done
    shift $((OPTIND-1))
    if [[ $_v ]];then local -n _res=${_v}; else local _res; fi
    if [[ $1 ]]; then    exec {iFd}<<<"$1"     # Open Input FD from string
    else                 exec {iFd}<&0   ; fi  # Open Input FD from STDIN
    mapfile -tu $iFd _lines
    read -ra _resArry <<<"${_lines[*]//?/& }"
    printf -v _tmpStr '"B64R[%s]<<18|B64R[%s]<<12|B64R[%s]<<6|B64R[%s]" ' \
           "${_resArry[@]}"
    local -ia "_tmpArry=($_tmpStr)"
    printf -v _tmpStr '%06x' "${_tmpArry[@]}"
    read -ra _res <<<"${_tmpStr//??/& }"
    exec {iFd}<&-
    _Tail=${_lines[-1]##*([^=])}
    _res=("${_res[@]::${#_res[@]}-${#_Tail}}")
    ((_ar==0)) && printf -v _res %s "${_res[@]}" && _res=("${_res[0]}")
    [[ -z $_v ]] && echo "${_res[@]}"
}

    4. Comparação do tempo de execução

    Bem, agora um pequeno teste de comparação fazendo repetidamente a mesma conversão para calcular o tempo de execução.

    Agora tenho 4 funções:

    1. b64toHexMinha versão usando base64exxd
    2. b64ToHexMinha versão puraT (observe o superior )
    3. b64ToHex52Meu puro usando bash versão 5.2+
    4. base64_to_hexda resposta aceita.

    Aqui está minha pequena função de teste:

    testB64decoders(){ 
    local TIMEFORMAT='r %3lR,  u %3lU,  s %3lS, p %P' bunch \
        inString="${2:-SGVsbG8gd29ybGQhIFRoaXMgaXMgYSB0ZXN0IHN0cmluZy4=}"
    printf -v bunch '%*s' ${1:-100} ''
    mapfile -t bunch <<<"${bunch// /$'\n'}"
    printf ' - %-29s: ' "3 fork (base64 | xxd)";
    time for i in "${bunch[@]}"; do b64toHex hx "$inString"; done
    printf ' - %-29s: ' "Pure bash";
    time for i in "${bunch[@]}"; do b64ToHex -v Hx "$inString"; done;
    printf ' - %-29s: ' "Pure bash V5.2+";
    time for i in "${bunch[@]}"; do b64ToHex52 -v Hx5 "$inString"; done;
    printf ' - %-29s: ' "5 fork =\$(echo| base64 | xxd)";
    time for i in "${bunch[@]}"; do hex=$(base64_to_hex "$inString"); done;
    [[ $hx == "$hex" ]] && [[ $Hx == "$hx" ]] && [[ $Hx5 == "$hx" ]] &&
        printf -v inString '%b' ${hx//??/\\x&} &&
        printf 'Hopefully result strings are same (%s).\n' "${inString@Q}"
}

    Vamos mostrar com um pequeno milhar de operação:

    testB64decoders 1000

    Poderia produzir algo como:

     - 3 fork (base64 | xxd)        : r 0m2.032s,  u 0m2.315s,  s 0m0.699s, p 148.32
 - Pure bash                    : r 0m0.965s,  u 0m0.735s,  s 0m0.213s, p 98.14
 - Pure bash V5.2+              : r 0m0.571s,  u 0m0.477s,  s 0m0.088s, p 98.91
 - 5 fork =$(echo| base64 | xxd): r 0m2.433s,  u 0m3.242s,  s 0m0.989s, p 173.92

    Onde rpara real , u: usuário , s: tempo do sistema e p: porcentagem da CPU é:100 * ( u + s ) / r

    • puro é mais rápido,
    • puro usando bash 5.2+ é significativamente mais rápido,
    • versão usando xxde base64com apenas dois garfos será até um pouco mais rápida que
    • versão usando quatro forks (um subshell para executar mais três forks para xxd, base64e tr). Eles são os mais lentos e, sim: mais dois forks ocupam espaço no sistema.

    Nota: em um sistema multicore, usero tempo é maior que realo tempo, graças à paralelização

    No meu Raspberry-Pi II modelo B , tive que reduzir meu teste para 20 loops.

    testB64decoders 20

    Produziu no meu RPi II :

     - 3 fork (base64 | xxd)        : r 0m2.134s,  u 0m0.289s,  s 0m0.704s, p 46.55
 - Pure bash                    : r 0m1.931s,  u 0m0.890s,  s 0m0.104s, p 51.49
 - Pure bash V5.2+              : r 0m0.874s,  u 0m0.354s,  s 0m0.078s, p 49.36
 - 5 fork =$(echo| base64 | xxd): r 0m3.399s,  u 0m0.787s,  s 0m0.847s, p 48.06
Hopefully result strings are same ('Hello world! This is a test string.').
    • 4
  2. Best Answer

    xxd -ppode haver \ncaracteres na saída, então você precisa removê-los:

    base64_to_hex()
{
    echo "$1" | base64 --decode | xxd -p | tr -d '\n'
}

    Use sua string base64 como exemplo:

    $ hex=$( base64_to_hex OQbb8rXnj/DwvglW018uP/1tqldwiJMbjxBhX7ZqwTw= )
$ echo $hex
3906dbf2b5e78ff0f0be0956d35f2e3ffd6daa577088931b8f10615fb66ac13c
    • 3

relate perguntas