4

I have a password stored in a shell variable (which was read from command line input).

I also have a keyfile stored in a file (which was created using dd and /dev/urandom).

Since I want to require both of those to decrypt my hard drive, I would like to XOR them, store it in a file and use that as key.

I would therefore like to know what the simplest way of doing that would be.

xxd would be a perfect fit if it allowed -b and -p at the same time but apparently, it doesn't...

Edit: I'll use it in https://github.com/xavierm02/combine-keys

Improve this question
14
  • 3
    Instead of building your own cryptosystem (almost always a bad idea), have you considered using LUKS/dmsetup support for encrypted keyfiles? That give the two-factor authentication you seem to want. E.g., see wiki.archlinux.org/index.php/Dm-crypt/… ... or see also gpg's --symmetric option. Commented May 5, 2014 at 19:03
  • I don't want to mess too much with the initramfs and the configuration of those things so I installed everything with the Debian installer and used passwords and now I'm planning on using cryptsetup to replace those passwords with my new key. Commented May 5, 2014 at 19:21
  • 1
    @derobert : I want to be able to backup parts of the keyfile in several geographically distant places. If I encrypted it with the password, getting those backups would allow to bypass the password (if I backed the non-encrypted version) or would force me to update all the backups whenever I changed the password (of I backed the encrypted version) so it's not exactly what I want and while trying to do it, I found out that I'd have to mess with the initramfs to make it work so while I'm at it, I could just get the two passwords myself and give it a new password computed with those two. Commented May 5, 2014 at 19:33
  • 1
    @xavierm02 Ah! OK, I understand then. You're trying to implement some form of secret sharing. There is an ssss package implementing secret sharing, and also bugs.debian.org/cgi-bin/bugreport.cgi?bug=617311 Commented May 5, 2014 at 19:38
  • 1
    I still don't get why concatting won't work. You lose security by doing an XOR operation, as multiple combinations can result in the same output (which is why implementing your own cryptosystem is often a bad idea). cryptsetup just reads a file as a key. It doesn't care what's in the file. It could be ascii, or arbitrary binary, it makes no difference. Commented May 5, 2014 at 19:51

3 Answers 3

Reset to default
2

Your shell can handle bitwise ops, though, for any serious processing, it's going to be awfully slow, and it can't handle anything more than say 20 or so digits at a time. Still:

sh <<\CMD 
    printf 'printf "%%b" "\\0$((%04o^04))"'  "'a" |\
    . /dev/stdin
CMD

#OUTPUT
A

I've used bc in the past for grabbing bytes in binary, so your question set me to googling for...

Exclusive-or (XOR) for GNU bc

If you've found your way across the internet to this question, chances are you're looking for bc's equivalent of C's ^ operator.

Disturbing fact: no such thing exists in bc. In bc, the up-arrow operator is used for integer exponentiation, that is, 2^x returns a power of 2 and not x with bit 2 flipped. If you're looking for equivalents to the bitwise operators for XOR as well as AND, OR and a few more exotic relatives, check out this site's logic.bc, and its relatives which contain functions to perform each of these.

If you're looking for a logical XOR to put in an if statement, like logical && and ||, try using != and surrounding your conditions with brackets. e.g.:

c=0;if((a==1)!=(b==2)){c=3}

Will set c to 3, if a is 1 or b is 2, but not if a is 1 and b is 2 at the same time

(Once upon a time, this was the secret to the internals of the logic.bc xor() function, but this has been superseded by a faster algorithm.)

The above is from the bc FAQ. The logic.bc function alluded to above includes the bitwise logic you're looking for. It can be found here. Its description:

A large suite of functions to perform bitwise functions such as AND, OR, NOT and XOR. Uses twos complement for negative numbers, unlike previous versions of this file, which had no support at all. Some of the functions here will use the global bitwidth variable, which itself is initialised as part of this file, to emulate byte/word sizes found in most computers. If this variable is set to zero, an infinite bitwidth is assumed. Many functions will display a warning if there is suspicion that a secondary floating point representation of a number has been generated, e.g.:

