mirrors/libmicrohttpd
2
0
Fork 0
mirror of https://git.gnunet.org/libmicrohttpd.git synced 2026-09-25 04:09:31 +03:00
Code Issues Packages Projects Releases Wiki Activity

more DCE

Browse Source
This commit is contained in:
Christian Grothoff
2008-11-16 06:50:40 +00:00
parent 31ca44a13c
commit 5acebb9234
16 changed files with 81 additions and 2250 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README
+13
View File
@@ -79,6 +79,9 @@ Missing features:
instead of linking against it
- Make sure SSL works on non-GNU/Linux platforms
- MHD_tls_connection_close is not called in any testcase!???
(is it used properly in the code!?)
Untested features:
==================
@@ -94,6 +97,16 @@ Untested features:
- more testing for SSL support
Functions not covered by "make check":
======================================
- MHD_get_connection_values is not called in any testcase
- MHD_set_connection_value is not called in any testcase
- parse_cookie_header is not tested by any testcase
- parse_arguments is not tested by any testcase
- MHD_del_response_header is not called by any testcase
- MHD_get_response_headers is not called by any testcase
Missing documentation:
======================
src/daemon/Makefile.am
+23 -26
View File
@@ -1,19 +1,11 @@
# including '.' mixes up build order when HTTPS is enabled.
SUBDIRS =
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
endif
AM_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/x509 \
-I$(top_srcdir)/src/daemon/https/minitasn1 \
-I$(top_srcdir)/src/daemon/https/tls \
-I$(top_srcdir)/src/daemon/https \
-I$(GCRYPT_CPPFLAGS)
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/x509 \
-I$(top_srcdir)/src/daemon/https/minitasn1 \
-I$(top_srcdir)/src/daemon/https/tls \
-I$(top_srcdir)/src/daemon/https
if HAVE_GNU_LD
# If you want to debug with gdb, comment out this line:
@@ -26,20 +18,26 @@ lib_LTLIBRARIES = \
libmicrohttpd.la
libmicrohttpd_la_SOURCES = \
connection.c connection.h \
reason_phrase.c reason_phrase.h \
daemon.c \
internal.c internal.h \
memorypool.c memorypool.h \
postprocessor.c \
response.c response.h
connection.c connection.h \
reason_phrase.c reason_phrase.h \
daemon.c \
internal.c internal.h \
memorypool.c memorypool.h \
postprocessor.c \
response.c response.h
libmicrohttpd_la_LDFLAGS = \
-export-dynamic -version-info 4:3:0 $(retaincommand)
-version-info 4:3:0 \
-export-dynamic $(retaincommand)
if USE_COVERAGE
AM_CFLAGS = --coverage
endif
if ENABLE_HTTPS
SUBDIRS += https .
libmicrohttpd_la_SOURCES += connection_https.c connection_https.h
SUBDIRS = https .
libmicrohttpd_la_SOURCES += \
connection_https.c connection_https.h
libmicrohttpd_la_LIBADD = \
https/lgl/liblgl.la \
https/x509/libx509.la \
@@ -47,7 +45,6 @@ libmicrohttpd_la_LIBADD = \
https/minitasn1/libasn1.la
endif
check_PROGRAMS = \
postprocessor_test \
postprocessor_large_test \
src/daemon/https/lgl/Makefile.am
+13 -20
View File
@@ -1,10 +1,5 @@
SUBDIRS = .
AM_CPPFLAGS = -std=c99 \
-I$(top_srcdir)/src/include \
-I$(GCRYPT_CPPFLAGS)
# gc-gnulib.c
AM_CPPFLAGS = \
-I$(top_srcdir)/src/include
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
@@ -13,18 +8,16 @@ endif
noinst_LTLIBRARIES = liblgl.la
liblgl_la_LDFLAGS = -lgcrypt
# liblgl_la_LIBADD = ./gc-libgcrypt.lo
liblgl_la_SOURCES = \
sha1.c sha1.h \
gc-libgcrypt.c \
rijndael-api-fst.c rijndael-api-fst.h \
gc-pbkdf2-sha1.c gc.h \
rijndael-alg-fst.c rijndael-alg-fst.h \
hmac-md5.c hmac.h \
hmac-sha1.c \
memxor.c memxor.h\
strverscmp.c strverscmp.h \
md5.c md5.h \
des.c des.h
sha1.c sha1.h \
gc-libgcrypt.c \
rijndael-api-fst.c rijndael-api-fst.h \
gc-pbkdf2-sha1.c gc.h \
rijndael-alg-fst.c rijndael-alg-fst.h \
hmac-md5.c hmac.h \
hmac-sha1.c \
memxor.c memxor.h\
strverscmp.c strverscmp.h \
md5.c md5.h
src/daemon/https/lgl/des.c
-559
View File
@@ -1,559 +0,0 @@
/* des.c --- DES and Triple-DES encryption/decryption Algorithm
* Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2006, 2007
* Free Software Foundation, Inc.
*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1, or (at your
* option) any later version.
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this file; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
*/
/* Adapted for gnulib by Simon Josefsson, based on Libgcrypt. */
/*
* For a description of triple encryption, see:
* Bruce Schneier: Applied Cryptography. Second Edition.
* John Wiley & Sons, 1996. ISBN 0-471-12845-7. Pages 358 ff.
* This implementation is according to the definition of DES in FIPS
* PUB 46-2 from December 1993.
*
* Written by Michael Roth <mroth@nessie.de>, September 1998
*/
/*
* U S A G E
* ===========
*
* For DES or Triple-DES encryption/decryption you must initialize a proper
* encryption context with a key.
*
* A DES key is 64bit wide but only 56bits of the key are used. The remaining
* bits are parity bits and they will _not_ checked in this implementation, but
* simply ignored.
*
* For Triple-DES you could use either two 64bit keys or three 64bit keys.
* The parity bits will _not_ checked, too.
*
* After initializing a context with a key you could use this context to
* encrypt or decrypt data in 64bit blocks in Electronic Codebook Mode.
*
* DES Example
* -----------
* unsigned char key[8];
* unsigned char plaintext[8];
* unsigned char ciphertext[8];
* unsigned char recoverd[8];
* MHD_gl_des_ctx context;
*
* // Fill 'key' and 'plaintext' with some data
* ....
*
* // Set up the DES encryption context
* MHD_gl_des_setkey(&context, key);
*
* // Encrypt the plaintext
* des_ecb_encrypt(&context, plaintext, ciphertext);
*
* // To recover the orginal plaintext from ciphertext use:
* des_ecb_decrypt(&context, ciphertext, recoverd);
*
*
* Triple-DES Example
* ------------------
* unsigned char key1[8];
* unsigned char key2[8];
* unsigned char key3[8];
* unsigned char plaintext[8];
* unsigned char ciphertext[8];
* unsigned char recoverd[8];
* MHD_gl_3des_ctx context;
*
* // Encrypting plaintext with Triple-DES
* MHD_gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
*
* // Decrypting ciphertext to recover the plaintext with Triple-DES
* MHD_gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
*/
#include "MHD_config.h"
#include "des.h"
#include <stdio.h>
#include <string.h> /* memcpy, memcmp */
/*
* The s-box values are permuted according to the 'primitive function P'
* and are rotated one bit to the left.
*/
static const uint32_t sbox1[64] = {
0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404,
0x00000004, 0x00010000, 0x00000400, 0x01010400, 0x01010404, 0x00000400,
0x01000404, 0x01010004, 0x01000000, 0x00000004, 0x00000404, 0x01000400,
0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404,
0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404,
0x00010404, 0x01000000, 0x00010000, 0x01010404, 0x00000004, 0x01010000,
0x01010400, 0x01000000, 0x01000000, 0x00000400, 0x01010004, 0x00010000,
0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404,
0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404,
0x00010404, 0x01010400, 0x00000404, 0x01000400, 0x01000400, 0x00000000,
0x00010004, 0x00010400, 0x00000000, 0x01010004
};
static const uint32_t sbox2[64] = {
0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020,
0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000,
0x80008000, 0x00100000, 0x00000020, 0x80100020, 0x00108000, 0x00100020,
0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000,
0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000,
0x80100000, 0x00008020, 0x00000000, 0x00108020, 0x80100020, 0x00100000,
0x80008020, 0x80100000, 0x80108000, 0x00008000, 0x80100000, 0x80008000,
0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000,
0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020,
0x80000020, 0x00100020, 0x00108000, 0x00000000, 0x80008000, 0x00008020,
0x80000000, 0x80100020, 0x80108020, 0x00108000
};
static const uint32_t sbox3[64] = {
0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000,
0x00020208, 0x08000200, 0x00020008, 0x08000008, 0x08000008, 0x00020000,
0x08020208, 0x00020008, 0x08020000, 0x00000208, 0x08000000, 0x00000008,
0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208,
0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208,
0x00000200, 0x08000000, 0x08020200, 0x08000000, 0x00020008, 0x00000208,
0x00020000, 0x08020200, 0x08000200, 0x00000000, 0x00000200, 0x00020008,
0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008,
0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208,
0x00020200, 0x08000008, 0x08020000, 0x08000208, 0x00000208, 0x08020000,
0x00020208, 0x00000008, 0x08020008, 0x00020200
};
static const uint32_t sbox4[64] = {
0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081,
0x00800001, 0x00002001, 0x00000000, 0x00802000, 0x00802000, 0x00802081,
0x00000081, 0x00000000, 0x00800080, 0x00800001, 0x00000001, 0x00002000,
0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080,
0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080,
0x00802081, 0x00000081, 0x00800080, 0x00800001, 0x00802000, 0x00802081,
0x00000081, 0x00000000, 0x00000000, 0x00802000, 0x00002080, 0x00800080,
0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080,
0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001,
0x00802080, 0x00800081, 0x00002001, 0x00002080, 0x00800000, 0x00802001,
0x00000080, 0x00800000, 0x00002000, 0x00802080
};
static const uint32_t sbox5[64] = {
0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100,
0x40000000, 0x02080000, 0x40080100, 0x00080000, 0x02000100, 0x40080100,
0x42000100, 0x42080000, 0x00080100, 0x40000000, 0x02000000, 0x40080000,
0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100,
0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000,
0x42000000, 0x00080100, 0x00080000, 0x42000100, 0x00000100, 0x02000000,
0x40000000, 0x02080000, 0x42000100, 0x40080100, 0x02000100, 0x40000000,
0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000,
0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000,
0x40080000, 0x42000000, 0x00080100, 0x02000100, 0x40000100, 0x00080000,
0x00000000, 0x40080000, 0x02080100, 0x40000100
};
static const uint32_t sbox6[64] = {
0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010,
0x20404010, 0x00400000, 0x20004000, 0x00404010, 0x00400000, 0x20000010,
0x00400010, 0x20004000, 0x20000000, 0x00004010, 0x00000000, 0x00400010,
0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010,
0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000,
0x20404000, 0x20000000, 0x20004000, 0x00000010, 0x20400010, 0x00404000,
0x20404010, 0x00400000, 0x00004010, 0x20000010, 0x00400000, 0x20004000,
0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000,
0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000,
0x20400000, 0x00404010, 0x00004000, 0x00400010, 0x20004010, 0x00000000,
0x20404000, 0x20000000, 0x00400010, 0x20004010
};
static const uint32_t sbox7[64] = {
0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802,
0x00200802, 0x04200800, 0x04200802, 0x00200000, 0x00000000, 0x04000002,
0x00000002, 0x04000000, 0x04200002, 0x00000802, 0x04000800, 0x00200802,
0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002,
0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002,
0x04000000, 0x00200800, 0x04000000, 0x00200800, 0x00200000, 0x04000802,
0x04000802, 0x04200002, 0x04200002, 0x00000002, 0x00200002, 0x04000000,
0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800,
0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000,
0x00000002, 0x04200802, 0x00000000, 0x00200802, 0x04200000, 0x00000800,
0x04000002, 0x04000800, 0x00000800, 0x00200002
};
static const uint32_t sbox8[64] = {
0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040,
0x00000040, 0x10000000, 0x00040040, 0x10040000, 0x10041040, 0x00041000,
0x10041000, 0x00041040, 0x00001000, 0x00000040, 0x10040000, 0x10000040,
0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000,
0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000,
0x00041040, 0x00040000, 0x00041040, 0x00040000, 0x10041000, 0x00001000,
0x00000040, 0x10040040, 0x00001000, 0x00041040, 0x10001000, 0x00000040,
0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040,
0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000,
0x10001040, 0x00000000, 0x10041040, 0x00041000, 0x00041000, 0x00001040,
0x00001040, 0x00040040, 0x10000000, 0x10041000
};
/*
* These two tables are part of the 'permuted choice 1' function.
* In this implementation several speed improvements are done.
*/
static const uint32_t leftkey_swap[16] = {
0x00000000, 0x00000001, 0x00000100, 0x00000101,
0x00010000, 0x00010001, 0x00010100, 0x00010101,
0x01000000, 0x01000001, 0x01000100, 0x01000101,
0x01010000, 0x01010001, 0x01010100, 0x01010101
};
static const uint32_t rightkey_swap[16] = {
0x00000000, 0x01000000, 0x00010000, 0x01010000,
0x00000100, 0x01000100, 0x00010100, 0x01010100,
0x00000001, 0x01000001, 0x00010001, 0x01010001,
0x00000101, 0x01000101, 0x00010101, 0x01010101,
};
/*
* Numbers of left shifts per round for encryption subkeys. To
* calculate the decryption subkeys we just reverse the ordering of
* the calculated encryption subkeys, so there is no need for a
* decryption rotate tab.
*/
static const unsigned char encrypt_rotate_tab[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
/*
* Table with weak DES keys sorted in ascending order. In DES there
* are 64 known keys which are weak. They are weak because they
* produce only one, two or four different subkeys in the subkey
* scheduling process. The keys in this table have all their parity
* bits cleared.
*/
static const unsigned char weak_keys[64][8] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*w */
{0x00, 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e},
{0x00, 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0},
{0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe},
{0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e}, /*sw */
{0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00},
{0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe},
{0x00, 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0},
{0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0}, /*sw */
{0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe},
{0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00},
{0x00, 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e},
{0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe}, /*sw */
{0x00, 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0},
{0x00, 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e},
{0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00},
{0x1e, 0x00, 0x00, 0x1e, 0x0e, 0x00, 0x00, 0x0e},
{0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00}, /*sw */
{0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0, 0xfe},
{0x1e, 0x00, 0xfe, 0xe0, 0x0e, 0x00, 0xfe, 0xf0},
{0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00},
{0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e}, /*w */
{0x1e, 0x1e, 0xe0, 0xe0, 0x0e, 0x0e, 0xf0, 0xf0},
{0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe, 0xfe},
{0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00, 0xfe},
{0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0}, /*sw */
{0x1e, 0xe0, 0xe0, 0x1e, 0x0e, 0xf0, 0xf0, 0x0e},
{0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe, 0x00},
{0x1e, 0xfe, 0x00, 0xe0, 0x0e, 0xfe, 0x00, 0xf0},
{0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe}, /*sw */
{0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0, 0x00},
{0x1e, 0xfe, 0xfe, 0x1e, 0x0e, 0xfe, 0xfe, 0x0e},
{0xe0, 0x00, 0x00, 0xe0, 0xf0, 0x00, 0x00, 0xf0},
{0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e, 0xfe},
{0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00}, /*sw */
{0xe0, 0x00, 0xfe, 0x1e, 0xf0, 0x00, 0xfe, 0x0e},
{0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00, 0xfe},
{0xe0, 0x1e, 0x1e, 0xe0, 0xf0, 0x0e, 0x0e, 0xf0},
{0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e}, /*sw */
{0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe, 0x00},
{0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00},
{0xe0, 0xe0, 0x1e, 0x1e, 0xf0, 0xf0, 0x0e, 0x0e},
{0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0}, /*w */
{0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe, 0xfe},
{0xe0, 0xfe, 0x00, 0x1e, 0xf0, 0xfe, 0x00, 0x0e},
{0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e, 0x00},
{0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe}, /*sw */
{0xe0, 0xfe, 0xfe, 0xe0, 0xf0, 0xfe, 0xfe, 0xf0},
{0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe},
{0xfe, 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0},
{0xfe, 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e},
{0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00}, /*sw */
{0xfe, 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0},
{0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe},
{0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00},
{0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e}, /*sw */
{0xfe, 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e},
{0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00},
{0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe},
{0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0}, /*sw */
{0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00},
{0xfe, 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e},
{0xfe, 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0},
{0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe} /*w */
};
/*
* Macro to swap bits across two words.
*/
#define DO_PERMUTATION(a, temp, b, offset, mask) \
temp = ((a>>offset) ^ b) & mask; \
b ^= temp; \
a ^= temp<<offset;
/*
* This performs the 'initial permutation' of the data to be encrypted
* or decrypted. Additionally the resulting two words are rotated one bit
* to the left.
*/
#define INITIAL_PERMUTATION(left, temp, right) \
DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) \
DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
right = (right << 1) | (right >> 31); \
temp = (left ^ right) & 0xaaaaaaaa; \
right ^= temp; \
left ^= temp; \
left = (left << 1) | (left >> 31);
/*
* The 'inverse initial permutation'.
*/
#define FINAL_PERMUTATION(left, temp, right) \
left = (left << 31) | (left >> 1); \
temp = (left ^ right) & 0xaaaaaaaa; \
left ^= temp; \
right ^= temp; \
right = (right << 31) | (right >> 1); \
DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \
DO_PERMUTATION(right, temp, left, 2, 0x33333333) \
DO_PERMUTATION(left, temp, right, 16, 0x0000ffff) \
DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f)
/*
* A full DES round including 'expansion function', 'sbox substitution'
* and 'primitive function P' but without swapping the left and right word.
* Please note: The data in 'from' and 'to' is already rotated one bit to
* the left, done in the initial permutation.
*/
#define DES_ROUND(from, to, work, subkey) \
work = from ^ *subkey++; \
to ^= sbox8[ work & 0x3f ]; \
to ^= sbox6[ (work>>8) & 0x3f ]; \
to ^= sbox4[ (work>>16) & 0x3f ]; \
to ^= sbox2[ (work>>24) & 0x3f ]; \
work = ((from << 28) | (from >> 4)) ^ *subkey++; \
to ^= sbox7[ work & 0x3f ]; \
to ^= sbox5[ (work>>8) & 0x3f ]; \
to ^= sbox3[ (work>>16) & 0x3f ]; \
to ^= sbox1[ (work>>24) & 0x3f ];
/*
* Macros to convert 8 bytes from/to 32bit words.
*/
#define READ_64BIT_DATA(data, left, right) \
left = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]; \
right = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | data[7];
#define WRITE_64BIT_DATA(data, left, right) \
data[0] = (left >> 24) &0xff; data[1] = (left >> 16) &0xff; \
data[2] = (left >> 8) &0xff; data[3] = left &0xff; \
data[4] = (right >> 24) &0xff; data[5] = (right >> 16) &0xff; \
data[6] = (right >> 8) &0xff; data[7] = right &0xff;
/*
* des_key_schedule(): Calculate 16 subkeys pairs (even/odd) for
* 16 encryption rounds.
* To calculate subkeys for decryption the caller
* have to reorder the generated subkeys.
*
* rawkey: 8 Bytes of key data
* subkey: Array of at least 32 uint32_ts. Will be filled
* with calculated subkeys.
*
*/
static void
des_key_schedule (const char *_rawkey, uint32_t * subkey)
{
const unsigned char *rawkey = (const unsigned char *) _rawkey;
uint32_t left, right, work;
int round;
READ_64BIT_DATA (rawkey, left, right)
DO_PERMUTATION (right, work, left, 4, 0x0f0f0f0f)
DO_PERMUTATION (right, work, left, 0, 0x10101010)
left = ((leftkey_swap[(left >> 0) & 0xf] << 3)
| (leftkey_swap[(left >> 8) & 0xf] << 2)
| (leftkey_swap[(left >> 16) & 0xf] << 1)
| (leftkey_swap[(left >> 24) & 0xf])
| (leftkey_swap[(left >> 5) & 0xf] << 7)
| (leftkey_swap[(left >> 13) & 0xf] << 6)
| (leftkey_swap[(left >> 21) & 0xf] << 5)
| (leftkey_swap[(left >> 29) & 0xf] << 4));
left &= 0x0fffffff;
right = ((rightkey_swap[(right >> 1) & 0xf] << 3)
| (rightkey_swap[(right >> 9) & 0xf] << 2)
| (rightkey_swap[(right >> 17) & 0xf] << 1)
| (rightkey_swap[(right >> 25) & 0xf])
| (rightkey_swap[(right >> 4) & 0xf] << 7)
| (rightkey_swap[(right >> 12) & 0xf] << 6)
| (rightkey_swap[(right >> 20) & 0xf] << 5)
| (rightkey_swap[(right >> 28) & 0xf] << 4));
right &= 0x0fffffff;
for (round = 0; round < 16; ++round)
{
left = ((left << encrypt_rotate_tab[round])
| (left >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
right = ((right << encrypt_rotate_tab[round])
| (right >> (28 - encrypt_rotate_tab[round]))) & 0x0fffffff;
*subkey++ = (((left << 4) & 0x24000000)
| ((left << 28) & 0x10000000)
| ((left << 14) & 0x08000000)
| ((left << 18) & 0x02080000)
| ((left << 6) & 0x01000000)
| ((left << 9) & 0x00200000)
| ((left >> 1) & 0x00100000)
| ((left << 10) & 0x00040000)
| ((left << 2) & 0x00020000)
| ((left >> 10) & 0x00010000)
| ((right >> 13) & 0x00002000)
| ((right >> 4) & 0x00001000)
| ((right << 6) & 0x00000800)
| ((right >> 1) & 0x00000400)
| ((right >> 14) & 0x00000200)
| (right & 0x00000100)
| ((right >> 5) & 0x00000020)
| ((right >> 10) & 0x00000010)
| ((right >> 3) & 0x00000008)
| ((right >> 18) & 0x00000004)
| ((right >> 26) & 0x00000002)
| ((right >> 24) & 0x00000001));
*subkey++ = (((left << 15) & 0x20000000)
| ((left << 17) & 0x10000000)
| ((left << 10) & 0x08000000)
| ((left << 22) & 0x04000000)
| ((left >> 2) & 0x02000000)
| ((left << 1) & 0x01000000)
| ((left << 16) & 0x00200000)
| ((left << 11) & 0x00100000)
| ((left << 3) & 0x00080000)
| ((left >> 6) & 0x00040000)
| ((left << 15) & 0x00020000)
| ((left >> 4) & 0x00010000)
| ((right >> 2) & 0x00002000)
| ((right << 8) & 0x00001000)
| ((right >> 14) & 0x00000808)
| ((right >> 9) & 0x00000400)
| ((right) & 0x00000200)
| ((right << 7) & 0x00000100)
| ((right >> 7) & 0x00000020)
| ((right >> 3) & 0x00000011)
| ((right << 2) & 0x00000004)
| ((right >> 21) & 0x00000002));
}
}
void
MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key)
{
int i;
des_key_schedule (key, ctx->encrypt_subkeys);
for (i = 0; i < 32; i += 2)
{
ctx->decrypt_subkeys[i] = ctx->encrypt_subkeys[30 - i];
ctx->decrypt_subkeys[i + 1] = ctx->encrypt_subkeys[31 - i];
}
}
void
MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to,
int mode)
{
const unsigned char *from = (const unsigned char *) _from;
unsigned char *to = (unsigned char *) _to;
uint32_t left, right, work;
uint32_t *keys;
keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
READ_64BIT_DATA (from, left, right)
INITIAL_PERMUTATION (left, work, right)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
void
MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to,
int mode)
{
const unsigned char *from = (const unsigned char *) _from;
unsigned char *to = (unsigned char *) _to;
uint32_t left, right, work;
uint32_t *keys;
keys = mode ? ctx->decrypt_subkeys : ctx->encrypt_subkeys;
READ_64BIT_DATA (from, left, right)
INITIAL_PERMUTATION (left, work, right)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (left, right, work, keys) DES_ROUND (right, left, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
DES_ROUND (right, left, work, keys) DES_ROUND (left, right, work, keys)
FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
src/daemon/https/lgl/des.h
-113
View File
@@ -1,113 +0,0 @@
/* des.h --- DES cipher implementation.
* Copyright (C) 2005, 2007 Free Software Foundation, Inc.
*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1, or (at your
* option) any later version.
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this file; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
*/
/* Adapted for gnulib by Simon Josefsson, based on Libgcrypt. */
#ifndef DES_H
# define DES_H
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
/*
* Encryption/Decryption context of DES
*/
typedef struct
{
uint32_t encrypt_subkeys[32];
uint32_t decrypt_subkeys[32];
} MHD_gl_des_ctx;
/*
* Encryption/Decryption context of Triple-DES
*/
typedef struct
{
uint32_t encrypt_subkeys[96];
uint32_t decrypt_subkeys[96];
} MHD_gl_3des_ctx;
/* Check whether the 8 byte key is weak. Does not check the parity
* bits of the key but simple ignore them. */
extern bool MHD_gl_des_is_weak_key (const char *key);
/*
* DES
* ---
*/
/* Fill a DES context CTX with subkeys calculated from 64bit KEY.
* Does not check parity bits, but simply ignore them. Does not check
* for weak keys. */
extern void MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key);
/* Fill a DES context CTX with subkeys calculated from 64bit KEY, with
* weak key checking. Does not check parity bits, but simply ignore
* them. */
extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key,
size_t keylen);
/* Electronic Codebook Mode DES encryption/decryption of data
* according to 'mode'. */
extern void
MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to,
int mode);
#define MHD_gl_des_ecb_encrypt(ctx, from, to) MHD_gl_des_ecb_crypt(ctx, from, to, 0)
#define MHD_gl_des_ecb_decrypt(ctx, from, to) MHD_gl_des_ecb_crypt(ctx, from, to, 1)
/* Triple-DES
* ----------
*/
/* Fill a Triple-DES context CTX with subkeys calculated from two
* 64bit keys in KEY1 and KEY2. Does not check the parity bits of the
* keys, but simply ignore them. Does not check for weak keys. */
extern void
MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1,
const char *key2);
/*
* Fill a Triple-DES context CTX with subkeys calculated from three
* 64bit keys in KEY1, KEY2 and KEY3. Does not check the parity bits
* of the keys, but simply ignore them. Does not check for weak
* keys. */
extern void
MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx,
const char *key1, const char *key2, const char *key3);
/* Fill a Triple-DES context CTX with subkeys calculated from three
* concatenated 64bit keys in KEY, with weak key checking. Does not
* check the parity bits of the keys, but simply ignore them. */
extern bool
MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen);
/* Electronic Codebook Mode Triple-DES encryption/decryption of data
* according to 'mode'. Sometimes this mode is named 'EDE' mode
* (Encryption-Decryption-Encryption). */
extern void
MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to,
int mode);
#define MHD_gl_3des_ecb_encrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,0)
#define MHD_gl_3des_ecb_decrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,1)
#endif /* DES_H */
src/daemon/https/lgl/gc-gnulib.c
-779
View File
@@ -1,779 +0,0 @@
/* gc-gnulib.c --- Common gnulib internal crypto interface functions
* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Simon Josefsson
*
* This file is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1, or (at your
* option) any later version.
*
* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this file; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
*/
/* Note: This file is only built if GC uses internal functions. */
#include "MHD_config.h"
/* Get prototype. */
#include "gc.h"
#include <stdlib.h>
#include <string.h>
/* For randomize. */
#ifdef GNULIB_GC_RANDOM
# include <unistd.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <fcntl.h>
# include <errno.h>
#endif
/* Hashes. */
#ifdef GNULIB_GC_MD5
# include "md5.h"
#endif
#ifdef GNULIB_GC_SHA1
# include "sha1.h"
#endif
#if defined(GNULIB_GC_HMAC_MD5) || defined(GNULIB_GC_HMAC_SHA1)
# include "hmac.h"
#endif
/* Ciphers. */
#ifdef GNULIB_GC_ARCFOUR
# include "arcfour.h"
#endif
#ifdef GNULIB_GC_ARCTWO
# include "arctwo.h"
#endif
#ifdef GNULIB_GC_DES
# include "des.h"
#endif
#ifdef GNULIB_GC_RIJNDAEL
# include "rijndael-api-fst.h"
#endif
/* The results of open() in this file are not used with fchdir,
therefore save some unnecessary work in fchdir.c. */
#undef open
#undef close
Gc_rc
MHD_gc_init (void)
{
return GC_OK;
}
void
MHD_gc_done (void)
{
return;
}
#ifdef GNULIB_GC_RANDOM
/* Randomness. */
static Gc_rc
randomize (int level, char *data, size_t datalen)
{
int fd;
const char *device;
size_t len = 0;
int rc;
switch (level)
{
case 0:
device = NAME_OF_NONCE_DEVICE;
break;
case 1:
device = NAME_OF_PSEUDO_RANDOM_DEVICE;
break;
default:
device = NAME_OF_RANDOM_DEVICE;
break;
}
if (strcmp (device, "no") == 0)
return GC_RANDOM_ERROR;
fd = open (device, O_RDONLY);
if (fd < 0)
return GC_RANDOM_ERROR;
do
{
ssize_t tmp;
tmp = read (fd, data, datalen);
if (tmp < 0)
{
int save_errno = errno;
close (fd);
errno = save_errno;
return GC_RANDOM_ERROR;
}
len += tmp;
}
while (len < datalen);
rc = close (fd);
if (rc < 0)
return GC_RANDOM_ERROR;
return GC_OK;
}
Gc_rc
MHD_gc_nonce (char *data, size_t datalen)
{
return randomize (0, data, datalen);
}
Gc_rc
MHD_gc_pseudo_random (char *data, size_t datalen)
{
return randomize (1, data, datalen);
}
#endif
/* Ciphers. */
typedef struct _MHD_gc_cipher_ctx
{
Gc_cipher alg;
Gc_cipher_mode mode;
#ifdef GNULIB_GC_ARCTWO
arctwo_context arctwoContext;
char arctwoIV[ARCTWO_BLOCK_SIZE];
#endif
#ifdef GNULIB_GC_ARCFOUR
arcfour_context arcfourContext;
#endif
#ifdef GNULIB_GC_DES
MHD_gl_des_ctx desContext;
#endif
#ifdef GNULIB_GC_RIJNDAEL
rijndaelKeyInstance aesEncKey;
rijndaelKeyInstance aesDecKey;
rijndaelCipherInstance aesContext;
#endif
} _MHD_gc_cipher_ctx;
Gc_rc
MHD_gc_cipher_open (Gc_cipher alg,
Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
{
_MHD_gc_cipher_ctx *ctx;
Gc_rc rc = GC_OK;
ctx = calloc (sizeof (*ctx), 1);
if (!ctx)
return GC_MALLOC_ERROR;
ctx->alg = alg;
ctx->mode = mode;
switch (alg)
{
#ifdef GNULIB_GC_ARCTWO
case GC_ARCTWO40:
switch (mode)
{
case GC_ECB:
case GC_CBC:
break;
default:
rc = GC_INVALID_CIPHER;
}
break;
#endif
#ifdef GNULIB_GC_ARCFOUR
case GC_ARCFOUR128:
case GC_ARCFOUR40:
switch (mode)
{
case GC_STREAM:
break;
default:
rc = GC_INVALID_CIPHER;
}
break;
#endif
#ifdef GNULIB_GC_DES
case GC_DES:
switch (mode)
{
case GC_ECB:
break;
default:
rc = GC_INVALID_CIPHER;
}
break;
#endif
#ifdef GNULIB_GC_RIJNDAEL
case GC_AES128:
case GC_AES192:
case GC_AES256:
switch (mode)
{
case GC_ECB:
case GC_CBC:
break;
default:
rc = GC_INVALID_CIPHER;
}
break;
#endif
default:
rc = GC_INVALID_CIPHER;
}
if (rc == GC_OK)
*outhandle = ctx;
else
free (ctx);
return rc;
}
Gc_rc
MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
const char *key)
{
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_ARCTWO
case GC_ARCTWO40:
arctwo_setkey (&ctx->arctwoContext, keylen, key);
break;
#endif
#ifdef GNULIB_GC_ARCFOUR
case GC_ARCFOUR128:
case GC_ARCFOUR40:
arcfour_setkey (&ctx->arcfourContext, key, keylen);
break;
#endif
#ifdef GNULIB_GC_DES
case GC_DES:
if (keylen != 8)
return GC_INVALID_CIPHER;
MHD_gl_des_setkey (&ctx->desContext, key);
break;
#endif
#ifdef GNULIB_GC_RIJNDAEL
case GC_AES128:
case GC_AES192:
case GC_AES256:
{
rijndael_rc rc;
size_t i;
char keyMaterial[RIJNDAEL_MAX_KEY_SIZE + 1];
for (i = 0; i < keylen; i++)
sprintf (&keyMaterial[2 * i], "%02x", key[i] & 0xFF);
rc = MHD_rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT,
keylen * 8, keyMaterial);
if (rc < 0)
return GC_INVALID_CIPHER;
rc = MHD_rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT,
keylen * 8, keyMaterial);
if (rc < 0)
return GC_INVALID_CIPHER;
rc =
MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB,
NULL);
if (rc < 0)
return GC_INVALID_CIPHER;
}
break;
#endif
default:
return GC_INVALID_CIPHER;
}
return GC_OK;
}
Gc_rc
MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
const char *iv)
{
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_ARCTWO
case GC_ARCTWO40:
if (ivlen != ARCTWO_BLOCK_SIZE)
return GC_INVALID_CIPHER;
memcpy (ctx->arctwoIV, iv, ivlen);
break;
#endif
#ifdef GNULIB_GC_RIJNDAEL
case GC_AES128:
case GC_AES192:
case GC_AES256:
switch (ctx->mode)
{
case GC_ECB:
/* Doesn't use IV. */
break;
case GC_CBC:
{
rijndael_rc rc;
size_t i;
char ivMaterial[2 * RIJNDAEL_MAX_IV_SIZE + 1];
for (i = 0; i < ivlen; i++)
sprintf (&ivMaterial[2 * i], "%02x", iv[i] & 0xFF);
rc =
MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
ivMaterial);
if (rc < 0)
return GC_INVALID_CIPHER;
}
break;
default:
return GC_INVALID_CIPHER;
}
break;
#endif
default:
return GC_INVALID_CIPHER;
}
return GC_OK;
}
Gc_rc
MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
char *data)
{
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_ARCTWO
case GC_ARCTWO40:
switch (ctx->mode)
{
case GC_ECB:
arctwo_encrypt (&ctx->arctwoContext, data, data, len);
break;
case GC_CBC:
for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
data += ARCTWO_BLOCK_SIZE)
{
size_t i;
for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
data[i] ^= ctx->arctwoIV[i];
arctwo_encrypt (&ctx->arctwoContext, data, data,
ARCTWO_BLOCK_SIZE);
memcpy (ctx->arctwoIV, data, ARCTWO_BLOCK_SIZE);
}
break;
default:
return GC_INVALID_CIPHER;
}
break;
#endif
#ifdef GNULIB_GC_ARCFOUR
case GC_ARCFOUR128:
case GC_ARCFOUR40:
arcfour_stream (&ctx->arcfourContext, data, data, len);
break;
#endif
#ifdef GNULIB_GC_DES
case GC_DES:
for (; len >= 8; len -= 8, data += 8)
MHD_gl_des_ecb_encrypt (&ctx->desContext, data, data);
break;
#endif
#ifdef GNULIB_GC_RIJNDAEL
case GC_AES128:
case GC_AES192:
case GC_AES256:
{
int nblocks;
nblocks = MHD_rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey,
data, 8 * len, data);
if (nblocks < 0)
return GC_INVALID_CIPHER;
}
break;
#endif
default:
return GC_INVALID_CIPHER;
}
return GC_OK;
}
Gc_rc
MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
char *data)
{
_MHD_gc_cipher_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_ARCTWO
case GC_ARCTWO40:
switch (ctx->mode)
{
case GC_ECB:
arctwo_decrypt (&ctx->arctwoContext, data, data, len);
break;
case GC_CBC:
for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
data += ARCTWO_BLOCK_SIZE)
{
char tmpIV[ARCTWO_BLOCK_SIZE];
size_t i;
memcpy (tmpIV, data, ARCTWO_BLOCK_SIZE);
arctwo_decrypt (&ctx->arctwoContext, data, data,
ARCTWO_BLOCK_SIZE);
for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
data[i] ^= ctx->arctwoIV[i];
memcpy (ctx->arctwoIV, tmpIV, ARCTWO_BLOCK_SIZE);
}
break;
default:
return GC_INVALID_CIPHER;
}
break;
#endif
#ifdef GNULIB_GC_ARCFOUR
case GC_ARCFOUR128:
case GC_ARCFOUR40:
arcfour_stream (&ctx->arcfourContext, data, data, len);
break;
#endif
#ifdef GNULIB_GC_DES
case GC_DES:
for (; len >= 8; len -= 8, data += 8)
MHD_gl_des_ecb_decrypt (&ctx->desContext, data, data);
break;
#endif
#ifdef GNULIB_GC_RIJNDAEL
case GC_AES128:
case GC_AES192:
case GC_AES256:
{
int nblocks;
nblocks = MHD_rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey,
data, 8 * len, data);
if (nblocks < 0)
return GC_INVALID_CIPHER;
}
break;
#endif
default:
return GC_INVALID_CIPHER;
}
return GC_OK;
}
Gc_rc
MHD_gc_cipher_close (MHD_gc_cipher_handle handle)
{
_MHD_gc_cipher_ctx *ctx = handle;
if (ctx)
free (ctx);
return GC_OK;
}
/* Hashes. */
#define MAX_DIGEST_SIZE 20
typedef struct _MHD_gc_hash_ctx
{
Gc_hash alg;
Gc_hash_mode mode;
char hash[MAX_DIGEST_SIZE];
#ifdef GNULIB_GC_MD5
struct MHD_md5_ctx md5Context;
#endif
#ifdef GNULIB_GC_SHA1
struct MHD_sha1_ctx sha1Context;
#endif
} _MHD_gc_hash_ctx;
Gc_rc
MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode,
MHD_gc_hash_handle * outhandle)
{
_MHD_gc_hash_ctx *ctx;
Gc_rc rc = GC_OK;
ctx = calloc (sizeof (*ctx), 1);
if (!ctx)
return GC_MALLOC_ERROR;
ctx->alg = hash;
ctx->mode = mode;
switch (hash)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
MHD_md5_init_ctx (&ctx->md5Context);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
MHD_sha1_init_ctx (&ctx->sha1Context);
break;
#endif
default:
rc = GC_INVALID_HASH;
break;
}
switch (mode)
{
case 0:
break;
default:
rc = GC_INVALID_HASH;
break;
}
if (rc == GC_OK)
*outhandle = ctx;
else
free (ctx);
return rc;
}
Gc_rc
MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle)
{
_MHD_gc_hash_ctx *in = handle;
_MHD_gc_hash_ctx *out;
*outhandle = out = calloc (sizeof (*out), 1);
if (!out)
return GC_MALLOC_ERROR;
memcpy (out, in, sizeof (*out));
return GC_OK;
}
size_t
MHD_gc_hash_digest_length (Gc_hash hash)
{
size_t len;
switch (hash)
{
case GC_MD2:
len = GC_MD2_DIGEST_SIZE;
break;
case GC_MD4:
len = GC_MD4_DIGEST_SIZE;
break;
case GC_MD5:
len = GC_MD5_DIGEST_SIZE;
break;
case GC_RMD160:
len = GC_RMD160_DIGEST_SIZE;
break;
case GC_SHA1:
len = GC_SHA1_DIGEST_SIZE;
break;
default:
return 0;
}
return len;
}
void
MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data)
{
_MHD_gc_hash_ctx *ctx = handle;
switch (ctx->alg)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
MHD_md5_process_bytes (data, len, &ctx->md5Context);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
MHD_sha1_process_bytes (data, len, &ctx->sha1Context);
break;
#endif
default:
break;
}
}
const char *
MHD_gc_hash_read (MHD_gc_hash_handle handle)
{
_MHD_gc_hash_ctx *ctx = handle;
const char *ret = NULL;
switch (ctx->alg)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
MHD_md5_finish_ctx (&ctx->md5Context, ctx->hash);
ret = ctx->hash;
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
MHD_sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
ret = ctx->hash;
break;
#endif
default:
return NULL;
}
return ret;
}
void
MHD_gc_hash_close (MHD_gc_hash_handle handle)
{
_MHD_gc_hash_ctx *ctx = handle;
free (ctx);
}
Gc_rc
MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
{
switch (hash)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
MHD_md5_buffer (in, inlen, resbuf);
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
MHD_sha1_buffer (in, inlen, resbuf);
break;
#endif
default:
return GC_INVALID_HASH;
}
return GC_OK;
}
#ifdef GNULIB_GC_MD5
Gc_rc
MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
{
MHD_md5_buffer (in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_SHA1
Gc_rc
MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
{
MHD_sha1_buffer (in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_MD5
Gc_rc
MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
const void *in, size_t inlen, char *resbuf)
{
MHD_hmac_md5 (key, keylen, in, inlen, resbuf);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_SHA1
Gc_rc
MHD_gc_MHD_hmac_sha1 (const void *key,
size_t keylen, const void *in, size_t inlen,
char *resbuf)
{
MHD_hmac_sha1 (key, keylen, in, inlen, resbuf);
return GC_OK;
}
#endif
src/daemon/https/lgl/gc-libgcrypt.c
-157
View File
@@ -416,163 +416,6 @@ MHD_gc_hash_close (MHD_gc_hash_handle handle)
free (ctx);
}
Gc_rc
MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
{
int gcryalg;
switch (hash)
{
#ifdef GNULIB_GC_MD5
case GC_MD5:
gcryalg = GCRY_MD_MD5;
break;
#endif
#ifdef GNULIB_GC_SHA1
case GC_SHA1:
gcryalg = GCRY_MD_SHA1;
break;
#endif
#ifdef GNULIB_GC_SHA256
case GC_SHA256:
gcryalg = GCRY_MD_SHA256;
break;
#endif
#ifdef GNULIB_GC_SHA384
case GC_SHA384:
gcryalg = GCRY_MD_SHA384;
break;
#endif
#ifdef GNULIB_GC_SHA512
case GC_SHA512:
gcryalg = GCRY_MD_SHA512;
break;
#endif
#ifdef GNULIB_GC_RMD160
case GC_RMD160:
gcryalg = GCRY_MD_RMD160;
break;
#endif
default:
return GC_INVALID_HASH;
}
gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
return GC_OK;
}
/* One-call interface. */
#ifdef GNULIB_GC_MD5
Gc_rc
MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
{
size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
gcry_md_hd_t hd;
gpg_error_t err;
unsigned char *p;
assert (outlen == GC_MD5_DIGEST_SIZE);
err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
if (err != GPG_ERR_NO_ERROR)
return GC_INVALID_HASH;
gcry_md_write (hd, in, inlen);
p = gcry_md_read (hd, GCRY_MD_MD5);
if (p == NULL)
{
gcry_md_close (hd);
return GC_INVALID_HASH;
}
memcpy (resbuf, p, outlen);
gcry_md_close (hd);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_SHA1
Gc_rc
MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
{
size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
gcry_md_hd_t hd;
gpg_error_t err;
unsigned char *p;
assert (outlen == GC_SHA1_DIGEST_SIZE);
err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
if (err != GPG_ERR_NO_ERROR)
return GC_INVALID_HASH;
gcry_md_write (hd, in, inlen);
p = gcry_md_read (hd, GCRY_MD_SHA1);
if (p == NULL)
{
gcry_md_close (hd);
return GC_INVALID_HASH;
}
memcpy (resbuf, p, outlen);
gcry_md_close (hd);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_MD5
Gc_rc
MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
const void *in, size_t inlen, char *resbuf)
{
size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
gcry_md_hd_t mdh;
unsigned char *hash;
gpg_error_t err;
assert (hlen == 16);
err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
if (err != GPG_ERR_NO_ERROR)
return GC_INVALID_HASH;
err = gcry_md_setkey (mdh, key, keylen);
if (err != GPG_ERR_NO_ERROR)
{
gcry_md_close (mdh);
return GC_INVALID_HASH;
}
gcry_md_write (mdh, in, inlen);
hash = gcry_md_read (mdh, GCRY_MD_MD5);
if (hash == NULL)
{
gcry_md_close (mdh);
return GC_INVALID_HASH;
}
memcpy (resbuf, hash, hlen);
gcry_md_close (mdh);
return GC_OK;
}
#endif
#ifdef GNULIB_GC_HMAC_SHA1
Gc_rc
MHD_gc_MHD_hmac_sha1 (const void *key,
src/daemon/https/lgl/memxor.c
+1 -1
View File
@@ -23,7 +23,7 @@
#include "memxor.h"
void *
MHD_memxor (void *restrict dest, const void *restrict src, size_t n)
MHD_memxor (void * dest, const void * src, size_t n)
{
char const *s = src;
char *d = dest;
src/daemon/https/lgl/memxor.h
+1 -1
View File
@@ -26,6 +26,6 @@
/* Compute binary exclusive OR of memory areas DEST and SRC, putting
the result in DEST, of length N bytes. Returns a pointer to
DEST. */
void *MHD_memxor (void *restrict dest, const void *restrict src, size_t n);
void *MHD_memxor (void * dest, const void * src, size_t n);
#endif /* MEMXOR_H */
src/daemon/https/minitasn1/Makefile.am
+3 -4
View File
@@ -1,8 +1,7 @@
AM_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/tls
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/tls
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
src/daemon/https/tls/Makefile.am
+6 -11
View File
@@ -1,9 +1,3 @@
SUBDIRS = .
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
endif
AM_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/ \
@@ -11,18 +5,19 @@ AM_CPPFLAGS = \
-I$(top_srcdir)/src/daemon/https/tls \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/minitasn1 \
-I$(top_srcdir)/src/daemon/https/x509 \
-I$(GCRYPT_CPPFLAGS)
-I$(top_srcdir)/src/daemon/https/x509
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
endif
noinst_LTLIBRARIES = libtls.la
libtls_la_LDFLAGS = \
-L$(GCRYPT_LIB_PATH)
libtls_la_LDFLAGS = -lgcrypt
libtls_la_SOURCES = \
auth_cert.c \
auth_dh_common.c \
auth_dhe.c \
auth_rsa.c \
auth_rsa_export.c \
debug.c \
src/daemon/https/tls/auth_dh_common.c
-275
View File
@@ -50,278 +50,3 @@ MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh)
MHD__gnutls_free_datum (&dh->public_key);
}
int
MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t g, mpi_t p)
{
uint16_t n_Y;
size_t _n_Y;
int ret;
ssize_t data_size = _data_size;
DECR_LEN (data_size, 2);
n_Y = MHD_gtls_read_uint16 (&data[0]);
_n_Y = n_Y;
DECR_LEN (data_size, n_Y);
if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
{
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
session->key->KEY =
MHD_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
if (session->key->KEY == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
MHD_gtls_mpi_release (&session->key->client_Y);
MHD_gtls_mpi_release (&session->key->dh_secret);
ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
MHD_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
return ret;
}
return 0;
}
int
MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t session, opaque ** data)
{
mpi_t x = NULL, X = NULL;
size_t n_X;
int ret;
*data = NULL;
X = MHD_gtls_calc_dh_secret (&x, session->key->client_g,
session->key->client_p);
if (X == NULL || x == NULL)
{
MHD_gnutls_assert ();
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
MHD_gtls_mpi_print (NULL, &n_X, X);
(*data) = MHD_gnutls_malloc (n_X + 2);
if (*data == NULL)
{
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
MHD_gtls_mpi_print (&(*data)[2], &n_X, X);
MHD_gtls_mpi_release (&X);
MHD_gtls_write_uint16 (n_X, &(*data)[0]);
/* calculate the key after calculating the message */
session->key->KEY =
MHD_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
MHD_gtls_mpi_release (&x);
if (session->key->KEY == NULL)
{
MHD_gnutls_assert ();
ret = GNUTLS_E_MEMORY_ERROR;
goto error;
}
/* THESE SHOULD BE DISCARDED */
MHD_gtls_mpi_release (&session->key->client_Y);
MHD_gtls_mpi_release (&session->key->client_p);
MHD_gtls_mpi_release (&session->key->client_g);
ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
MHD_gtls_mpi_release (&session->key->KEY);
if (ret < 0)
{
MHD_gnutls_assert ();
goto error;
}
return n_X + 2;
error:
MHD_gtls_mpi_release (&x);
MHD_gtls_mpi_release (&X);
MHD_gnutls_free (*data);
*data = NULL;
return ret;
}
int
MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size, int psk)
{
uint16_t n_Y, n_g, n_p;
size_t _n_Y, _n_g, _n_p;
uint8_t *data_p;
uint8_t *data_g;
uint8_t *data_Y;
int i, bits, psk_size, ret;
ssize_t data_size = _data_size;
i = 0;
if (psk != 0)
{
DECR_LEN (data_size, 2);
psk_size = MHD_gtls_read_uint16 (&data[i]);
DECR_LEN (data_size, psk_size);
i += 2 + psk_size;
}
DECR_LEN (data_size, 2);
n_p = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_p);
data_p = &data[i];
i += n_p;
DECR_LEN (data_size, 2);
n_g = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_g);
data_g = &data[i];
i += n_g;
DECR_LEN (data_size, 2);
n_Y = MHD_gtls_read_uint16 (&data[i]);
i += 2;
DECR_LEN (data_size, n_Y);
data_Y = &data[i];
i += n_Y;
_n_Y = n_Y;
_n_g = n_g;
_n_p = n_p;
if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
{
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
if (MHD_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
{
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
if (MHD_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
{
MHD_gnutls_assert ();
return GNUTLS_E_MPI_SCAN_FAILED;
}
bits = MHD_gtls_dh_get_allowed_prime_bits (session);
if (bits < 0)
{
MHD_gnutls_assert ();
return bits;
}
if (MHD__gnutls_mpi_get_nbits (session->key->client_p) < (size_t) bits)
{
/* the prime used by the peer is not acceptable
*/
MHD_gnutls_assert ();
return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
}
MHD_gtls_dh_set_group (session, session->key->client_g,
session->key->client_p);
MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
ret = n_Y + n_p + n_g + 6;
if (psk != 0)
ret += 2;
return ret;
}
/* If the psk flag is set, then an empty psk_identity_hint will
* be inserted */
int
MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t session,
mpi_t g, mpi_t p, opaque ** data, int psk)
{
mpi_t x, X;
size_t n_X, n_g, n_p;
int ret, data_size, pos;
uint8_t *pdata;
X = MHD_gtls_calc_dh_secret (&x, g, p);
if (X == NULL || x == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
session->key->dh_secret = x;
MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
MHD_gtls_mpi_print (NULL, &n_g, g);
MHD_gtls_mpi_print (NULL, &n_p, p);
MHD_gtls_mpi_print (NULL, &n_X, X);
data_size = n_g + n_p + n_X + 6;
if (psk != 0)
data_size += 2;
(*data) = MHD_gnutls_malloc (data_size);
if (*data == NULL)
{
MHD_gtls_mpi_release (&X);
return GNUTLS_E_MEMORY_ERROR;
}
pos = 0;
pdata = *data;
if (psk != 0)
{
MHD_gtls_write_uint16 (0, &pdata[pos]);
pos += 2;
}
MHD_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
MHD_gtls_write_uint16 (n_p, &pdata[pos]);
pos += n_p + 2;
MHD_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
MHD_gtls_write_uint16 (n_g, &pdata[pos]);
pos += n_g + 2;
MHD_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
MHD_gtls_mpi_release (&X);
MHD_gtls_write_uint16 (n_X, &pdata[pos]);
ret = data_size;
return ret;
}
src/daemon/https/tls/auth_dh_common.h
-9
View File
@@ -35,14 +35,5 @@ typedef struct
} MHD_gtls_dh_info_st;
void MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh);
int MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t, opaque **);
int MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
mpi_t p, mpi_t g);
int MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t, mpi_t g, mpi_t p,
opaque ** data, int psk);
int MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
opaque * data, size_t _data_size,
int psk);
#endif
src/daemon/https/tls/auth_dhe.c
-277
View File
@@ -1,277 +0,0 @@
/*
* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation
*
* Author: Nikos Mavrogiannopoulos
*
* This file is part of GNUTLS.
*
* The GNUTLS library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA
*
*/
/* This file contains everything for the Ephemeral Diffie Hellman (DHE)
* key exchange. This is used in the handshake procedure of the certificate
* authentication.
*/
#include "gnutls_int.h"
#include "gnutls_auth_int.h"
#include "gnutls_errors.h"
#include "gnutls_dh.h"
#include "gnutls_num.h"
#include "gnutls_sig.h"
#include <gnutls_datum.h>
#include <auth_cert.h>
#include <gnutls_x509.h>
#include <gnutls_state.h>
#include <auth_dh_common.h>
static int gen_dhe_server_kx (MHD_gtls_session_t, opaque **);
static int proc_dhe_server_kx (MHD_gtls_session_t, opaque *, size_t);
static int proc_dhe_client_kx (MHD_gtls_session_t, opaque *, size_t);
const MHD_gtls_mod_auth_st MHD_gtls_dhe_rsa_auth_struct = {
"DHE_RSA",
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
MHD_gtls_gen_dh_common_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
const MHD_gtls_mod_auth_st MHD_gtls_dhe_dss_auth_struct = {
"DHE_DSS",
MHD_gtls_gen_cert_server_certificate,
MHD_gtls_gen_cert_client_certificate,
gen_dhe_server_kx,
MHD_gtls_gen_dh_common_client_kx,
MHD_gtls_gen_cert_client_cert_vrfy, /* gen client cert vrfy */
MHD_gtls_gen_cert_server_cert_req, /* server cert request */
MHD_gtls_proc_cert_server_certificate,
MHD__gnutls_proc_cert_client_certificate,
proc_dhe_server_kx,
proc_dhe_client_kx,
MHD_gtls_proc_cert_client_cert_vrfy, /* proc client cert vrfy */
MHD_gtls_proc_cert_cert_req /* proc server cert request */
};
static int
gen_dhe_server_kx (MHD_gtls_session_t session, opaque ** data)
{
mpi_t g, p;
const mpi_t *mpis;
int ret = 0, data_size;
int bits;
MHD_gnutls_cert *apr_cert_list;
MHD_gnutls_privkey *apr_pkey;
int apr_cert_list_length;
MHD_gnutls_datum_t signature, ddata;
MHD_gtls_cert_credentials_t cred;
MHD_gtls_dh_params_t dh_params;
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
bits = MHD_gtls_dh_get_allowed_prime_bits (session);
/* find the appropriate certificate */
if ((ret =
MHD_gtls_get_selected_cert (session, &apr_cert_list,
&apr_cert_list_length, &apr_pkey)) < 0)
{
MHD_gnutls_assert ();
return ret;
}
dh_params =
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
p = mpis[0];
g = mpis[1];
if ((ret = MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
sizeof (cert_auth_info_st), 0)) < 0)
{
MHD_gnutls_assert ();
return ret;
}
MHD_gtls_dh_set_group (session, g, p);
ret = MHD_gtls_dh_common_print_server_kx (session, g, p, data, 0);
if (ret < 0)
{
MHD_gnutls_assert ();
return ret;
}
data_size = ret;
/* Generate the signature. */
ddata.data = *data;
ddata.size = data_size;
if (apr_cert_list_length > 0)
{
if ((ret =
MHD_gtls_tls_sign_params (session, &apr_cert_list[0],
apr_pkey, &ddata, &signature)) < 0)
{
MHD_gnutls_assert ();
MHD_gnutls_free (*data);
return ret;
}
}
else
{
MHD_gnutls_assert ();
return data_size; /* do not put a signature - ILLEGAL! */
}
*data = MHD_gtls_realloc_fast (*data, data_size + signature.size + 2);
if (*data == NULL)
{
MHD__gnutls_free_datum (&signature);
MHD_gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
MHD_gtls_write_datum16 (&(*data)[data_size], signature);
data_size += signature.size + 2;
MHD__gnutls_free_datum (&signature);
return data_size;
}
static int
proc_dhe_server_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
int sigsize;
MHD_gnutls_datum_t vparams, signature;
int ret;
cert_auth_info_t info = MHD_gtls_get_auth_info (session);
ssize_t data_size = _data_size;
MHD_gnutls_cert peer_cert;
if (info == NULL || info->ncerts == 0)
{
MHD_gnutls_assert ();
/* we need this in order to get peer's certificate */
return GNUTLS_E_INTERNAL_ERROR;
}
ret = MHD_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
if (ret < 0)
{
MHD_gnutls_assert ();
return ret;
}
/* VERIFY SIGNATURE */
vparams.size = ret;
vparams.data = data;
DECR_LEN (data_size, 2);
sigsize = MHD_gtls_read_uint16 (&data[vparams.size]);
DECR_LEN (data_size, sigsize);
signature.data = &data[vparams.size + 2];
signature.size = sigsize;
if ((ret =
MHD_gtls_raw_cert_to_gcert (&peer_cert,
session->security_parameters.cert_type,
&info->raw_certificate_list[0],
CERT_NO_COPY)) < 0)
{
MHD_gnutls_assert ();
return ret;
}
ret =
MHD_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
MHD_gtls_gcert_deinit (&peer_cert);
if (ret < 0)
{
MHD_gnutls_assert ();
return ret;
}
return ret;
}
static int
proc_dhe_client_kx (MHD_gtls_session_t session, opaque * data,
size_t _data_size)
{
MHD_gtls_cert_credentials_t cred;
int ret;
mpi_t p, g;
const mpi_t *mpis;
MHD_gtls_dh_params_t dh_params;
cred = (MHD_gtls_cert_credentials_t)
MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
if (cred == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
}
dh_params =
MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
mpis = MHD_gtls_dh_params_to_mpi (dh_params);
if (mpis == NULL)
{
MHD_gnutls_assert ();
return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
}
p = mpis[0];
g = mpis[1];
ret = MHD_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
return ret;
}
src/daemon/https/x509/Makefile.am
+17 -18
View File
@@ -1,26 +1,25 @@
SUBDIRS = .
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
endif
AM_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/https \
-I$(top_srcdir)/src/daemon/https/minitasn1 \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/x509 \
-I$(top_srcdir)/src/daemon/https/tls
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/https \
-I$(top_srcdir)/src/daemon/https/minitasn1 \
-I$(top_srcdir)/src/daemon/https/lgl \
-I$(top_srcdir)/src/daemon/https/tls \
-I$(top_srcdir)/src/daemon/https/x509
noinst_LTLIBRARIES = libx509.la
libx509_la_LDFLAGS = -lgcrypt
if USE_COVERAGE
AM_CFLAGS = -fprofile-arcs -ftest-coverage
endif
libx509_la_SOURCES = \
common.c common.h \
extensions.c extensions.h \
mpi.c mpi.h \
pkcs12.h \
x509_privkey.c privkey.h \
x509.c x509.h
common.c common.h \
extensions.c extensions.h \
mpi.c mpi.h \
pkcs12.h \
x509_privkey.c privkey.h \
x509.c x509.h
src/examples/Makefile.am
+4
View File
@@ -4,6 +4,10 @@ AM_CPPFLAGS = \
-I$(top_srcdir)/src/include \
-I$(top_srcdir)/src/daemon/https
if USE_COVERAGE
AM_CFLAGS = --coverage
endif
# example programs
noinst_PROGRAMS = \
authorization_example \