XOR au niveau du bit d'une chaîne en Bash

Je suis en train d'accomplir un travail dans les scripts Bash. J'ai une chaîne qui je veux XOR avec ma clé.

#!/bin/sh
PATH=/bin:/usr/bin:/sbin:/usr/sbin export PATH

teststring="abcdefghijklmnopqr"

Maintenant, comment puis-je XOR la valeur de chaîne de test et de le stocker dans une variable à l'aide de bash?

Toute aide sera appréciée.

Fondamentalement, je suis en train d'essayer de reproduire le résultat de follwing VB Script:

Function XOREncryption(CodeKey, DataIn)

Dim lonDataPtr
Dim strDataOut
Dim temp
Dim tempstring
Dim intXOrValue1
Dim intXOrValue2


For lonDataPtr = 1 To Len(DataIn) Step 1
    'The first value to be XOr-ed comes from the data to be encrypted
    intXOrValue1 = Asc(Mid(DataIn, lonDataPtr, 1))
    'The second value comes from the code key
    intXOrValue2 = Asc(Mid(CodeKey, ((lonDataPtr Mod Len(CodeKey)) + 1), 1))

    temp = (intXOrValue1 Xor intXOrValue2)
    tempstring = Hex(temp)
    If Len(tempstring) = 1 Then tempstring = "0" & tempstring

    strDataOut = strDataOut + tempstring
Next
XOREncryption = strDataOut
End Function

Ne serait-il pas juste être teststring="abcdefghijklmnopqr" ^ key?
dosen';t de travail
peut-être que si il ya une manière de passer la valeur de chaîne de test en perl à partir de script bash et XOR.
Il semble que votre essayer de faire une sorte de mot de passe de dissimulation ou de chiffrement dans bash. Perl ou python serait probablement un meilleur choix de la langue.
il semble qu'il ne peut pas être fait de demeurer tous en bash.. donc peut-être que vous devez vous en tenir à perl, ou utiliser quelque chose de plus léger que l'interprète d'une langue; par exemple, od et sed pourrait être utilisé, par exemple: echo $(( $(echo -n "c" |od -td1 |sed -e 's/^[0-9]\+ *//g;') ^ 1 )); mettez votre char au lieu de "c"... ce qui est préférable si vous faites cela comme une fonction, alors vous pouvez diviser char par char la chaîne et appliquer le xor (peut-être xorring char par char n'était pas ce que tu voulais...; si vous avez besoin d'xorring deux mêmes chaînes de longueur, vous pouvez séparer les deux et de "construire" le résultat; sinon chaîne ^ entier ... que voulez-vous dire?

OriginalL'auteur ricky2002 | 2010-06-02

Avec l'aide de ces conseils j'ai écrit rapidement script pour terminer Pedro réponse:

#!/bin/bash

function ascii2dec
{
  RES=""
  for i in `echo $1 | sed "s/./& /g"`
  do 
    RES="$RES `printf \"%d\" \"'$i\"`"
  done 
  echo $RES
}

function dec2ascii
{
  RES=""
  for i in $*
  do 
    RES="$RES`printf \\\$(printf '%03o' $i)`"
  done 
  echo $RES
}

function xor
{
  KEY=$1
  shift
  RES=""
  for i in $*
  do
    RES="$RES $(($i ^$KEY))"
  done

  echo $RES
}


KEY=127
TESTSTRING="abcdefghijklmnopqr"

echo "Original String: $TESTSTRING"
STR_DATA=`ascii2dec "$TESTSTRING"`
echo "Original String Data: $STR_DATA"
XORED_DATA=`xor $KEY $STR_DATA`
echo "XOR-ed Data: $XORED_DATA"
RESTORED_DATA=`xor $KEY $XORED_DATA`
echo "Restored Data: $RESTORED_DATA"
RESTORED_STR=`dec2ascii $RESTORED_DATA`
echo "Restored String: $RESTORED_STR"

Résultat:

iMac:Desktop fer$ bash test.sh
Original String: abcdefghijklmnopqr
Original String Data: 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 
XOR-ed Data: 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13
Restored Data: 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 
Restored String: abcdefghijklmnopqr

C'est XORing avec une touche d'un seul octet.

OriginalL'auteur Fernando Miguélez

Si vous décidez d'aller pour Perl one-liner, voici ce que je suis venu avec

perl -e '@a=split("", $ARGV[0]); @b=split("", $ARGV[1]); print unpack "H2", chr(ord(shift @a)^ord(shift @b)) while @a; print "\n"' aab aaa