1.1111... is an SFPR of10.0000...;`

These warnings can be disabled by setting the global variable sfpr_warn to 0 (default is 1).

  • Fixed word size
  • Infinite word size
  • Common bitwise
  • Twos complement
  • Bit shifting
  • Gray code
  • 'Multiplication'
  • Floating point
  • Floating point 'Multiplication'
  • Gray code + Floating point
Improve this answer
5
  • This is a description of a logical (boolean) xor operation, not a binary (bit-by-bit) xor the OP was asking for. Commented May 6, 2014 at 5:42
  • @danielkullmann - very good point, thanks. I'll have the update live in a moment. Commented May 6, 2014 at 5:47
  • 1
    @danielkullmann - it's a little better now. Commented May 6, 2014 at 6:24
  • You code would be much easier to read if you used variables instead of having this expression with a printf printing a printf... Anyway, I'll accept this answer but still go with the C binary since it will be way faster. Commented May 6, 2014 at 10:42
  • @xavierm02 - You don't have to accept this - your answer is way better than mine. This was just an alternative because I thought your question was a very good one (just now remembered to upvote it though - sorry) and I had a tiny bit of knowledge that some others who happen upon it in future might be able to use. You know - for progeny or whatever. I'll fix the printf statement - but not with shell variables - it's slow enough as it is. Commented May 6, 2014 at 11:05
1

I used a C binary.

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "No argument given.\n");
        exit(1);
    }
    char *filename = argv[1];

    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        fprintf(stderr, "Could not open given file.");
        exit(1);
    }
    int c1;
    int c2;
    do {
        c1 = fgetc(stdin);
        c2 = fgetc(file);
        if (c1 == EOF) {
            while (c2 != EOF) {
                printf("%c", c2);
                c2 = fgetc(file);
            }
            break;
        } else  if (c2 == EOF) {
            while (c1 != EOF) {
                printf("%c", c1);
                c1 = fgetc(stdin);
            }
            break;
        }
        int c = c1 ^ c2;
        printf("%c", c);
    } while (true);

    exit(0);
}
Improve this answer
0

I got something nearly working in SH but it's way too slow

#!/bin/sh

small_hex_to_bin() {
    hex=$1
    hex_length=${#1}
    bin=$(echo "ibase=16;obase=2;$hex" | bc)
    bin_length=$((4*$hex_length))
    bin=$(printf %0*d $bin_length $bin)
    echo $bin
}

hex_to_bin() {
    hex=$1
    hex_length=${#hex}
    for i in $(seq 1 $hex_length); do
        hex_digit=$(expr substr $hex $i 1)
        bin_digits=$(small_hex_to_bin $hex_digit)
        echo -n $bin_digits
    done
    echo ""
}

bin_to_hex() {
    bin=$1
    hex=$(echo "ibase=2;obase=10000;$bin" | bc)
    echo $hex
}

char_to_hex() {
    char=$1
    hex_lower=$(printf %x \'$char\')
    hex=$(echo $hex_lower | tr '[:lower:]' '[:upper:]')
    echo $hex
}

char_to_bin() {
    char=$1
    hex=$(char_to_hex $char)
    bin=$(small_hex_to_bin $hex)
    echo $bin
}

string_to_bin() {
    s=$1
    l=${#s}
    for i in $(seq 1 $l); do
        char=$(expr substr $s $i 1)
        bin=$(char_to_bin $char)
        echo -n $bin
    done
    echo ""
}

file_to_bin() {
    filename=$1
    hex_spaces=$(xxd -u -p $filename)
    hex=$(echo $hex_spaces | tr -d '\n' | tr -d ' ')
    bin=$(hex_to_bin $hex)
    echo $bin
}

min() {
    if [ $1 -ge $2 ]; then
        echo $2
    else
        echo $1
    fi
}

bit_xor() {
    if [ $1 -eq $2 ]; then
        echo 0
    else
        echo 1
    fi
}

xor() {
    b1=$1
    b2=$2
    l1=${#b1}
    l2=${#b2}
    l=$(min $l1 $l2)
    for i in $(seq 1 $l); do
        c1=$(expr substr $b1 $i 1)
        c2=$(expr substr $b2 $i 1)
        c=$(bit_xor $c1 $c2)
        echo -n $c
    done
    next_i=$(($l + 1))
    if [ $l -ne $l1 ]; then
        for i in $(seq $next_i $l1); do
            c1=$(expr substr $b1 $i 1)
            echo -n $c1
        done
    fi
    if [ $l -ne $l2 ]; then
        for i in $(seq $next_i $l2); do
            c2=$(expr substr $b2 $i 1)
            echo -n $c2
        done
    fi
    echo ""
}

#stdin=$(cat)
#file=$(cat $1)
#hex_to_bin $1
file_to_bin $1
Improve this answer
5
  • Don't use that, guy. This is how you do it in the shell: _c2o() { od -A n -t o1 -w1 -v ; } Commented May 6, 2014 at 18:53
  • And if you want to do case conversion, dd is the tool for you. Commented May 6, 2014 at 18:54
  • for i in seq is bad. You've gotta steer clear of common shell/readline constructs and work with files and streams. For instance: eval printf "%*s" "$(seq -s' "$var" ' ${#var})" should take a variable apart char by char in one shell op. But better than that is dd cbs=1 conv=unblock or od -A n -a -w1. Also, I have a bunch of these little functions and things if you want - with bc even, including a simple echo sttement for streamed binary conversion. But C was a better way to go if you ask me... Commented May 6, 2014 at 19:01
  • I did go with C. You're saying I should use stream. But since I have two inputs (for the xor part) I don't see how I could do that. (For the rest of it, I guess it'd be possible) Commented May 6, 2014 at 22:08
  • You would have to select the bits out of the stream and keep them streaming - i dont know C but i once did something similar to your XOR function. I computed all possible upper-lower case variations for an arbitrary char string by requesting all the binary representations of the numbers from 0 to string $len and then translating 1 to lower and 0 to upper for my string. I did this in the shell and i used a lot of tees to sort of ring-buffer the stream as i selected from the stream. The problem with the above is every $(sub) is a blocking op - youll never get anything done. Commented May 6, 2014 at 22:14

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.