These patches fix problems reported on the hlfs-dev list. Please remove: openssl-0.9.8a-arc4random-1.patch glibc-2.3.6-ssp-1.patch glibc-2.3.6-arc4random-1.patch
And add the attached patches. robert
Submitted By: Robert Connolly <robert at linuxfromscratch dot org> (ashes) Date: 2006-01-01 Initial Package Version: 2.3.6 Upstream Status: Not submitted Origin: http://www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/crypt/arc4random.c Description: This patch adds the arc4random() and arc4randomII() functions to Glibc, and hooks so mktemp(3) can use arc4randomII(). Also see: http://www.linuxfromscratch.org/hlfs/ http://www.linuxfromscratch.org/hints/downloads/files/entropy.txt diff -Naur glibc-2.3.6.orig/manual/arc4random.3 glibc-2.3.6/manual/arc4random.3 --- glibc-2.3.6.orig/manual/arc4random.3 1970-01-01 00:00:00.000000000 +0000 +++ glibc-2.3.6/manual/arc4random.3 2006-01-01 07:48:48.000000000 +0000 @@ -0,0 +1,74 @@ +.TH ARC4RANDOM 3 "February 11, 2005" +.SH NAME +arc4random - arc4 random number generator +.SH SYNOPSIS +.nf +.B #include <stdlib.h> +.sp +.I u_int32_t +.B arc4random(void); +.sp +.I u_int32_t +.B arc4randomII(void); +.fi +.SH DESCRIPTION +The \fBarc4random()\fP function generates a pseudo-random number using the +ARC4 cipher key stream generator. ARCFOUR uses 8*8 8 bit S-Boxes, and can +be in about (2**1700) states. + +The \fBarc4random()\fP function is seeded automatically from /dev/urandom, +or from sysctl \fBurandom\fP if /dev/urandom is not accessible (chroot), or from +sysctl random.uuid if sysctl \fBurandom\fP is not accessible. \fBgettimeofday(2)\fP +is always included when initializing the state of \fBarc4random()\fP, this makes +it impossible to generate the same random sequence twice. \fBarc4random()\fP +is intended to be safe to use with encryption software to provide entropy. + +The \fBarc4randomII()\fP function is identical to \fBarc4random()\fP except +that \fBarc4randomII()\fP is seeded automatically from /dev/erandom, and +sysctl erandom. \fBarc4randomII()\fP is NOT intended for cryptography, but is +ideal for \fBmktemp(3)\fP, and other functions with a short lifespan. +\fBarc4randomII()\fP and erandom do not consume any kernel entropy. + +Sysctl urandom, and erandom require a modified kernel. See: +http://www.linuxfromscratch.org/hlfs/ + +.SH EXAMPLES +.TP +Return a random number between 0 and 100. +.sp +arc4random() % 100; +.TP +Return any random number. +.sp +arc4random(); +.TP +.nf +Sample program; this will display a number between 0 and 65536. + +#include <stdlib.h> +#include <stdio.h> + +int main(void) { + int random_number; + random_number = arc4random() % 65536; + printf("%d\n", random_number); + return 0; +} +.fi +.SH "SEE ALSO" +.BR random (3), +.BR gettimeofday (2), +.BR mktemp (3) + +.SH HISTORY +An algorithm called RC4 was designed by RSA Data Security, Inc. It was +considered a trade secret, but not trademarked. Because it was a trade +secret, it obviously could not be patented. A clone of this was posted +anonymously to USENET and confirmed to be equivalent by several sources +who had access to the original cipher. Because of the trade secret situation, +RSA Data Security, Inc. can do nothing about the release of the +ARC4 algorithm. Since RC4 used to be a trade secret, the cipher is now +referred to as ARC4 (Another RC4). + +These functions first appeared in OpenBSD 2.1. + diff -Naur glibc-2.3.6.orig/stdlib/Makefile glibc-2.3.6/stdlib/Makefile --- glibc-2.3.6.orig/stdlib/Makefile 2005-02-16 11:23:58.000000000 +0000 +++ glibc-2.3.6/stdlib/Makefile 2006-01-01 07:48:48.000000000 +0000 @@ -27,7 +27,7 @@ routines := \ atof atoi atol atoll \ - abort \ + abort arc4random arc4randomII \ bsearch qsort msort \ getenv putenv setenv secure-getenv \ exit on_exit atexit cxa_atexit cxa_finalize old_atexit \ diff -Naur glibc-2.3.6.orig/stdlib/Versions glibc-2.3.6/stdlib/Versions --- glibc-2.3.6.orig/stdlib/Versions 2004-05-03 21:25:53.000000000 +0000 +++ glibc-2.3.6/stdlib/Versions 2006-01-01 07:50:28.000000000 +0000 @@ -11,6 +11,8 @@ # a* a64l; abort; abs; atexit; atof; atoi; atol; atoll; + arc4random_stir; arc4random_addrandom; arc4random; + arc4random_stirII; arc4random_addrandomII; arc4randomII; # b* bsearch; diff -Naur glibc-2.3.6.orig/stdlib/arc4random.c glibc-2.3.6/stdlib/arc4random.c --- glibc-2.3.6.orig/stdlib/arc4random.c 1970-01-01 00:00:00.000000000 +0000 +++ glibc-2.3.6/stdlib/arc4random.c 2006-01-01 07:48:48.000000000 +0000 @@ -0,0 +1,205 @@ +/* + * Arc4 random number generator for OpenBSD. + * Copyright 1996 David Mazieres <[EMAIL PROTECTED]>. + * + * Modification and redistribution in source and binary forms is + * permitted provided that due credit is given to the author and the + * OpenBSD project by leaving this copyright notice intact. + */ + +/* + * This code is derived from section 17.1 of Applied Cryptography, + * second edition, which describes a stream cipher allegedly + * compatible with RSA Labs "RC4" cipher (the actual description of + * which is a trade secret). The same algorithm is used as a stream + * cipher called "arcfour" in Tatu Ylonen's ssh package. + * + * Here the stream cipher has been modified always to include the time + * when initializing the state. That makes it impossible to + * regenerate the same random sequence twice, so this can't be used + * for encryption, but will generate good random numbers. + * + * RC4 is a registered trademark of RSA Laboratories. + */ + +/* + * Modified by Robert Connolly from OpenBSD lib/libc/crypt/arc4random.c v1.11. + * This is arc4random(3) using urandom. + */ + +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/time.h> +#include <sys/sysctl.h> + +#ifdef __GNUC__ +#define inline __inline +#else /* !__GNUC__ */ +#define inline +#endif /* !__GNUC__ */ + +struct arc4_stream { + u_int8_t i; + u_int8_t j; + u_int8_t s[256]; +}; + +static int rs_initialized; +static struct arc4_stream rs; +static pid_t arc4_stir_pid; + +static inline u_int8_t arc4_getbyte(struct arc4_stream *); + +static inline void +arc4_init(struct arc4_stream *as) +{ + int n; + + for (n = 0; n < 256; n++) + as->s[n] = n; + as->i = 0; + as->j = 0; +} + +static inline void +arc4_addrandom(struct arc4_stream *as, u_char *dat, int datlen) +{ + int n; + u_int8_t si; + + as->i--; + for (n = 0; n < 256; n++) { + as->i = (as->i + 1); + si = as->s[as->i]; + as->j = (as->j + si + dat[n % datlen]); + as->s[as->i] = as->s[as->j]; + as->s[as->j] = si; + } + as->j = as->i; +} + +static void +arc4_stir(struct arc4_stream *as) +{ + int n, fd; + struct { + struct timeval tv; + u_int rnd[(128 - sizeof(struct timeval)) / sizeof(u_int)]; + } rdat; + + gettimeofday(&rdat.tv, NULL); + + /* /dev/urandom is a multithread interface, sysctl is not. */ + /* Try to use /dev/urandom before sysctl. */ + fd = open("/dev/urandom", O_RDONLY); + if (fd != -1) { + read(fd, rdat.rnd, sizeof(rdat.rnd)); + close(fd); + } + +#if defined(SYSCTL_URANDOM) + else { + /* /dev/urandom failed? Maybe we're in a chroot. */ + int mib[]={CTL_KERN, KERN_RANDOM, RANDOM_URANDOM}; + u_int i; + size_t len; + + for (i = 0; i < sizeof(rdat.rnd) / sizeof(u_int); i ++) { + len = sizeof(u_int); + if (sysctl(mib, 3, &rdat.rnd[i], &len, NULL, 0) == -1) + break; + } + if (i < sizeof(rdat.rnd) / 4) { + /* Sysctl urandom failed? Maybe we're running a vanilla kernel. */ + mib[2] = RANDOM_UUID; + for (i = 0; i < sizeof(rdat.rnd) / sizeof(u_int); i ++) { + len = sizeof(u_int); + if (sysctl(mib, 3, &rdat.rnd[i], &len, NULL, 0) == -1) + break; + } + } + } +#endif + + arc4_stir_pid = getpid(); + /* + * Time to give up. If no entropy could be found then we will just + * use gettimeofday. + */ + arc4_addrandom(as, (void *)&rdat, sizeof(rdat)); + + /* + * Discard early keystream, as per recommendations in: + * http://www.wisdom.weizmann.ac.il/~itsik/RC4/Papers/Rc4_ksa.ps + * We discard 256 words. A long word is 4 bytes. + */ + for (n = 0; n < 256 * 4; n ++) + arc4_getbyte(as); +} + +static inline u_int8_t +arc4_getbyte(struct arc4_stream *as) +{ + u_int8_t si, sj; + + as->i = (as->i + 1); + si = as->s[as->i]; + as->j = (as->j + si); + sj = as->s[as->j]; + as->s[as->i] = sj; + as->s[as->j] = si; + return (as->s[(si + sj) & 0xff]); +} + +static inline u_int32_t +arc4_getword(struct arc4_stream *as) +{ + u_int32_t val; + val = arc4_getbyte(as) << 24; + val |= arc4_getbyte(as) << 16; + val |= arc4_getbyte(as) << 8; + val |= arc4_getbyte(as); + return val; +} + +void +arc4random_stir(void) +{ + if (!rs_initialized) { + arc4_init(&rs); + rs_initialized = 1; + } + arc4_stir(&rs); +} + +void +arc4random_addrandom(u_char *dat, int datlen) +{ + if (!rs_initialized) + arc4random_stir(); + arc4_addrandom(&rs, dat, datlen); +} + +u_int32_t +arc4random(void) +{ + if (!rs_initialized || arc4_stir_pid != getpid()) + arc4random_stir(); + return arc4_getword(&rs); +} + +#if 0 +/*-------- Test code --------*/ +#include <stdlib.h> +#include <stdio.h> + +int main(void) { + int random_number; + random_number = arc4random() % 65536; + printf("A random number between 0 and 65536 is %d\n", random_number); + return 0; +} +#endif diff -Naur glibc-2.3.6.orig/stdlib/arc4randomII.c glibc-2.3.6/stdlib/arc4randomII.c --- glibc-2.3.6.orig/stdlib/arc4randomII.c 1970-01-01 00:00:00.000000000 +0000 +++ glibc-2.3.6/stdlib/arc4randomII.c 2006-01-01 07:48:48.000000000 +0000 @@ -0,0 +1,196 @@ +/* + * Arc4 random number generator for OpenBSD. + * Copyright 1996 David Mazieres <[EMAIL PROTECTED]>. + * + * Modification and redistribution in source and binary forms is + * permitted provided that due credit is given to the author and the + * OpenBSD project by leaving this copyright notice intact. + */ + +/* + * This code is derived from section 17.1 of Applied Cryptography, + * second edition, which describes a stream cipher allegedly + * compatible with RSA Labs "RC4" cipher (the actual description of + * which is a trade secret). The same algorithm is used as a stream + * cipher called "arcfour" in Tatu Ylonen's ssh package. + * + * Here the stream cipher has been modified always to include the time + * when initializing the state. That makes it impossible to + * regenerate the same random sequence twice, so this can't be used + * for encryption, but will generate good random numbers. + * + * RC4 is a registered trademark of RSA Laboratories. + */ + +/* + * Modified by Robert Connolly from OpenBSD lib/libc/crypt/arc4random.c v1.11. + * This is arc4randomII(3) using erandom. + */ + +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/param.h> +#include <sys/time.h> +#include <sys/sysctl.h> + +#ifdef __GNUC__ +#define inline __inline +#else /* !__GNUC__ */ +#define inline +#endif /* !__GNUC__ */ + +struct arc4_streamII { + u_int8_t i; + u_int8_t j; + u_int8_t s[256]; +}; + +static int rs_initializedII; +static struct arc4_streamII rs; +static pid_t arc4_stir_pidII; + +static inline u_int8_t arc4_getbyteII(struct arc4_streamII *); + +static inline void +arc4_initII(struct arc4_streamII *as) +{ + int n; + + for (n = 0; n < 256; n++) + as->s[n] = n; + as->i = 0; + as->j = 0; +} + +static inline void +arc4_addrandomII(struct arc4_streamII *as, u_char *dat, int datlen) +{ + int n; + u_int8_t si; + + as->i--; + for (n = 0; n < 256; n++) { + as->i = (as->i + 1); + si = as->s[as->i]; + as->j = (as->j + si + dat[n % datlen]); + as->s[as->i] = as->s[as->j]; + as->s[as->j] = si; + } + as->j = as->i; +} + +static void +arc4_stirII(struct arc4_streamII *as) +{ + int n, fd; + struct { + struct timeval tv; + u_int rnd[(128 - sizeof(struct timeval)) / sizeof(u_int)]; + } rdat; + + gettimeofday(&rdat.tv, NULL); + + /* /dev/urandom is a multithread interface, sysctl is not. */ + /* Try to use /dev/urandom before sysctl. */ + fd = open("/dev/erandom", O_RDONLY); + if (fd != -1) { + read(fd, rdat.rnd, sizeof(rdat.rnd)); + close(fd); + } + +#if defined(SYSCTL_ERANDOM) + else { + /* /dev/urandom failed? Maybe we're in a chroot. */ + int mib[]={CTL_KERN, KERN_RANDOM, RANDOM_ERANDOM}; + u_int i; + size_t len; + + for (i = 0; i < sizeof(rdat.rnd) / sizeof(u_int); i++) { + len = sizeof(u_int); + if (sysctl(mib, 3, &rdat.rnd[i], &len, NULL, 0) == -1) + break; + } + } +#endif + + arc4_stir_pidII = getpid(); + /* + * Time to give up. If no entropy could be found then we will just + * use gettimeofday. + */ + arc4_addrandomII(as, (void *)&rdat, sizeof(rdat)); + + /* + * Discard early keystream, as per recommendations in: + * http://www.wisdom.weizmann.ac.il/~itsik/RC4/Papers/Rc4_ksa.ps + * We discard 256 words. A long word is 4 bytes. + */ + for (n = 0; n < 256 * 4; n ++) + arc4_getbyteII(as); +} + +static inline u_int8_t +arc4_getbyteII(struct arc4_streamII *as) +{ + u_int8_t si, sj; + + as->i = (as->i + 1); + si = as->s[as->i]; + as->j = (as->j + si); + sj = as->s[as->j]; + as->s[as->i] = sj; + as->s[as->j] = si; + return (as->s[(si + sj) & 0xff]); +} + +static inline u_int32_t +arc4_getwordII(struct arc4_streamII *as) +{ + u_int32_t val; + val = arc4_getbyteII(as) << 24; + val |= arc4_getbyteII(as) << 16; + val |= arc4_getbyteII(as) << 8; + val |= arc4_getbyteII(as); + return val; +} + +void +arc4random_stirII(void) +{ + if (!rs_initializedII) { + arc4_initII(&rs); + rs_initializedII = 1; + } + arc4_stirII(&rs); +} + +void +arc4random_addrandomII(u_char *dat, int datlen) +{ + if (!rs_initializedII) + arc4random_stirII(); + arc4_addrandomII(&rs, dat, datlen); +} + +u_int32_t +arc4randomII(void) +{ + if (!rs_initializedII || arc4_stir_pidII != getpid()) + arc4random_stirII(); + return arc4_getwordII(&rs); +} + +#if 0 +/*-------- Test code --------*/ +#include <stdlib.h> +#include <stdio.h> + +int main(void) { + int random_number; + random_number = arc4randomII() % 65536; + printf("A random number between 0 and 65536 is %d\n", random_number); + return 0; +} +#endif diff -Naur glibc-2.3.6.orig/stdlib/stdlib.h glibc-2.3.6/stdlib/stdlib.h --- glibc-2.3.6.orig/stdlib/stdlib.h 2005-07-18 01:15:30.000000000 +0000 +++ glibc-2.3.6/stdlib/stdlib.h 2006-01-01 07:48:48.000000000 +0000 @@ -572,6 +572,15 @@ extern int lcong48_r (unsigned short int __param[7], struct drand48_data *__buffer) __THROW __nonnull ((1, 2)); + +#define LIBC_HAS_ARC4RANDOM +u_int32_t arc4random(void); +void arc4random_stir(void); +void arc4random_addrandom(unsigned char *, int); +u_int32_t arc4randomII(void); +void arc4random_stirII(void); +void arc4random_addrandomII(unsigned char *, int); + # endif /* Use misc. */ #endif /* Use SVID or X/Open. */ diff -Naur glibc-2.3.6.orig/sysdeps/posix/tempname.c glibc-2.3.6/sysdeps/posix/tempname.c --- glibc-2.3.6.orig/sysdeps/posix/tempname.c 2001-11-27 03:35:06.000000000 +0000 +++ glibc-2.3.6/sysdeps/posix/tempname.c 2006-01-01 07:48:48.000000000 +0000 @@ -258,6 +258,10 @@ /* This is where the Xs start. */ XXXXXX = &tmpl[len - 6]; +/* Get real random data. */ +#if defined(LIBC_HAS_ARC4RANDOM) + random_time_bits = arc4randomII(); +#else /* Get some more or less random data. */ #ifdef RANDOM_BITS RANDOM_BITS (random_time_bits); @@ -272,7 +276,12 @@ random_time_bits = time (NULL); # endif #endif +#endif +#if defined(LIBC_HAS_ARC4RANDOM) + value += random_time_bits ^ arc4randomII(); +#else value += random_time_bits ^ __getpid (); +#endif for (count = 0; count < attempts; value += 7777, ++count) {
Submitted By: Robert Connolly <robert at linuxfromscratch dot org> (ashes) Date: 2005-01-01 Initial Package Version: 2.3.6 Upstream Status: Not submitted Origin: http://www.research.ibm.com/trl/projects/security/ssp/ http://www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/sys/stack_protector.c http://uclibc.org/cgi-bin/viewcvs.cgi/trunk/uClibc/libc/sysdeps/linux/common/ssp.c Description: Stack Smashing Protector - This patch adds SSP functions to Glibc. This patch depends on the Glibc arc4random patch. Also see: http://www.linuxfromscratch.org/hlfs/ http://www.linuxfromscratch.org/hints/downloads/files/ssp.txt diff -Naur glibc-2.3.4.orig/sysdeps/generic/libc-start.c glibc-2.3.4/sysdeps/generic/libc-start.c --- glibc-2.3.4.orig/sysdeps/generic/libc-start.c 2004-03-31 01:46:43.000000000 +0000 +++ glibc-2.3.4/sysdeps/generic/libc-start.c 2005-02-12 17:26:49.470416840 +0000 @@ -188,6 +188,9 @@ GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]); #endif + void __guard_setup(void) __attribute__ ((constructor)); + __guard_setup (); + #ifdef HAVE_CLEANUP_JMP_BUF /* Memory for the cancellation buffer. */ struct pthread_unwind_buf unwind_buf; diff -Naur glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Dist glibc-2.3.4/sysdeps/unix/sysv/linux/Dist --- glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Dist 2004-06-30 07:58:38.000000000 +0000 +++ glibc-2.3.4/sysdeps/unix/sysv/linux/Dist 2005-02-12 17:26:49.473416384 +0000 @@ -1,3 +1,4 @@ +stack_protector.c bits/initspin.h cmsg_nxthdr.c dl-brk.c diff -Naur glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Makefile glibc-2.3.4/sysdeps/unix/sysv/linux/Makefile --- glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Makefile 2004-10-04 23:29:06.000000000 +0000 +++ glibc-2.3.4/sysdeps/unix/sysv/linux/Makefile 2005-02-12 17:26:49.476415928 +0000 @@ -1,5 +1,5 @@ ifeq ($(subdir),csu) -sysdep_routines += errno-loc +sysdep_routines += errno-loc stack_protector endif ifeq ($(subdir),assert) diff -Naur glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Versions glibc-2.3.4/sysdeps/unix/sysv/linux/Versions --- glibc-2.3.4.orig/sysdeps/unix/sysv/linux/Versions 2004-10-22 19:57:45.000000000 +0000 +++ glibc-2.3.4/sysdeps/unix/sysv/linux/Versions 2005-02-12 17:26:49.479415472 +0000 @@ -108,6 +108,7 @@ GLIBC_2.3.2 { # New kernel interfaces. epoll_create; epoll_ctl; epoll_wait; + __guard; __guard_setup; __stack_smash_handler; } GLIBC_2.3.3 { gnu_dev_major; gnu_dev_minor; gnu_dev_makedev; diff -Naur glibc-2.3.4.orig/sysdeps/unix/sysv/linux/stack_protector.c glibc-2.3.4/sysdeps/unix/sysv/linux/stack_protector.c --- glibc-2.3.4.orig/sysdeps/unix/sysv/linux/stack_protector.c 1970-01-01 00:00:00.000000000 +0000 +++ glibc-2.3.4/sysdeps/unix/sysv/linux/stack_protector.c 2005-02-12 18:00:25.757512648 +0000 @@ -0,0 +1,131 @@ +/* $hlfs: stack_protector.c,v 1.7 2005/04/24 robert Exp $ */ + +/* + * Copyright (c) 2002 Hiroaki Etoh, Federico G. Schwindt, and Miodrag Vallat. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/* One of these things is not like the other... */ + +/* + * Distributed under the terms of the GNU General Public License v2 + * $Header: $ + * + * This is a modified version of Hiroaki Etoh's stack smashing routines + * implemented for glibc. + * + * The following people have contributed input to this code. + * Ned Ludd - <[EMAIL PROTECTED]> + * Alexander Gabert - <[EMAIL PROTECTED]> + * The PaX Team - <[EMAIL PROTECTED]> + * Peter S. Mazinger - <[EMAIL PROTECTED]> + * Yoann Vandoorselaere - <[EMAIL PROTECTED]> + * Robert Connolly - <[EMAIL PROTECTED]> + * Cory Visi <[EMAIL PROTECTED]> + * + */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> /* For arc4random() */ +#include <fcntl.h> +#include <unistd.h> +#include <signal.h> +#include <syslog.h> + +#include <sys/types.h> +#include <sys/un.h> +#include <sys/time.h> + +#ifdef __PROPOLICE_BLOCK_SEGV__ +#define SSP_SIGTYPE SIGSEGV +#elif __PROPOLICE_BLOCK_KILL__ +#define SSP_SIGTYPE SIGKILL +#else +#define SSP_SIGTYPE SIGABRT +#endif + +unsigned long __guard = 0UL; + +//void __guard_setup(void) __attribute__ ((constructor)); +void __guard_setup(void) +{ + int i=0, fd=0; + size_t size; + struct timeval tv; + + if (__guard != 0UL) + return; + + __guard = 0xFF0A0D00UL; + /* Always start with the time. */ + gettimeofday(&tv, NULL); + __guard ^= tv.tv_usec ^ tv.tv_sec; + +#if defined(LIBC_HAS_ARC4RANDOM) /* From <stdlib.h> */ + for (i = 0; i < sizeof(__guard) / 4; i ++) { + size = sizeof(unsigned long); + if ((__guard = (int)(arc4randomII())) == (-1)) + break; + } +#else + if (i < sizeof(__guard) / 4) { + fd = open("/dev/urandom", O_RDONLY); + if (fd != (-1)) { + size = read(fd, (char *) &__guard, sizeof(__guard)); + close(fd); + if (size == sizeof(__guard)) + return; + } + } +#endif +} + +//void __stack_smash_handler(char func[], int damaged __attribute__ ((unused))); +void __stack_smash_handler(char func[], int damaged) +{ + extern char *__progname; + const char message[] = ": stack smashing attack in function "; + struct sigaction sa; + sigset_t mask; + + sigfillset(&mask); + + sigdelset(&mask, SSP_SIGTYPE); /* Block all signal handlers */ + sigprocmask(SIG_BLOCK, &mask, NULL); /* except SIGABRT */ + + /* print error message to stderr and syslog */ + fprintf(stderr, "%s%s%s()\n", __progname, message, func); + syslog(LOG_INFO, "%s%s%s()", __progname, message, func); + + /* Make the default handler is associated with the signal handler */ + memset(&sa, 0, sizeof(struct sigaction)); + sigfillset(&sa.sa_mask); /* Block all signals */ + sa.sa_flags = 0; + sa.sa_handler = SIG_DFL; + sigaction(SSP_SIGTYPE, &sa, NULL); + (void) kill(getpid(), SSP_SIGTYPE); + _exit(127); +}
Submitted By: Robert Connolly <robert at linuxfromscratch dot org> (ashes) Date: 2005-01-01 Initial Package Version: 0.9.7h Upstream Status: Not submitted Origin: None Description: This patch enables the arc4random() function in OpenSSL, when using the Glibc or uClibc arc4random patch. Also see: http://www.linuxfromscratch.org/hlfs/ http://www.linuxfromscratch.org/hints/downloads/files/entropy.txt diff -Naur openssl-0.9.7h.orig/crypto/rand/rand_unix.c openssl-0.9.7h/crypto/rand/rand_unix.c --- openssl-0.9.7h.orig/crypto/rand/rand_unix.c 2005-01-14 16:19:47.000000000 +0000 +++ openssl-0.9.7h/crypto/rand/rand_unix.c 2005-10-18 23:20:08.000000000 +0000 @@ -125,7 +125,7 @@ #include <unistd.h> #include <time.h> -#ifdef __OpenBSD__ +#if defined(__OpenBSD__) || defined(LIBC_HAS_ARC4RANDOM) int RAND_poll(void) { u_int32_t rnd = 0, i;
-- http://linuxfromscratch.org/mailman/listinfo/patches FAQ: http://www.linuxfromscratch.org/faq/ Unsubscribe: See the above information page