zip fonction Perl 6 serait mieux...

OriginalL'auteur Arkadiy

1

encore une autre réponse
```
function xenc {
  local data=$1 key=$2
  local _data _key ndata nkey count i _res
  _data=($(eval printf "'%d '" $(printf "%s" "$data" | sed -e '$!N;${s/./"'"'"'&" /g;s/""/\\&/g}')))
  _key=($(eval printf "'%d '" $(printf "%s" "$key" | sed '$!N;${s/./"'"'"'&" /g;s/""/\\&/g}')))
  ndata=${#_data[@]} nkey=${#_key[@]}
  (( count = ndata < nkey ? nkey : ndata ))
  for ((i = 0; i < count; i++)); do
    (( _res[i] = ${_data[i]:-0} ^ ${_key[i%nkey]:-0} ))
  done
  printf "\\\\\\%o" "${_res[@]}"  | xargs printf
}
res=$(xenc abcdefghijklmnopqrstuvwxyz FLqFb8LU0TY)
xenc "$res" FLqFb8LU0TY
```
Vous pouvez utiliser une boucle data=abcdef; for ((i=0;i<${#data};i++)); do printf '%d ' "'${data:i:1}"; done pour éviter la construction complexe en utilisant eval et d'appeler une commande externe sed.
Comme il est très possible d'émettre des caractères de contrôle avec le xor, il est raisonnable de présenter le résultat codé comme chiffres hexadécimaux (comme la question de la demande).
En fait, c'est une solution raisonnable à la question posée: Un script bash pour xor de deux chaînes de caractères (ascii des valeurs). à cet effet, le changement printf "\\\\\\%o" "${_res[@]}" | xargs printf le plus simple printf '%02x' "${_res[@]}"

OriginalL'auteur Cyrille Lefevre
0

Bit à bit OU exclusif en BASH nécessite à la fois des opérandes numériques. Depuis il n'y a pas intégré de manière à obtenir des ordinal (ASCII) de la valeur d'un caractère dans bash, vous aurez besoin de l'utiliser, de le dire, Perl, pour obtenir cette valeur.

Modifier: comme indiqué ci-dessous, ord travaille sur le premier caractère d'une chaîne.
```
let a=`perl -e 'print ord $_ for split //, $ARGV[0]' string`^123; echo $a
```
Bien sûr, une fois que vous êtes en Perl, vous pourriez aussi bien le faire tout est là:
```
let a=`perl -e '$ordinal .= ord $_ for split //, $ARGV[0]; print $ordinal ^ $ARGV[1]' string 123`
```
Modifier: il s'avère, vous pouvez saisir la valeur ordinale d'une chaîne de BASH en utilisant printf. Tout simplement le préfixe de la chaîne de '.
```
printf "%d" "'string"
```
Donc, dans BASH seulement:
```
let a=$(printf "%d" "'string")^123; echo $a
```
j'ai quelque chose comme ça en bash mais son score 0 en sortie... username=whoami test=perl -e 'print ord $strUrl ^ key' echo ${test} ai-je fait une erreur?
Vous avez besoin d'envelopper le perl commande en soit backticks ou $(). Aussi, $strUrl est pas défini, et key est un mot nu.
Est-ce la bonne façon de le faire? je suis un nombre à deux chiffres comme sortie mais je m'attendais à un numéro de long. key=secret strUrl=cdcdcdc strUrl=$(($(printf "%d" "'strUrl")^$(printf "%d" ""clé")));echo $strUrl
ord opère sur un seul personnage, donc ord $ARGV[0] renvoie la valeur ordinale de la le premier caractère de $ARGV[0]
Vous obtenez le résultat en format décimal. Convertir en binaire avec unpack("N", pack("B32", substr("0" x 32 . $decimal, -32)))

OriginalL'auteur Pedro Silva

woks dans busybox(la pâte ne pouvait pas recevoir de deux ruisseaux), a également fait la clé de répéter

