xorg-xserver-server-builtin-SHA1.patch

   1 diff -urN xorg-server-1.17.0.org/configure.ac xorg-server-1.17.0/configure.ac
   2 --- xorg-server-1.17.0.org/configure.ac 2015-02-02 07:40:17.000000000 +0100
   3 +++ xorg-server-1.17.0/configure.ac     2015-02-04 19:34:23.458568095 +0100
   4 @@ -1544,7 +1544,7 @@
   5
   6  if test "x$SPECIAL_DTRACE_OBJECTS" = "xyes" ; then
   7    DIX_LIB='$(top_builddir)/dix/dix.O'
   8 -  OS_LIB='$(top_builddir)/os/os.O $(SHA1_LIBS) $(DLOPEN_LIBS) $(LIBUNWIND_LIBS)'
   9 +  OS_LIB='$(top_builddir)/os/os.O $(DLOPEN_LIBS) $(LIBUNWIND_LIBS)'
  10  else
  11    DIX_LIB='$(top_builddir)/dix/libdix.la'
  12    OS_LIB='$(top_builddir)/os/libos.la'
  13 @@ -1566,124 +1566,6 @@
  14  MIEXT_SYNC_LIB='$(top_builddir)/miext/sync/libsync.la'
  15  CORE_INCS='-I$(top_srcdir)/include -I$(top_builddir)/include'
  16
  17 -# SHA1 hashing
  18 -AC_ARG_WITH([sha1],
  19 -            [AS_HELP_STRING([--with-sha1=libc|libmd|libnettle|libgcrypt|libcrypto|libsha1|CommonCrypto|CryptoAPI],
  20 -                            [choose SHA1 implementation])])
  21 -AC_CHECK_FUNC([SHA1Init], [HAVE_SHA1_IN_LIBC=yes])
  22 -if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_LIBC" = xyes; then
  23 -       with_sha1=libc
  24 -fi
  25 -if test "x$with_sha1" = xlibc && test "x$HAVE_SHA1_IN_LIBC" != xyes; then
  26 -       AC_MSG_ERROR([libc requested but not found])
  27 -fi
  28 -if test "x$with_sha1" = xlibc; then
  29 -       AC_DEFINE([HAVE_SHA1_IN_LIBC], [1],
  30 -               [Use libc SHA1 functions])
  31 -       SHA1_LIBS=""
  32 -fi
  33 -AC_CHECK_FUNC([CC_SHA1_Init], [HAVE_SHA1_IN_COMMONCRYPTO=yes])
  34 -if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_COMMONCRYPTO" = xyes; then
  35 -       with_sha1=CommonCrypto
  36 -fi
  37 -if test "x$with_sha1" = xCommonCrypto && test "x$HAVE_SHA1_IN_COMMONCRYPTO" != xyes; then
  38 -       AC_MSG_ERROR([CommonCrypto requested but not found])
  39 -fi
  40 -if test "x$with_sha1" = xCommonCrypto; then
  41 -       AC_DEFINE([HAVE_SHA1_IN_COMMONCRYPTO], [1],
  42 -               [Use CommonCrypto SHA1 functions])
  43 -       SHA1_LIBS=""
  44 -fi
  45 -dnl stdcall functions cannot be tested with AC_CHECK_LIB
  46 -AC_CHECK_HEADER([wincrypt.h], [HAVE_SHA1_IN_CRYPTOAPI=yes], [], [#include <windows.h>])
  47 -if test "x$with_sha1" = x && test "x$HAVE_SHA1_IN_CRYPTOAPI" = xyes; then
  48 -       with_sha1=CryptoAPI
  49 -fi
  50 -if test "x$with_sha1" = xCryptoAPI && test "x$HAVE_SHA1_IN_CRYPTOAPI" != xyes; then
  51 -       AC_MSG_ERROR([CryptoAPI requested but not found])
  52 -fi
  53 -if test "x$with_sha1" = xCryptoAPI; then
  54 -       AC_DEFINE([HAVE_SHA1_IN_CRYPTOAPI], [1],
  55 -               [Use CryptoAPI SHA1 functions])
  56 -       SHA1_LIBS=""
  57 -fi
  58 -AC_CHECK_LIB([md], [SHA1Init], [HAVE_LIBMD=yes])
  59 -if test "x$with_sha1" = x && test "x$HAVE_LIBMD" = xyes; then
  60 -       with_sha1=libmd
  61 -fi
  62 -if test "x$with_sha1" = xlibmd && test "x$HAVE_LIBMD" != xyes; then
  63 -       AC_MSG_ERROR([libmd requested but not found])
  64 -fi
  65 -if test "x$with_sha1" = xlibmd; then
  66 -       AC_DEFINE([HAVE_SHA1_IN_LIBMD], [1],
  67 -                 [Use libmd SHA1 functions])
  68 -       SHA1_LIBS=-lmd
  69 -fi
  70 -PKG_CHECK_MODULES([LIBSHA1], [libsha1], [HAVE_LIBSHA1=yes], [HAVE_LIBSHA1=no])
  71 -if test "x$with_sha1" = x && test "x$HAVE_LIBSHA1" = xyes; then
  72 -   with_sha1=libsha1
  73 -fi
  74 -if test "x$with_sha1" = xlibsha1 && test "x$HAVE_LIBSHA1" != xyes; then
  75 -       AC_MSG_ERROR([libsha1 requested but not found])
  76 -fi
  77 -if test "x$with_sha1" = xlibsha1; then
  78 -       AC_DEFINE([HAVE_SHA1_IN_LIBSHA1], [1],
  79 -                 [Use libsha1 for SHA1])
  80 -       SHA1_LIBS=-lsha1
  81 -fi
  82 -AC_CHECK_LIB([nettle], [nettle_sha1_init], [HAVE_LIBNETTLE=yes])
  83 -if test "x$with_sha1" = x && test "x$HAVE_LIBNETTLE" = xyes; then
  84 -       with_sha1=libnettle
  85 -fi
  86 -if test "x$with_sha1" = xlibnettle && test "x$HAVE_LIBNETTLE" != xyes; then
  87 -       AC_MSG_ERROR([libnettle requested but not found])
  88 -fi
  89 -if test "x$with_sha1" = xlibnettle; then
  90 -       AC_DEFINE([HAVE_SHA1_IN_LIBNETTLE], [1],
  91 -                 [Use libnettle SHA1 functions])
  92 -       SHA1_LIBS=-lnettle
  93 -fi
  94 -AC_CHECK_LIB([gcrypt], [gcry_md_open], [HAVE_LIBGCRYPT=yes])
  95 -if test "x$with_sha1" = x && test "x$HAVE_LIBGCRYPT" = xyes; then
  96 -       with_sha1=libgcrypt
  97 -fi
  98 -if test "x$with_sha1" = xlibgcrypt && test "x$HAVE_LIBGCRYPT" != xyes; then
  99 -       AC_MSG_ERROR([libgcrypt requested but not found])
 100 -fi
 101 -if test "x$with_sha1" = xlibgcrypt; then
 102 -       AC_DEFINE([HAVE_SHA1_IN_LIBGCRYPT], [1],
 103 -                 [Use libgcrypt SHA1 functions])
 104 -       SHA1_LIBS=-lgcrypt
 105 -fi
 106 -# We don't need all of the OpenSSL libraries, just libcrypto
 107 -AC_CHECK_LIB([crypto], [SHA1_Init], [HAVE_LIBCRYPTO=yes])
 108 -PKG_CHECK_MODULES([OPENSSL], [openssl], [HAVE_OPENSSL_PKC=yes],
 109 -                  [HAVE_OPENSSL_PKC=no])
 110 -if test "x$HAVE_LIBCRYPTO" = xyes || test "x$HAVE_OPENSSL_PKC" = xyes; then
 111 -       if test "x$with_sha1" = x; then
 112 -               with_sha1=libcrypto
 113 -       fi
 114 -else
 115 -       if test "x$with_sha1" = xlibcrypto; then
 116 -               AC_MSG_ERROR([OpenSSL libcrypto requested but not found])
 117 -       fi
 118 -fi
 119 -if test "x$with_sha1" = xlibcrypto; then
 120 -       if test "x$HAVE_LIBCRYPTO" = xyes; then
 121 -               SHA1_LIBS=-lcrypto
 122 -       else
 123 -               SHA1_LIBS="$OPENSSL_LIBS"
 124 -               SHA1_CFLAGS="$OPENSSL_CFLAGS"
 125 -       fi
 126 -fi
 127 -AC_MSG_CHECKING([for SHA1 implementation])
 128 -if test "x$with_sha1" = x; then
 129 -       AC_MSG_ERROR([No suitable SHA1 implementation found])
 130 -fi
 131 -AC_MSG_RESULT([$with_sha1])
 132 -AC_SUBST(SHA1_LIBS)
 133 -AC_SUBST(SHA1_CFLAGS)
 134 -
 135  PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
 136  PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
 137
 138 diff -urN xorg-server-1.17.0.org/include/dix-config.h.in xorg-server-1.17.0/include/dix-config.h.in
 139 --- xorg-server-1.17.0.org/include/dix-config.h.in      2014-10-09 14:15:31.000000000 +0200
 140 +++ xorg-server-1.17.0/include/dix-config.h.in  2015-02-04 19:34:23.455234679 +0100
 141 @@ -152,27 +152,6 @@
 142  /* Define to 1 if you have the `arc4random_buf' function. */
 143  #undef HAVE_ARC4RANDOM_BUF
 144
 145 -/* Define to use libc SHA1 functions */
 146 -#undef HAVE_SHA1_IN_LIBC
 147 -
 148 -/* Define to use CommonCrypto SHA1 functions */
 149 -#undef HAVE_SHA1_IN_COMMONCRYPTO
 150 -
 151 -/* Define to use CryptoAPI SHA1 functions */
 152 -#undef HAVE_SHA1_IN_CRYPTOAPI
 153 -
 154 -/* Define to use libmd SHA1 functions */
 155 -#undef HAVE_SHA1_IN_LIBMD
 156 -
 157 -/* Define to use libgcrypt SHA1 functions */
 158 -#undef HAVE_SHA1_IN_LIBGCRYPT
 159 -
 160 -/* Define to use libnettle SHA1 functions */
 161 -#undef HAVE_SHA1_IN_LIBNETTLE
 162 -
 163 -/* Define to use libsha1 for SHA1 */
 164 -#undef HAVE_SHA1_IN_LIBSHA1
 165 -
 166  /* Define to 1 if you have the `shmctl64' function. */
 167  #undef HAVE_SHMCTL64
 168
 169 diff -urN xorg-server-1.17.0.org/os/Makefile.am xorg-server-1.17.0/os/Makefile.am
 170 --- xorg-server-1.17.0.org/os/Makefile.am       2013-11-12 00:15:00.000000000 +0100
 171 +++ xorg-server-1.17.0/os/Makefile.am   2015-02-04 19:34:23.455234679 +0100
 172 @@ -21,7 +21,6 @@
 173         ospoll.h        \
 174         utils.c         \
 175         xdmauth.c       \
 176 -       xsha1.c         \
 177         xstrans.c       \
 178         xprintf.c       \
 179         $(XORG_SRCS)
 180 diff -urN xorg-server-1.17.0.org/os/xsha1.c xorg-server-1.17.0/os/xsha1.c
 181 --- xorg-server-1.17.0.org/os/xsha1.c   2015-01-18 00:42:52.000000000 +0100
 182 +++ xorg-server-1.17.0/os/xsha1.c       2015-02-04 19:34:23.455234679 +0100
 183 @@ -23,279 +23,3 @@
 184   * DEALINGS IN THE SOFTWARE.
 185   */
 186
 187 -#ifdef HAVE_DIX_CONFIG_H
 188 -#include <dix-config.h>
 189 -#endif
 190 -
 191 -#include "os.h"
 192 -#include "xsha1.h"
 193 -
 194 -#if defined(HAVE_SHA1_IN_LIBMD)  /* Use libmd for SHA1 */ \
 195 -       || defined(HAVE_SHA1_IN_LIBC)   /* Use libc for SHA1 */
 196 -
 197 -#if defined(__DragonFly__) || defined(__FreeBSD__)
 198 -#include <sha.h>
 199 -#define        SHA1End         SHA1_End
 200 -#define        SHA1File        SHA1_File
 201 -#define        SHA1Final       SHA1_Final
 202 -#define        SHA1Init        SHA1_Init
 203 -#define        SHA1Update      SHA1_Update
 204 -#else
 205 -#include <sha1.h>
 206 -#endif
 207 -
 208 -void *
 209 -x_sha1_init(void)
 210 -{
 211 -    SHA1_CTX *ctx = malloc(sizeof(*ctx));
 212 -
 213 -    if (!ctx)
 214 -        return NULL;
 215 -    SHA1Init(ctx);
 216 -    return ctx;
 217 -}
 218 -
 219 -int
 220 -x_sha1_update(void *ctx, void *data, int size)
 221 -{
 222 -    SHA1_CTX *sha1_ctx = ctx;
 223 -
 224 -    SHA1Update(sha1_ctx, data, size);
 225 -    return 1;
 226 -}
 227 -
 228 -int
 229 -x_sha1_final(void *ctx, unsigned char result[20])
 230 -{
 231 -    SHA1_CTX *sha1_ctx = ctx;
 232 -
 233 -    SHA1Final(result, sha1_ctx);
 234 -    free(sha1_ctx);
 235 -    return 1;
 236 -}
 237 -
 238 -#elif defined(HAVE_SHA1_IN_COMMONCRYPTO)        /* Use CommonCrypto for SHA1 */
 239 -
 240 -#include <CommonCrypto/CommonDigest.h>
 241 -
 242 -void *
 243 -x_sha1_init(void)
 244 -{
 245 -    CC_SHA1_CTX *ctx = malloc(sizeof(*ctx));
 246 -
 247 -    if (!ctx)
 248 -        return NULL;
 249 -    CC_SHA1_Init(ctx);
 250 -    return ctx;
 251 -}
 252 -
 253 -int
 254 -x_sha1_update(void *ctx, void *data, int size)
 255 -{
 256 -    CC_SHA1_CTX *sha1_ctx = ctx;
 257 -
 258 -    CC_SHA1_Update(sha1_ctx, data, size);
 259 -    return 1;
 260 -}
 261 -
 262 -int
 263 -x_sha1_final(void *ctx, unsigned char result[20])
 264 -{
 265 -    CC_SHA1_CTX *sha1_ctx = ctx;
 266 -
 267 -    CC_SHA1_Final(result, sha1_ctx);
 268 -    free(sha1_ctx);
 269 -    return 1;
 270 -}
 271 -
 272 -#elif defined(HAVE_SHA1_IN_CRYPTOAPI)        /* Use CryptoAPI for SHA1 */
 273 -
 274 -#define WIN32_LEAN_AND_MEAN
 275 -#include <X11/Xwindows.h>
 276 -#include <wincrypt.h>
 277 -
 278 -static HCRYPTPROV hProv;
 279 -
 280 -void *
 281 -x_sha1_init(void)
 282 -{
 283 -    HCRYPTHASH *ctx = malloc(sizeof(*ctx));
 284 -
 285 -    if (!ctx)
 286 -        return NULL;
 287 -    CryptAcquireContext(&hProv, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 288 -    CryptCreateHash(hProv, CALG_SHA1, 0, 0, ctx);
 289 -    return ctx;
 290 -}
 291 -
 292 -int
 293 -x_sha1_update(void *ctx, void *data, int size)
 294 -{
 295 -    HCRYPTHASH *hHash = ctx;
 296 -
 297 -    CryptHashData(*hHash, data, size, 0);
 298 -    return 1;
 299 -}
 300 -
 301 -int
 302 -x_sha1_final(void *ctx, unsigned char result[20])
 303 -{
 304 -    HCRYPTHASH *hHash = ctx;
 305 -    DWORD len = 20;
 306 -
 307 -    CryptGetHashParam(*hHash, HP_HASHVAL, result, &len, 0);
 308 -    CryptDestroyHash(*hHash);
 309 -    CryptReleaseContext(hProv, 0);
 310 -    free(ctx);
 311 -    return 1;
 312 -}
 313 -
 314 -#elif defined(HAVE_SHA1_IN_LIBNETTLE)   /* Use libnettle for SHA1 */
 315 -
 316 -#include <nettle/sha.h>
 317 -
 318 -void *
 319 -x_sha1_init(void)
 320 -{
 321 -    struct sha1_ctx *ctx = malloc(sizeof(*ctx));
 322 -
 323 -    if (!ctx)
 324 -        return NULL;
 325 -    sha1_init(ctx);
 326 -    return ctx;
 327 -}
 328 -
 329 -int
 330 -x_sha1_update(void *ctx, void *data, int size)
 331 -{
 332 -    sha1_update(ctx, size, data);
 333 -    return 1;
 334 -}
 335 -
 336 -int
 337 -x_sha1_final(void *ctx, unsigned char result[20])
 338 -{
 339 -    sha1_digest(ctx, 20, result);
 340 -    free(ctx);
 341 -    return 1;
 342 -}
 343 -
 344 -#elif defined(HAVE_SHA1_IN_LIBGCRYPT)   /* Use libgcrypt for SHA1 */
 345 -
 346 -#include <gcrypt.h>
 347 -
 348 -void *
 349 -x_sha1_init(void)
 350 -{
 351 -    static int init;
 352 -    gcry_md_hd_t h;
 353 -    gcry_error_t err;
 354 -
 355 -    if (!init) {
 356 -        if (!gcry_check_version(NULL))
 357 -            return NULL;
 358 -        gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
 359 -        gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
 360 -        init = 1;
 361 -    }
 362 -
 363 -    err = gcry_md_open(&h, GCRY_MD_SHA1, 0);
 364 -    if (err)
 365 -        return NULL;
 366 -    return h;
 367 -}
 368 -
 369 -int
 370 -x_sha1_update(void *ctx, void *data, int size)
 371 -{
 372 -    gcry_md_hd_t h = ctx;
 373 -
 374 -    gcry_md_write(h, data, size);
 375 -    return 1;
 376 -}
 377 -
 378 -int
 379 -x_sha1_final(void *ctx, unsigned char result[20])
 380 -{
 381 -    gcry_md_hd_t h = ctx;
 382 -
 383 -    memcpy(result, gcry_md_read(h, GCRY_MD_SHA1), 20);
 384 -    gcry_md_close(h);
 385 -    return 1;
 386 -}
 387 -
 388 -#elif defined(HAVE_SHA1_IN_LIBSHA1)     /* Use libsha1 */
 389 -
 390 -#include <libsha1.h>
 391 -
 392 -void *
 393 -x_sha1_init(void)
 394 -{
 395 -    sha1_ctx *ctx = malloc(sizeof(*ctx));
 396 -
 397 -    if (!ctx)
 398 -        return NULL;
 399 -    sha1_begin(ctx);
 400 -    return ctx;
 401 -}
 402 -
 403 -int
 404 -x_sha1_update(void *ctx, void *data, int size)
 405 -{
 406 -    sha1_hash(data, size, ctx);
 407 -    return 1;
 408 -}
 409 -
 410 -int
 411 -x_sha1_final(void *ctx, unsigned char result[20])
 412 -{
 413 -    sha1_end(result, ctx);
 414 -    free(ctx);
 415 -    return 1;
 416 -}
 417 -
 418 -#else                           /* Use OpenSSL's libcrypto */
 419 -
 420 -#include <stddef.h>             /* buggy openssl/sha.h wants size_t */
 421 -#include <openssl/sha.h>
 422 -
 423 -void *
 424 -x_sha1_init(void)
 425 -{
 426 -    int ret;
 427 -    SHA_CTX *ctx = malloc(sizeof(*ctx));
 428 -
 429 -    if (!ctx)
 430 -        return NULL;
 431 -    ret = SHA1_Init(ctx);
 432 -    if (!ret) {
 433 -        free(ctx);
 434 -        return NULL;
 435 -    }
 436 -    return ctx;
 437 -}
 438 -
 439 -int
 440 -x_sha1_update(void *ctx, void *data, int size)
 441 -{
 442 -    int ret;
 443 -    SHA_CTX *sha_ctx = ctx;
 444 -
 445 -    ret = SHA1_Update(sha_ctx, data, size);
 446 -    if (!ret)
 447 -        free(sha_ctx);
 448 -    return ret;
 449 -}
 450 -
 451 -int
 452 -x_sha1_final(void *ctx, unsigned char result[20])
 453 -{
 454 -    int ret;
 455 -    SHA_CTX *sha_ctx = ctx;
 456 -
 457 -    ret = SHA1_Final(result, sha_ctx);
 458 -    free(sha_ctx);
 459 -    return ret;
 460 -}
 461 -
 462 -#endif
 463 diff -urN xorg-server-1.17.0.org/render/glyph.c xorg-server-1.17.0/render/glyph.c
 464 --- xorg-server-1.17.0.org/render/glyph.c       2015-01-18 00:42:52.000000000 +0100
 465 +++ xorg-server-1.17.0/render/glyph.c   2015-02-04 19:34:23.458568095 +0100
 466 @@ -26,8 +26,7 @@
 467  #include <dix-config.h>
 468  #endif
 469
 470 -#include "xsha1.h"
 471 -
 472 +#include "sha1.h"
 473  #include "misc.h"
 474  #include "scrnintstr.h"
 475  #include "os.h"
 476 @@ -165,21 +164,13 @@
 477  HashGlyph(xGlyphInfo * gi,
 478            CARD8 *bits, unsigned long size, unsigned char sha1[20])
 479  {
 480 -    void *ctx = x_sha1_init();
 481 -    int success;
 482 +    SHA1_CTX ctx;
 483
 484 -    if (!ctx)
 485 -        return BadAlloc;
 486 +    SHA1Init (&ctx);
 487 +    SHA1Update (&ctx, gi, sizeof (xGlyphInfo));
 488 +    SHA1Update (&ctx, bits, size);
 489 +    SHA1Final (sha1, &ctx);
 490
 491 -    success = x_sha1_update(ctx, gi, sizeof(xGlyphInfo));
 492 -    if (!success)
 493 -        return BadAlloc;
 494 -    success = x_sha1_update(ctx, bits, size);
 495 -    if (!success)
 496 -        return BadAlloc;
 497 -    success = x_sha1_final(ctx, sha1);
 498 -    if (!success)
 499 -        return BadAlloc;
 500      return Success;
 501  }
 502
 503 diff -urN xorg-server-1.17.0.org/render/Makefile.am xorg-server-1.17.0/render/Makefile.am
 504 --- xorg-server-1.17.0.org/render/Makefile.am   2013-06-18 18:03:42.000000000 +0200
 505 +++ xorg-server-1.17.0/render/Makefile.am       2015-02-04 19:34:23.455234679 +0100
 506 @@ -13,8 +13,11 @@
 507         mitrap.c        \
 508         mitri.c         \
 509         picture.c       \
 510 +       sha1.c          \
 511         render.c
 512
 513  if XORG
 514  sdk_HEADERS = picture.h mipict.h glyphstr.h picturestr.h
 515  endif
 516 +
 517 +EXTRA_DIST = sha1.h
 518 diff -urN xorg-server-1.17.0.org/render/sha1.c xorg-server-1.17.0/render/sha1.c
 519 --- xorg-server-1.17.0.org/render/sha1.c        1970-01-01 01:00:00.000000000 +0100
 520 +++ xorg-server-1.17.0/render/sha1.c    2015-02-04 19:34:23.458568095 +0100
 521 @@ -0,0 +1,173 @@
 522 +/*
 523 + * SHA-1 in C
 524 + * By Steve Reid <steve@edmweb.com>
 525 + * 100% Public Domain
 526 + *
 527 + * Test Vectors (from FIPS PUB 180-1)
 528 + * "abc"
 529 + *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
 530 + * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
 531 + *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
 532 + * A million repetitions of "a"
 533 + *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
 534 + */
 535 +
 536 +#include <sys/param.h>
 537 +#include <string.h>
 538 +#include <sha1.h>
 539 +
 540 +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 541 +
 542 +/*
 543 + * blk0() and blk() perform the initial expand.
 544 + * I got the idea of expanding during the round function from SSLeay
 545 + */
 546 +#if BYTE_ORDER == LITTLE_ENDIAN
 547 +# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
 548 +    |(rol(block->l[i],8)&0x00FF00FF))
 549 +#else
 550 +# define blk0(i) block->l[i]
 551 +#endif
 552 +#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
 553 +    ^block->l[(i+2)&15]^block->l[i&15],1))
 554 +
 555 +/*
 556 + * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
 557 + */
 558 +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
 559 +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
 560 +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
 561 +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
 562 +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
 563 +
 564 +/*
 565 + * Hash a single 512-bit block. This is the core of the algorithm.
 566 + */
 567 +void
 568 +SHA1Transform(uint32_t state[5], const uint8_t buffer[SHA1_BLOCK_LENGTH])
 569 +{
 570 +       uint32_t a, b, c, d, e;
 571 +       uint8_t workspace[SHA1_BLOCK_LENGTH];
 572 +       typedef union {
 573 +               uint8_t c[64];
 574 +               uint32_t l[16];
 575 +       } CHAR64LONG16;
 576 +       CHAR64LONG16 *block = (CHAR64LONG16 *)workspace;
 577 +
 578 +       (void)memcpy(block, buffer, SHA1_BLOCK_LENGTH);
 579 +
 580 +       /* Copy context->state[] to working vars */
 581 +       a = state[0];
 582 +       b = state[1];
 583 +       c = state[2];
 584 +       d = state[3];
 585 +       e = state[4];
 586 +
 587 +       /* 4 rounds of 20 operations each. Loop unrolled. */
 588 +       R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
 589 +       R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
 590 +       R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
 591 +       R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
 592 +       R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
 593 +       R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
 594 +       R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
 595 +       R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
 596 +       R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
 597 +       R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
 598 +       R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
 599 +       R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
 600 +       R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
 601 +       R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
 602 +       R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
 603 +       R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
 604 +       R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
 605 +       R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
 606 +       R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
 607 +       R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
 608 +
 609 +       /* Add the working vars back into context.state[] */
 610 +       state[0] += a;
 611 +       state[1] += b;
 612 +       state[2] += c;
 613 +       state[3] += d;
 614 +       state[4] += e;
 615 +
 616 +       /* Wipe variables */
 617 +       a = b = c = d = e = 0;
 618 +}
 619 +
 620 +
 621 +/*
 622 + * SHA1Init - Initialize new context
 623 + */
 624 +void
 625 +SHA1Init(SHA1_CTX *context)
 626 +{
 627 +
 628 +       /* SHA1 initialization constants */
 629 +       context->count = 0;
 630 +       context->state[0] = 0x67452301;
 631 +       context->state[1] = 0xEFCDAB89;
 632 +       context->state[2] = 0x98BADCFE;
 633 +       context->state[3] = 0x10325476;
 634 +       context->state[4] = 0xC3D2E1F0;
 635 +}
 636 +
 637 +
 638 +/*
 639 + * Run your data through this.
 640 + */
 641 +void
 642 +SHA1Update(SHA1_CTX *context, const uint8_t *data, size_t len)
 643 +{
 644 +       size_t i, j;
 645 +
 646 +       j = (size_t)((context->count >> 3) & 63);
 647 +       context->count += (len << 3);
 648 +       if ((j + len) > 63) {
 649 +               (void)memcpy(&context->buffer[j], data, (i = 64-j));
 650 +               SHA1Transform(context->state, context->buffer);
 651 +               for ( ; i + 63 < len; i += 64)
 652 +                       SHA1Transform(context->state, (uint8_t *)&data[i]);
 653 +               j = 0;
 654 +       } else {
 655 +               i = 0;
 656 +       }
 657 +       (void)memcpy(&context->buffer[j], &data[i], len - i);
 658 +}
 659 +
 660 +
 661 +/*
 662 + * Add padding and return the message digest.
 663 + */
 664 +void
 665 +SHA1Pad(SHA1_CTX *context)
 666 +{
 667 +       uint8_t finalcount[8];
 668 +       uint i;
 669 +
 670 +       for (i = 0; i < 8; i++) {
 671 +               finalcount[i] = (uint8_t)((context->count >>
 672 +                   ((7 - (i & 7)) * 8)) & 255);        /* Endian independent */
 673 +       }
 674 +       SHA1Update(context, (uint8_t *)"\200", 1);
 675 +       while ((context->count & 504) != 448)
 676 +               SHA1Update(context, (uint8_t *)"\0", 1);
 677 +       SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
 678 +}
 679 +
 680 +void
 681 +SHA1Final(uint8_t digest[SHA1_DIGEST_LENGTH], SHA1_CTX *context)
 682 +{
 683 +       uint i;
 684 +
 685 +       SHA1Pad(context);
 686 +       if (digest) {
 687 +               for (i = 0; i < SHA1_DIGEST_LENGTH; i++) {
 688 +                       digest[i] = (uint8_t)
 689 +                          ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
 690 +               }
 691 +               memset(context, 0, sizeof(*context));
 692 +       }
 693 +}
 694 +
 695 diff -urN xorg-server-1.17.0.org/render/sha1.h xorg-server-1.17.0/render/sha1.h
 696 --- xorg-server-1.17.0.org/render/sha1.h        1970-01-01 01:00:00.000000000 +0100
 697 +++ xorg-server-1.17.0/render/sha1.h    2015-02-04 19:34:23.458568095 +0100
 698 @@ -0,0 +1,63 @@
 699 +/*
 700 + * SHA-1 in C
 701 + * By Steve Reid <steve@edmweb.com>
 702 + * 100% Public Domain
 703 + */
 704 +
 705 +#ifndef _SHA1_H
 706 +#define _SHA1_H
 707 +
 708 +#include <stdint.h>
 709 +#include <stddef.h>
 710 +#include <unistd.h>
 711 +
 712 +
 713 +#define        SHA1_BLOCK_LENGTH               64
 714 +#define        SHA1_DIGEST_LENGTH              20
 715 +#define        SHA1_DIGEST_STRING_LENGTH       (SHA1_DIGEST_LENGTH * 2 + 1)
 716 +
 717 +typedef struct {
 718 +    uint32_t state[5];
 719 +    uint64_t count;
 720 +    uint8_t buffer[SHA1_BLOCK_LENGTH];
 721 +} SHA1_CTX;
 722 +
 723 +#include <sys/cdefs.h>
 724 +
 725 +__BEGIN_DECLS
 726 +void SHA1Init(SHA1_CTX *);
 727 +void SHA1Pad(SHA1_CTX *);
 728 +void SHA1Transform(uint32_t [5], const uint8_t [SHA1_BLOCK_LENGTH])
 729 +       __attribute__((__bounded__(__minbytes__,1,5)))
 730 +       __attribute__((__bounded__(__minbytes__,2,SHA1_BLOCK_LENGTH)));
 731 +void SHA1Update(SHA1_CTX *, const uint8_t *, size_t)
 732 +       __attribute__((__bounded__(__string__,2,3)));
 733 +void SHA1Final(uint8_t [SHA1_DIGEST_LENGTH], SHA1_CTX *)
 734 +       __attribute__((__bounded__(__minbytes__,1,SHA1_DIGEST_LENGTH)));
 735 +char *SHA1End(SHA1_CTX *, char *)
 736 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 737 +char *SHA1File(const char *, char *)
 738 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 739 +char *SHA1FileChunk(const char *, char *, off_t, off_t)
 740 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 741 +char *SHA1Data(const uint8_t *, size_t, char *)
 742 +       __attribute__((__bounded__(__string__,1,2)))
 743 +       __attribute__((__bounded__(__minbytes__,3,SHA1_DIGEST_STRING_LENGTH)));
 744 +__END_DECLS
 745 +
 746 +#define HTONDIGEST(x) do {                                              \
 747 +        x[0] = htonl(x[0]);                                             \
 748 +        x[1] = htonl(x[1]);                                             \
 749 +        x[2] = htonl(x[2]);                                             \
 750 +        x[3] = htonl(x[3]);                                             \
 751 +        x[4] = htonl(x[4]); } while (0)
 752 +
 753 +#define NTOHDIGEST(x) do {                                              \
 754 +        x[0] = ntohl(x[0]);                                             \
 755 +        x[1] = ntohl(x[1]);                                             \
 756 +        x[2] = ntohl(x[2]);                                             \
 757 +        x[3] = ntohl(x[3]);                                             \
 758 +        x[4] = ntohl(x[4]); } while (0)
 759 +
 760 +#endif /* _SHA1_H */
 761 +