/*
- * Copyright (C) 2011 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2011 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
#include "crypt.h"
#include "crypt_backend.h"
#include "fd.h"
+#include "base64.h"
//#define GCRYPT_DEBUG 1
{
int i;
- fprintf(stderr, "%s (%u bytes): ", msg, len);
+ fprintf(stderr, "%s (%d bytes): ", msg, len);
for (i = 0; i < len; i++)
fprintf(stderr, "%02x ", buf[i]);
fprintf(stderr, "\n");
}
/*
- * This is called at the beginning of every program that uses libgcrypt. We
- * don't have to initialize any random seed here, but we must initialize the
- * gcrypt library. This task is performed by gcry_check_version() which can
- * also check that the gcrypt library version is at least the minimal required
- * version. This function also tells us whether we have to use our own OAEP
- * padding code.
+ * This is called at the beginning of every program that uses libgcrypt. The
+ * call to gcry_check_version() initializes the gcrypt library and checks that
+ * we have at least the minimal required version. This function also tells us
+ * whether we have to use our own OAEP padding code.
*/
void init_random_seed_or_die(void)
{
const char *ver, *req_ver;
+ int seed;
ver = gcry_check_version(NULL);
req_ver = "1.4.0";
libgcrypt_has_oaep = false;
rsa_decrypt_sexp = "(enc-val(rsa(a %m)))";
}
+ get_random_bytes_or_die((unsigned char *)&seed, sizeof(seed));
+ srandom(seed);
}
/** S-expression for the public part of an RSA key. */
-#define RSA_PUBKEY_SEXP "(public-key (rsa (n %m) (e %m)))"
+#define RSA_PUBKEY_SEXP "(public-key (rsa (n %m) (e %m)))"
/** S-expression for a private RSA key. */
#define RSA_PRIVKEY_SEXP "(private-key (rsa (n %m) (e %m) (d %m) (p %m) (q %m) (u %m)))"
{
gcry_error_t gret;
gcry_md_hd_t handle;
- size_t n;;
+ size_t n;
unsigned char *md;
unsigned char octet_string[4], *rp = result, *end = rp + result_len;
ret = mmap_full_file(key_file, O_RDONLY, &map, &map_size, NULL);
if (ret < 0)
- return ret;
+ goto out;
ret = -E_KEY_MARKER;
if (strncmp(map, header_str, strlen(header_str)))
goto unmap;
key[j++] = begin[i];
}
key[j] = '\0';
- //PARA_CRIT_LOG("key: %s\n", key);
- blob_size = key_size * 2;
- blob = para_malloc(blob_size);
- ret = base64_decode(key, blob, blob_size);
+ ret = base64_decode(key, j, (char **)&blob, &blob_size);
free(key);
if (ret < 0)
goto free_unmap;
+ ret = blob_size;
goto unmap;
free_unmap:
free(blob);
free(blob);
blob = NULL;
}
+out:
*result = blob;
return ret;
}
/* bit 6 has value 0 */
static inline bool is_primitive(unsigned char c)
{
- return ((c & (1<<6)) == 0);
+ return (c & (1<<6)) == 0;
}
static inline bool is_primitive_integer(unsigned char c)
{
if (!is_primitive(c))
return false;
- return ((c & 0x1f) == ASN1_TYPE_INTEGER);
+ return (c & 0x1f) == ASN1_TYPE_INTEGER;
}
/* Bit 8 is zero (and bits 7-1 give the length) */
{
const unsigned char *p = data, *end = data + len;
- /* the whole thing istarts with one sequence */
+ /* the whole thing starts with one sequence */
if (*p != ASN1_TYPE_SEQUENCE)
return -E_ASN1_PARSE;
p++;
for (i = 0; i < num_bytes; i++, cp++)
bn_size = (bn_size << 8) + *cp;
}
- PARA_DEBUG_LOG("bn_size %d (0x%x)\n", bn_size, bn_size);
+ PARA_DEBUG_LOG("bn_size %d (0x%x)\n", bn_size, (unsigned)bn_size);
gret = gcry_mpi_scan(bn, GCRYMPI_FMT_STD, cp, bn_size, NULL);
if (gret) {
PARA_ERROR_LOG("%s while scanning n\n",
if (p >= end)
return -E_ASN1_PARSE;
- /* Skip next integer */
+ /* skip next integer */
if (*p != ASN1_TYPE_INTEGER)
return -E_ASN1_PARSE;
p++;
ret = read_bignum(cp, end, &u, NULL);
if (ret < 0)
goto release_q;
- cp += ret;
/*
* OpenSSL uses slightly different parameters than gcrypt. To use these
* parameters we need to swap the values of p and q and recompute u.
ret = read_bignum(cp, end, &e, NULL);
if (ret < 0)
goto release_n;
- cp += ret;
gret = gcry_sexp_build(&sexp, &erroff, RSA_PUBKEY_SEXP, n, e);
if (gret) {
}
key = para_malloc(sizeof(*key));
key->sexp = sexp;
+ key->num_bytes = n_size;
*result = key;
ret = n_size;
- PARA_INFO_LOG("successfully read %u bit asn public key\n", n_size * 8);
+ PARA_INFO_LOG("successfully read %d bit asn public key\n", n_size * 8);
release_e:
gcry_mpi_release(e);
size_t nr_scanned, erroff, decoded_size;
gcry_mpi_t e = NULL, n = NULL;
- PARA_DEBUG_LOG("decoding %d byte public rsa-ssh key\n", size);
- if (size > INT_MAX / 4)
- return -ERRNO_TO_PARA_ERROR(EOVERFLOW);
- blob = para_malloc(2 * size);
- ret = uudecode((char *)data, blob, 2 * size);
+ PARA_DEBUG_LOG("decoding %d byte public rsa-ssh key\n", size);
+ ret = uudecode((char *)data, size, (char **)&blob, &decoded_size);
if (ret < 0)
goto free_blob;
- decoded_size = ret;
end = blob + decoded_size;
dump_buffer("decoded key", blob, decoded_size);
ret = check_ssh_key_header(blob, decoded_size);
goto release_n;
}
ret = nr_scanned / 32 * 32;
- PARA_INFO_LOG("successfully read %u bit ssh public key\n", ret * 8);
+ PARA_INFO_LOG("successfully read %d bit ssh public key\n", ret * 8);
release_n:
gcry_mpi_release(n);
release_e:
key->num_bytes = ret;
key->sexp = sexp;
*result = key;
- ret = key->num_bytes;
unmap:
ret2 = para_munmap(map, map_size);
if (ret >= 0 && ret2 < 0)
PARA_DEBUG_LOG("decrypted buffer before unpad (%d bytes):\n",
key_size);
- dump_buffer("non-unpadded decrypted buffer", oaep_buf, key_size);;
+ dump_buffer("non-unpadded decrypted buffer", oaep_buf, key_size);
ret = unpad_oaep(oaep_buf, key_size, outbuf, nbytes);
if (ret < 0)
goto out_mpi_release;
PARA_DEBUG_LOG("decrypted buffer after unpad (%zu bytes):\n",
*nbytes);
- dump_buffer("unpadded decrypted buffer", outbuf, *nbytes);;
+ dump_buffer("unpadded decrypted buffer", outbuf, *nbytes);
ret = 1;
out_mpi_release:
gcry_mpi_release(out_mpi);
gcry_sexp_t in, out, priv_key;
size_t nbytes;
+ ret = check_key_file(key_file, true);
+ if (ret < 0)
+ return ret;
PARA_INFO_LOG("decrypting %d byte input\n", inlen);
/* key_file -> asymmetric key priv */
ret = get_private_key(key_file, &priv);
gcry_cipher_hd_t handle;
};
-struct stream_cipher *sc_new(const unsigned char *data, int len)
+struct stream_cipher *sc_new(const unsigned char *data, int len,
+ bool use_aes)
{
gcry_error_t gret;
-
struct stream_cipher *sc = para_malloc(sizeof(*sc));
+
+ if (use_aes) {
+ assert(len >= 2 * AES_CRT128_BLOCK_SIZE);
+ gret = gcry_cipher_open(&sc->handle, GCRY_CIPHER_AES128,
+ GCRY_CIPHER_MODE_CTR, 0);
+ assert(gret == 0);
+ gret = gcry_cipher_setkey(sc->handle, data,
+ AES_CRT128_BLOCK_SIZE);
+ assert(gret == 0);
+ gret = gcry_cipher_setctr(sc->handle,
+ data + AES_CRT128_BLOCK_SIZE, AES_CRT128_BLOCK_SIZE);
+ assert(gret == 0);
+ return sc;
+ }
gret = gcry_cipher_open(&sc->handle, GCRY_CIPHER_ARCFOUR,
GCRY_CIPHER_MODE_STREAM, 0);
if (gret) {
free(sc);
}
-int sc_send_bin_buffer(struct stream_cipher_context *scc, char *buf,
- size_t size)
+void sc_crypt(struct stream_cipher *sc, struct iovec *src, struct iovec *dst)
{
+ gcry_cipher_hd_t handle = sc->handle;
gcry_error_t gret;
- int ret;
- unsigned char *tmp = para_malloc(size);
- assert(size);
- gret = gcry_cipher_encrypt(scc->send->handle, tmp, size,
- (unsigned char *)buf, size);
- assert(gret == 0);
- ret = write_all(scc->fd, (char *)tmp, &size);
- free(tmp);
- return ret;
-}
-
-int sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf,
- size_t size)
-{
- gcry_error_t gret;
- ssize_t ret = recv(scc->fd, buf, size, 0);
-
- if (ret < 0)
- ret = -ERRNO_TO_PARA_ERROR(errno);
- if (ret <= 0)
- return ret;
/* perform in-place encryption */
- gret = gcry_cipher_encrypt(scc->recv->handle, (unsigned char *)buf, ret,
+ *dst = *src;
+ gret = gcry_cipher_encrypt(handle, src->iov_base, src->iov_len,
NULL, 0);
assert(gret == 0);
- return ret;
}
projects / paraslash.git / blobdiff