Administrace komentářů

Tyhle domácí úkoly… Podle mě to postrádá smysl, pokud je člověk nevyřeší nějak samostatně. Není jasné, o jakou šifru se jedná. Takže Bash může umět třeba tohle:

$ string2base64 tajny-text
dGFqbnktdGV4dA==

$ string2base64 tajny-text | base64 -d
tajny-text

Implementace string2base64 se dá klidně udělat à la prase — například následující věc je v čistém Bashi bez dalších procesů. Ale neumí to ani náhodou Unicode a dokonce to neumí správně ošetřit nulový byte. Ale jinak to téměř funguje. Specifikace je třeba tady. Dekodér z base64 zpět do plaintextu si pozorný čtenář zajisté dovede sám naimplementovat za cvičení, podobně jako drobnou úpravu, která by string2base64 umožnila zpracovávat stream neomezené délky. Výkonnostních optimalizací se tam nabízí tři spousty a půl.

#!/bin/bash

# Creates a global mapping from ASCII bytes 1..255 to their binary codes.
# For example, 'a' (i.e., ${#BYTE2CODE['a']}) maps to '01100001'.
initcache() {
  if ((255 != "${#BYTE2CODE[@]}")); then
    declare -Ag BYTE2CODE
    local -i i
    for ((i = 1; i < 256; ++i)); do
      eval BYTE2CODE[$\'\\x"$(printf '%x' "$i")"\']="$(code2bin "$i")"
    done
  fi
}

# Translates an ASCII byte in decimal notation into an 8-digit binary literal.
# For example, argument '97' (otherwise known as 0x61 or 'a') yields '01100001'.
code2bin() {
  local -ai bits=(0 0 0 0 0 0 0 0)
  local -i number="$1"
  local -i idx=${#bits[@]}
  local -i i
  while ((number && idx)); do
    bits[--idx]='number % 2'
    ((number /= 2))
  done
  for ((i = 0; i < ${#bits[@]}; ++i)); do
      echo -n "${bits[i]}"
  done
}

# Translates a string into a binary representation suitable for base64 encoding.
# The first output line is the number of padding characters (0 to 2).
# Each subsequent line is a binary representation of 3 bytes or 4 base64 digits.
# For example, argument 'aa' yields '1' (1 padding symbol) on the first line and
# '011000010110000100000000' (24 bits of data) on the second line.
string2code() {
  local -ri equals=$(((3 - ${#1} % 3) % 3))
  local -i i
  local buffer="$equals"
  for ((i = 0; i < ${#1}; ++i)); do
    if ((!(i % 3))); then
      echo "$buffer"
      buffer=
    fi
    buffer+="${BYTE2CODE[${1:i:1}]}"
  done
  echo -n "$buffer"
  for ((i = 0; i < equals; ++i)); do
    code2bin 0
  done
  echo
}

# Translates 6 bits (a string of '0' and '1' characters) to a base64 digit.
# For example, argument '100111' (39 in decimal notation) yields 'n'.
bin2basechar() {
  local -ri code=2#"$1"
  local -a chars
  if ((code < 26)); then
    chars=(A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
    echo -n "${chars[code]}"
  elif ((code < 52)); then
    chars=(a b c d e f g h i j k l m n o p q r s t u v w x y z)
    echo -n "${chars[code - 26]}"
  elif ((code < 62)); then
    chars=(0 1 2 3 4 5 6 7 8 9)
    echo -n "${chars[code - 52]}"
  else
    chars=(+ /)
    echo -n "${chars[code - 62]}"
  fi
}

# Translates its first (and only) argument into base64.
# For example, argument 'doprdele' yields 'ZG9wcmRlbGU='.
string2base64() {
  local -a fragments
  local fragment
  local line
  local -i equals
  local -i i
  local chars
  initcache
  string2code "$1" | {
    read equals
    while read line; do
      echo -n "$chars"
      fragments=("${line:0:6}" "${line:6:6}" "${line:12:6}" "${line:18:6}")
      chars=
      for fragment in "${fragments[@]}"; do
        chars+="$(bin2basechar "$fragment")"
      done
    done
    if ((equals)); then
        echo -n "${chars:0:-equals}"
        for ((i = 0; i < equals; ++i)); do echo -n '='; done
    else
        echo -n "$chars"
    fi
    echo
  }
}

Pár příkladů, kde k zakódování používám výše uvedenou funkci string2base64 a k dekódování slouží base64 z coreutils:

$ string2base64 zzz$'\xa' 
enp6Cg==

$ string2base64 'bla bla bla'$'\xa' 
YmxhIGJsYSBibGEK

$ string2base64 zzz$'\xa' | base64 -d
zzz

$ string2base64 'bla bla bla'$'\xa' | base64 -d
bla bla bla

(Konce řádků jsou tam^^^ samozřejmě jen tak bezdůvodně, because we can.) A tady ještě drobný test, jestli to vůbec něco rozumného dělá:

for i in x{a..z} {A..Z}y a{0..9}b; do
  echo -n "${i} "
  string2base64 "$i" | base64 -d
  echo
done