El algoritmo de clave pública más rápido para fines de prueba

5

Como parte de un conjunto de pruebas automatizado, necesito ejecutar una gran cantidad de procesos gpg --encrypt y gpg --decrypt .

Para que cada invocación de gpg --encrypt y gpg --decrypt sea más rápida, me gustaría usar un algoritmo de clave pública muy rápido.

Entiendo que los cifrados más rápidos también son los que brindan la seguridad más débil, especialmente en tamaños de clave pequeños. Sin embargo, la seguridad no es un tema importante en este caso: la clave sin frase de contraseña incluso se publica públicamente como parte de la suite de prueba.

Como referencia, esto es lo que admite mi versión de GnuPG:

Pubkey: RSA, ELG, DSA
Cipher: 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH, CAMELLIA128, 
        CAMELLIA192, CAMELLIA256
Hash: MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Para resumir, ¿cuál es la combinación más rápida de algoritmo y longitud de clave disponible en GnuPG?

    
pregunta gioele 08.06.2014 - 12:03
fuente

1 respuesta

2

Eso va a variar de una máquina a otra y de un binario GPG a un binario GPG; ¿La máquina ofrece instrucciones AES-NI? ¿Las usa su binario GPG? ¿Está utilizando operaciones de 64 bits? ¿Las instrucciones XOP o AVX están disponibles y son utilizadas por su binario, etc.?

Solo hay una respuesta: evalúelo en su configuración particular.

Daniel Kahn Gillmor publicó tal script de referencia en los usuarios de gnupg lista en 2010, que incluye una suma SHA1 y una firma, naturalmente.

Tenga en cuenta que la salida es del comando de tiempo de Unix, formateado como + en segundos.

Si quieres algo diferente, ¡entonces modifica el script!

#!/bin/sh

# Author: Daniel Kahn Gillmor <[email protected]>
# Date: Tue, 28 Sep 2010 14:25:19 -0400

# This script produces some roughly-formatted OpenPGP performance data
# against different algorithms and keysizes


set -e

REPEAT=100
ASYM_ALGOS="RSA DSA"
KEY_SIZES="1024 2048 3072 4096"
DIGESTS="SHA1 SHA224 SHA256 SHA384 SHA512"
CIPHERS="3DES AES AES192 AES256"

if gpg --debug-quick-random --version >/dev/null 2>/dev/null ; then
    QUICKRANDOM=--debug-quick-random
elif gpg --quick-random --version >/dev/null 2>/dev/null ; then
    QUICKRANDOM=--quick-random
else
    printf "don't know how to set quick random number generation"
    exit 2
fi

encalgo() {
    if [ "$1" = "DSA" ]; then
    printf "ELG-E"
    else
    printf "%s" "$1"
    fi
}

describe_system() {
    # FIXME: this is fairly Linux-specific.  it'd be better to use
    # something more generic to get info about the CPU and RAM
    # available:
    cat /proc/cpuinfo 2>&1 || :
    free 2>&1 || :
    uname -a
    gpg --version
}

# quick key creation:
setup() {
    rm -f testmsg
    for rep in $(seq 1 25) ; do
    echo "this is a test message for benchmarking OpenPGP signature validation times." >> testmsg
    done
    for algo in $ASYM_ALGOS; do
    for size in $KEY_SIZES; do
        if [ "$algo" = "DSA" ] && [ "$size" -gt 3072 ]; then
        # gpg can't do DSA > 3072 bits
        continue
        fi
        mkdir -m 0700 -p ${algo}-${size}
        if printf 'Key-Type: %s
Key-Length: %s
Key-Usage: sign
Subkey-Type: %s
Subkey-Length: %s
Subkey-Usage: encrypt
Name-Real: OpenPGP Benchmark Key %s %s bits
Name-Comment: DO NOT USE!
' "$algo" "$size" $(encalgo "$algo") "$size" "$algo" "$size" | GNUPGHOME=${algo}-${size} gpg $QUICKRANDOM --batch --gen-key ; then
        for digest in $DIGESTS; do
            output=${algo}-${size}/testmsg.${algo}-${size}-${digest}.asc
            if ! GNUPGHOME=${algo}-${size} gpg --digest-algo "$digest" --clearsign < testmsg > ${output} ; then
            rm -f ${output}
            fi
        done

        for cipher in $CIPHERS; do
            output=${algo}-${size}/testmsg.${algo}-${size}-${cipher}.asc
            if ! GNUPGHOME=${algo}-${size} gpg --armor --cipher-algo "$cipher" --encrypt -r 'Benchmark' < testmsg > ${output} ; then
            rm -f ${output}
            fi
        done
        else
        rm -rf ${algo}-${size}
        fi
    done
    done
}