#!/bin/sh
numitems() { i=0;while read ITEM; do i=$(( $i + 1 )) ; done; echo $i; }
starmap() { while read ITEM; do $1 $ITEM; done; }
ord() { printf '%d\n' "'$1"; }
chr() { printf \\$(printf '%03o' $1); }
split_chars() { echo -n "$1" | sed 's/./&\n/g'; }
xor() { echo $(($1 ^ $2)); }
map_ord() { split_chars "$1" | starmap ord; }
encrypt()
{
KEY=$1;STR=$2;
while [ ${#KEY} -lt ${#STR} ]; do KEY="$KEY$KEY"; done; #make key longer then str
[ -e /tmp/paste_col1 ] && rm -rf /tmp/paste_col1
[ -e /tmp/paste_col1t ] && rm -rf /tmp/paste_col1t
[ -e /tmp/paste_col2 ] && rm -rf /tmp/paste_col2
map_ord "$KEY">/tmp/paste_col1t
map_ord "$STR">/tmp/paste_col2
head -n `wc -l /tmp/paste_col2 |sed -r 's|^([0-9]+)\s.*|\1|'` /tmp/paste_col1t>/tmp/paste_col1 #trim lines
[ -e /tmp/paste_col1t ] && rm -rf /tmp/paste_col1t
paste /tmp/paste_col1 /tmp/paste_col2 | starmap xor | starmap chr
[ -e /tmp/paste_col1 ] && rm -rf /tmp/paste_col1
[ -e /tmp/paste_col2 ] && rm -rf /tmp/paste_col2
echo
}
KEY="12345678"
TESTSTRING="abcdefghasdfasdfasfdas"
encrypt "$KEY" "$TESTSTRING"
ENC="`encrypt \"$KEY\" \"$TESTSTRING\"`"
encrypt "$KEY" "$ENC" # we should get $TESTSTRING again

La sortie peut être n'importe quelle valeur d'un octet, chr qui produisent des caractères de contrôle n'est pas une bonne idée. C'est pourquoi le code de la question de l'utilisation Hex pour la sortie.

OriginalL'auteur Shimon Doodkin

Les plus similaires transformation de seulement la fonction de bash serait:

(# signifie commentaire):

# Function XOREncryption(CodeKey, DataIn)
XOREncryption(){
local CodeKey=$1
local DataIn=$2
# Dim lonDataPtr strDataOut temp tempstring intXOrValue1 intXOrValue2
local lonDataPtr strDataOut temp tempstring intXOrValue1 intXOrValue2
# For lonDataPtr = 1 To Len(DataIn) Step 1
for (( lonDataPtr=0; lonDataPtr < ${#DataIn}; lonDataPtr++ )); do
#The first value to be XOr-ed comes from the data to be encrypted
# intXOrValue1 = Asc(Mid(DataIn, lonDataPtr, 1))
intXOrValue1=$( toAsc "${DataIn:$lonDataPtr:1}" )
echo "val1=$intXOrValue1 and=<${DataIn:$lonDataPtr:1}> and $(toAsc "${DataIn:$lonDataPtr:1}")"
#The second value comes from the code key
echo "Ptr=$lonDataPtr Mod=<$(( lonDataPtr % ${#CodeKey} ))>"
# intXOrValue2 = Asc(Mid(CodeKey, ((lonDataPtr Mod Len(CodeKey)) + 1), 1))
intXOrValue2=$( toAsc "${CodeKey:$(( lonDataPtr % ${#CodeKey} )):1}" )
echo "val1=$intXOrValue1 val2=<${CodeKey:$(( lonDataPtr % ${#CodeKey} )):1}> and |$intXOrValue2|"
# temp = (intXOrValue1 Xor intXOrValue2)
temp=$(( intXOrValue1 ^ intXOrValue2 ))
echo "temp=$temp"
# tempstring = Hex(temp)
tempstring=$(printf '%02x' "$temp")
echo "tempstring=$tempstring"
# strDataOut = strDataOut + tempstring
strDataOut+=$tempstring
echo
# Next
done
# XOREncryption = strDataOut
printf '%s\n' "$strDataOut"
# End Function
}

Supprimé les commentaires, et le nettoyage du code:

#!/bin/bash
Asc() { printf '%d' "'$1"; }
XOREncryption(){
local key=$1 DataIn=$2
local ptr DataOut val1 val2
for (( ptr=0; ptr < ${#DataIn}; ptr++ )); do
val1=$( Asc "${DataIn:$ptr:1}" )
val2=$( Asc "${key:$(( ptr % ${#key} )):1}" )
DataOut+=$(printf '%02x' "$(( val1 ^ val2 ))")
done
printf '%s\n' "$DataOut"
}
CodeKey="$1"
teststring="$2"
XOREncryption "$CodeKey" "$teststring"

De course:

$ ./script.sh "123456789" "abcdefghijklmnopqr"
5050505050505050505b595f595b5947494b

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.