signing() {
    for algo in $ASYM_ALGOS ; do
    printf '%s Signing (x%d)\n' $algo $REPEAT
    for length in 'digest:' $KEY_SIZES; do
        if [ -d "${algo}-${length}" ] || [ "$length" = 'digest:' ]; then
        printf '%s\t' "$length"
        for digest in $DIGESTS; do
            if [ "$length" = 'digest:' ]; then
            printf '%s\t' "$digest"
            else
            for x in ${algo}-${length}/*; do
                cat < "$x" > /dev/null
            done
            targfile=${algo}-${length}/testmsg.${algo}-${length}-${digest}.asc
            if [ -e $targfile ]; then
                stats=$(bash -c "time -p for seq in $(seq 1 $REPEAT | tr '\n' ' '); do
GNUPGHOME=${algo}-${length} gpg --digest-algo $digest --sign >/dev/null 2>/dev/null < ./testmsg
done" 2>&1)
                printf '%s+%s\t' $(printf "%s" "$stats" | grep ^user | cut -f2 -d' ') $(printf "%s" "$stats" | grep ^sys | cut -f2 -d' ')
            else
                printf 'X\t'
            fi
            fi
        done
        printf '\n'
        fi
    done
    done
}

verifying() { 
    for algo in $ASYM_ALGOS ; do
    printf '%s Verifying (x%d)\n' $algo $REPEAT
    for length in 'digest:' $KEY_SIZES; do
        if [ -d "${algo}-${length}" ] || [ "$length" = 'digest:' ]; then
        printf '%s\t' "$length"
        for digest in $DIGESTS; do
            if [ "$length" = 'digest:' ]; then
            printf '%s\t' "$digest"
            else
            for x in ${algo}-${length}/*; do
                cat < "$x" > /dev/null
            done
            targfile=${algo}-${length}/testmsg.${algo}-${length}-${digest}.asc
            if [ -e $targfile ]; then
                stats=$(bash -c "time -p for seq in $(seq 1 $REPEAT | tr '\n' ' '); do
GNUPGHOME=${algo}-${length} gpg --verify >/dev/null 2>/dev/null < $targfile
done" 2>&1)
                printf '%s+%s\t' $(printf "%s" "$stats" | grep ^user | cut -f2 -d' ') $(printf "%s" "$stats" | grep ^sys | cut -f2 -d' ')
            else
                printf 'X\t'
            fi
            fi
        done
        printf '\n'
        fi
    done
    done
}


encrypting() {
    for algo in $ASYM_ALGOS ; do
    printf '%s Encrypting (x%s)\n' $(encalgo "$algo") $REPEAT
    for length in 'cipher:' $KEY_SIZES; do
        if [ -d "${algo}-${length}" ] || [ "$length" = 'cipher:' ]; then
        printf '%s\t' "$length"
        for cipher in $CIPHERS; do
            if [ "$length" = 'cipher:' ]; then
            printf '%s\t' "$cipher"
            else
            for x in ${algo}-${length}/*; do
                cat < "$x" > /dev/null
            done
            targfile=${algo}-${length}/testmsg.${algo}-${length}-${cipher}.asc
            if [ -e $targfile ]; then
                stats=$(bash -c "time -p for seq in $(seq 1 $REPEAT | tr '\n' ' '); do
GNUPGHOME=${algo}-${length} gpg --cipher-algo $cipher --encrypt -r Benchmark >/dev/null 2>/dev/null < ./testmsg
done" 2>&1)
                printf '%s+%s\t' $(printf "%s" "$stats" | grep ^user | cut -f2 -d' ') $(printf "%s" "$stats" | grep ^sys | cut -f2 -d' ')
            else
                printf 'X\t'
            fi
            fi
        done
        printf '\n'
        fi
    done
    done
}


decrypting() {
    for algo in $ASYM_ALGOS ; do
    printf '%s Decrypting (x%s)\n' $(encalgo "$algo") $REPEAT
    for length in 'cipher:' $KEY_SIZES; do
        if [ -d "${algo}-${length}" ] || [ "$length" = 'cipher:' ]; then
        printf '%s\t' "$length"
        for cipher in $CIPHERS; do
            if [ "$length" = 'cipher:' ]; then
            printf '%s\t' "$cipher"
            else
            for x in ${algo}-${length}/*; do
                cat < "$x" > /dev/null
            done
            targfile=${algo}-${length}/testmsg.${algo}-${length}-${cipher}.asc
            if [ -e $targfile ]; then
                stats=$(bash -c "time -p for seq in $(seq 1 $REPEAT | tr '\n' ' '); do
GNUPGHOME=${algo}-${length} gpg --decrypt >/dev/null 2>/dev/null < $targfile
done" 2>&1)
                printf '%s+%s\t' $(printf "%s" "$stats" | grep ^user | cut -f2 -d' ') $(printf "%s" "$stats" | grep ^sys | cut -f2 -d' ')
            else
                printf 'X\t'
            fi
            fi
        done
        printf '\n'
        fi
    done
    done
}


run() {
    WORKDIR=$(mktemp -d "${TMPDIR:-/tmp}/openpgp-benchmark.XXXXXX")
    OUTPUT=$(mktemp "$(pwd)/openpgp-benchmark.$(date +%F_%T | tr ':' '-').XXXXXX")
    printf 'Working in %s...\n' "$WORKDIR"
    cd "$WORKDIR"
    ( describe_system
        setup
        signing
        verifying
        encrypting 
        decrypting ) | tee "$OUTPUT"
    printf 'log written to %s...\nPlease mail back to Daniel Kahn Gillmor <[email protected]>.\n' "$OUTPUT"
}

action="$1"
if [ "x$action" = "x" ]; then
    action=run
fi

case "$action" in
    setup|describe_system|signing|verifying|encrypting|run)
        "$action"
        ;;
    *)
        echo "Usage: $0 [setup|describe_system|signing|verifying|encrypting|run]  " >&2
        exit 2
        ;;
esac
    
respondido por el Anti-weakpasswords 31.01.2016 - 05:24
fuente

Lea otras preguntas en las etiquetas