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 <rpcsvc/dbm.h> header file. */
 143  #undef HAVE_RPCSVC_DBM_H
 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         osinit.c        \
 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,270 +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 -#include <sha1.h>
 198 -
 199 -void *
 200 -x_sha1_init(void)
 201 -{
 202 -    SHA1_CTX *ctx = malloc(sizeof(*ctx));
 203 -
 204 -    if (!ctx)
 205 -        return NULL;
 206 -    SHA1Init(ctx);
 207 -    return ctx;
 208 -}
 209 -
 210 -int
 211 -x_sha1_update(void *ctx, void *data, int size)
 212 -{
 213 -    SHA1_CTX *sha1_ctx = ctx;
 214 -
 215 -    SHA1Update(sha1_ctx, data, size);
 216 -    return 1;
 217 -}
 218 -
 219 -int
 220 -x_sha1_final(void *ctx, unsigned char result[20])
 221 -{
 222 -    SHA1_CTX *sha1_ctx = ctx;
 223 -
 224 -    SHA1Final(result, sha1_ctx);
 225 -    free(sha1_ctx);
 226 -    return 1;
 227 -}
 228 -
 229 -#elif defined(HAVE_SHA1_IN_COMMONCRYPTO)        /* Use CommonCrypto for SHA1 */
 230 -
 231 -#include <CommonCrypto/CommonDigest.h>
 232 -
 233 -void *
 234 -x_sha1_init(void)
 235 -{
 236 -    CC_SHA1_CTX *ctx = malloc(sizeof(*ctx));
 237 -
 238 -    if (!ctx)
 239 -        return NULL;
 240 -    CC_SHA1_Init(ctx);
 241 -    return ctx;
 242 -}
 243 -
 244 -int
 245 -x_sha1_update(void *ctx, void *data, int size)
 246 -{
 247 -    CC_SHA1_CTX *sha1_ctx = ctx;
 248 -
 249 -    CC_SHA1_Update(sha1_ctx, data, size);
 250 -    return 1;
 251 -}
 252 -
 253 -int
 254 -x_sha1_final(void *ctx, unsigned char result[20])
 255 -{
 256 -    CC_SHA1_CTX *sha1_ctx = ctx;
 257 -
 258 -    CC_SHA1_Final(result, sha1_ctx);
 259 -    free(sha1_ctx);
 260 -    return 1;
 261 -}
 262 -
 263 -#elif defined(HAVE_SHA1_IN_CRYPTOAPI)        /* Use CryptoAPI for SHA1 */
 264 -
 265 -#define WIN32_LEAN_AND_MEAN
 266 -#include <X11/Xwindows.h>
 267 -#include <wincrypt.h>
 268 -
 269 -static HCRYPTPROV hProv;
 270 -
 271 -void *
 272 -x_sha1_init(void)
 273 -{
 274 -    HCRYPTHASH *ctx = malloc(sizeof(*ctx));
 275 -
 276 -    if (!ctx)
 277 -        return NULL;
 278 -    CryptAcquireContext(&hProv, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
 279 -    CryptCreateHash(hProv, CALG_SHA1, 0, 0, ctx);
 280 -    return ctx;
 281 -}
 282 -
 283 -int
 284 -x_sha1_update(void *ctx, void *data, int size)
 285 -{
 286 -    HCRYPTHASH *hHash = ctx;
 287 -
 288 -    CryptHashData(*hHash, data, size, 0);
 289 -    return 1;
 290 -}
 291 -
 292 -int
 293 -x_sha1_final(void *ctx, unsigned char result[20])
 294 -{
 295 -    HCRYPTHASH *hHash = ctx;
 296 -    DWORD len = 20;
 297 -
 298 -    CryptGetHashParam(*hHash, HP_HASHVAL, result, &len, 0);
 299 -    CryptDestroyHash(*hHash);
 300 -    CryptReleaseContext(hProv, 0);
 301 -    free(ctx);
 302 -    return 1;
 303 -}
 304 -
 305 -#elif defined(HAVE_SHA1_IN_LIBNETTLE)   /* Use libnettle for SHA1 */
 306 -
 307 -#include <nettle/sha.h>
 308 -
 309 -void *
 310 -x_sha1_init(void)
 311 -{
 312 -    struct sha1_ctx *ctx = malloc(sizeof(*ctx));
 313 -
 314 -    if (!ctx)
 315 -        return NULL;
 316 -    sha1_init(ctx);
 317 -    return ctx;
 318 -}
 319 -
 320 -int
 321 -x_sha1_update(void *ctx, void *data, int size)
 322 -{
 323 -    sha1_update(ctx, size, data);
 324 -    return 1;
 325 -}
 326 -
 327 -int
 328 -x_sha1_final(void *ctx, unsigned char result[20])
 329 -{
 330 -    sha1_digest(ctx, 20, result);
 331 -    free(ctx);
 332 -    return 1;
 333 -}
 334 -
 335 -#elif defined(HAVE_SHA1_IN_LIBGCRYPT)   /* Use libgcrypt for SHA1 */
 336 -
 337 -#include <gcrypt.h>
 338 -
 339 -void *
 340 -x_sha1_init(void)
 341 -{
 342 -    static int init;
 343 -    gcry_md_hd_t h;
 344 -    gcry_error_t err;
 345 -
 346 -    if (!init) {
 347 -        if (!gcry_check_version(NULL))
 348 -            return NULL;
 349 -        gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
 350 -        gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
 351 -        init = 1;
 352 -    }
 353 -
 354 -    err = gcry_md_open(&h, GCRY_MD_SHA1, 0);
 355 -    if (err)
 356 -        return NULL;
 357 -    return h;
 358 -}
 359 -
 360 -int
 361 -x_sha1_update(void *ctx, void *data, int size)
 362 -{
 363 -    gcry_md_hd_t h = ctx;
 364 -
 365 -    gcry_md_write(h, data, size);
 366 -    return 1;
 367 -}
 368 -
 369 -int
 370 -x_sha1_final(void *ctx, unsigned char result[20])
 371 -{
 372 -    gcry_md_hd_t h = ctx;
 373 -
 374 -    memcpy(result, gcry_md_read(h, GCRY_MD_SHA1), 20);
 375 -    gcry_md_close(h);
 376 -    return 1;
 377 -}
 378 -
 379 -#elif defined(HAVE_SHA1_IN_LIBSHA1)     /* Use libsha1 */
 380 -
 381 -#include <libsha1.h>
 382 -
 383 -void *
 384 -x_sha1_init(void)
 385 -{
 386 -    sha1_ctx *ctx = malloc(sizeof(*ctx));
 387 -
 388 -    if (!ctx)
 389 -        return NULL;
 390 -    sha1_begin(ctx);
 391 -    return ctx;
 392 -}
 393 -
 394 -int
 395 -x_sha1_update(void *ctx, void *data, int size)
 396 -{
 397 -    sha1_hash(data, size, ctx);
 398 -    return 1;
 399 -}
 400 -
 401 -int
 402 -x_sha1_final(void *ctx, unsigned char result[20])
 403 -{
 404 -    sha1_end(result, ctx);
 405 -    free(ctx);
 406 -    return 1;
 407 -}
 408 -
 409 -#else                           /* Use OpenSSL's libcrypto */
 410 -
 411 -#include <stddef.h>             /* buggy openssl/sha.h wants size_t */
 412 -#include <openssl/sha.h>
 413 -
 414 -void *
 415 -x_sha1_init(void)
 416 -{
 417 -    int ret;
 418 -    SHA_CTX *ctx = malloc(sizeof(*ctx));
 419 -
 420 -    if (!ctx)
 421 -        return NULL;
 422 -    ret = SHA1_Init(ctx);
 423 -    if (!ret) {
 424 -        free(ctx);
 425 -        return NULL;
 426 -    }
 427 -    return ctx;
 428 -}
 429 -
 430 -int
 431 -x_sha1_update(void *ctx, void *data, int size)
 432 -{
 433 -    int ret;
 434 -    SHA_CTX *sha_ctx = ctx;
 435 -
 436 -    ret = SHA1_Update(sha_ctx, data, size);
 437 -    if (!ret)
 438 -        free(sha_ctx);
 439 -    return ret;
 440 -}
 441 -
 442 -int
 443 -x_sha1_final(void *ctx, unsigned char result[20])
 444 -{
 445 -    int ret;
 446 -    SHA_CTX *sha_ctx = ctx;
 447 -
 448 -    ret = SHA1_Final(result, sha_ctx);
 449 -    free(sha_ctx);
 450 -    return ret;
 451 -}
 452 -
 453 -#endif
 454 diff -urN xorg-server-1.17.0.org/render/glyph.c xorg-server-1.17.0/render/glyph.c
 455 --- xorg-server-1.17.0.org/render/glyph.c       2015-01-18 00:42:52.000000000 +0100
 456 +++ xorg-server-1.17.0/render/glyph.c   2015-02-04 19:34:23.458568095 +0100
 457 @@ -26,8 +26,7 @@
 458  #include <dix-config.h>
 459  #endif
 460
 461 -#include "xsha1.h"
 462 -
 463 +#include "sha1.h"
 464  #include "misc.h"
 465  #include "scrnintstr.h"
 466  #include "os.h"
 467 @@ -165,21 +164,13 @@
 468  HashGlyph(xGlyphInfo * gi,
 469            CARD8 *bits, unsigned long size, unsigned char sha1[20])
 470  {
 471 -    void *ctx = x_sha1_init();
 472 -    int success;
 473 +    SHA1_CTX ctx;
 474
 475 -    if (!ctx)
 476 -        return BadAlloc;
 477 +    SHA1Init (&ctx);
 478 +    SHA1Update (&ctx, gi, sizeof (xGlyphInfo));
 479 +    SHA1Update (&ctx, bits, size);
 480 +    SHA1Final (sha1, &ctx);
 481
 482 -    success = x_sha1_update(ctx, gi, sizeof(xGlyphInfo));
 483 -    if (!success)
 484 -        return BadAlloc;
 485 -    success = x_sha1_update(ctx, bits, size);
 486 -    if (!success)
 487 -        return BadAlloc;
 488 -    success = x_sha1_final(ctx, sha1);
 489 -    if (!success)
 490 -        return BadAlloc;
 491      return Success;
 492  }
 493
 494 diff -urN xorg-server-1.17.0.org/render/Makefile.am xorg-server-1.17.0/render/Makefile.am
 495 --- xorg-server-1.17.0.org/render/Makefile.am   2013-06-18 18:03:42.000000000 +0200
 496 +++ xorg-server-1.17.0/render/Makefile.am       2015-02-04 19:34:23.455234679 +0100
 497 @@ -13,8 +13,11 @@
 498         mitrap.c        \
 499         mitri.c         \
 500         picture.c       \
 501 +       sha1.c          \
 502         render.c
 503
 504  if XORG
 505  sdk_HEADERS = picture.h mipict.h glyphstr.h picturestr.h
 506  endif
 507 +
 508 +EXTRA_DIST = sha1.h
 509 diff -urN xorg-server-1.17.0.org/render/sha1.c xorg-server-1.17.0/render/sha1.c
 510 --- xorg-server-1.17.0.org/render/sha1.c        1970-01-01 01:00:00.000000000 +0100
 511 +++ xorg-server-1.17.0/render/sha1.c    2015-02-04 19:34:23.458568095 +0100
 512 @@ -0,0 +1,173 @@
 513 +/*
 514 + * SHA-1 in C
 515 + * By Steve Reid <steve@edmweb.com>
 516 + * 100% Public Domain
 517 + *
 518 + * Test Vectors (from FIPS PUB 180-1)
 519 + * "abc"
 520 + *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
 521 + * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
 522 + *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
 523 + * A million repetitions of "a"
 524 + *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
 525 + */
 526 +
 527 +#include <sys/param.h>
 528 +#include <string.h>
 529 +#include <sha1.h>
 530 +
 531 +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 532 +
 533 +/*
 534 + * blk0() and blk() perform the initial expand.
 535 + * I got the idea of expanding during the round function from SSLeay
 536 + */
 537 +#if BYTE_ORDER == LITTLE_ENDIAN
 538 +# define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
 539 +    |(rol(block->l[i],8)&0x00FF00FF))
 540 +#else
 541 +# define blk0(i) block->l[i]
 542 +#endif
 543 +#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
 544 +    ^block->l[(i+2)&15]^block->l[i&15],1))
 545 +
 546 +/*
 547 + * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
 548 + */
 549 +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
 550 +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
 551 +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
 552 +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
 553 +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
 554 +
 555 +/*
 556 + * Hash a single 512-bit block. This is the core of the algorithm.
 557 + */
 558 +void
 559 +SHA1Transform(uint32_t state[5], const uint8_t buffer[SHA1_BLOCK_LENGTH])
 560 +{
 561 +       uint32_t a, b, c, d, e;
 562 +       uint8_t workspace[SHA1_BLOCK_LENGTH];
 563 +       typedef union {
 564 +               uint8_t c[64];
 565 +               uint32_t l[16];
 566 +       } CHAR64LONG16;
 567 +       CHAR64LONG16 *block = (CHAR64LONG16 *)workspace;
 568 +
 569 +       (void)memcpy(block, buffer, SHA1_BLOCK_LENGTH);
 570 +
 571 +       /* Copy context->state[] to working vars */
 572 +       a = state[0];
 573 +       b = state[1];
 574 +       c = state[2];
 575 +       d = state[3];
 576 +       e = state[4];
 577 +
 578 +       /* 4 rounds of 20 operations each. Loop unrolled. */
 579 +       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);
 580 +       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);
 581 +       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);
 582 +       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);
 583 +       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);
 584 +       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);
 585 +       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);
 586 +       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);
 587 +       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);
 588 +       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);
 589 +       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);
 590 +       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);
 591 +       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);
 592 +       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);
 593 +       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);
 594 +       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);
 595 +       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);
 596 +       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);
 597 +       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);
 598 +       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);
 599 +
 600 +       /* Add the working vars back into context.state[] */
 601 +       state[0] += a;
 602 +       state[1] += b;
 603 +       state[2] += c;
 604 +       state[3] += d;
 605 +       state[4] += e;
 606 +
 607 +       /* Wipe variables */
 608 +       a = b = c = d = e = 0;
 609 +}
 610 +
 611 +
 612 +/*
 613 + * SHA1Init - Initialize new context
 614 + */
 615 +void
 616 +SHA1Init(SHA1_CTX *context)
 617 +{
 618 +
 619 +       /* SHA1 initialization constants */
 620 +       context->count = 0;
 621 +       context->state[0] = 0x67452301;
 622 +       context->state[1] = 0xEFCDAB89;
 623 +       context->state[2] = 0x98BADCFE;
 624 +       context->state[3] = 0x10325476;
 625 +       context->state[4] = 0xC3D2E1F0;
 626 +}
 627 +
 628 +
 629 +/*
 630 + * Run your data through this.
 631 + */
 632 +void
 633 +SHA1Update(SHA1_CTX *context, const uint8_t *data, size_t len)
 634 +{
 635 +       size_t i, j;
 636 +
 637 +       j = (size_t)((context->count >> 3) & 63);
 638 +       context->count += (len << 3);
 639 +       if ((j + len) > 63) {
 640 +               (void)memcpy(&context->buffer[j], data, (i = 64-j));
 641 +               SHA1Transform(context->state, context->buffer);
 642 +               for ( ; i + 63 < len; i += 64)
 643 +                       SHA1Transform(context->state, (uint8_t *)&data[i]);
 644 +               j = 0;
 645 +       } else {
 646 +               i = 0;
 647 +       }
 648 +       (void)memcpy(&context->buffer[j], &data[i], len - i);
 649 +}
 650 +
 651 +
 652 +/*
 653 + * Add padding and return the message digest.
 654 + */
 655 +void
 656 +SHA1Pad(SHA1_CTX *context)
 657 +{
 658 +       uint8_t finalcount[8];
 659 +       uint i;
 660 +
 661 +       for (i = 0; i < 8; i++) {
 662 +               finalcount[i] = (uint8_t)((context->count >>
 663 +                   ((7 - (i & 7)) * 8)) & 255);        /* Endian independent */
 664 +       }
 665 +       SHA1Update(context, (uint8_t *)"\200", 1);
 666 +       while ((context->count & 504) != 448)
 667 +               SHA1Update(context, (uint8_t *)"\0", 1);
 668 +       SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
 669 +}
 670 +
 671 +void
 672 +SHA1Final(uint8_t digest[SHA1_DIGEST_LENGTH], SHA1_CTX *context)
 673 +{
 674 +       uint i;
 675 +
 676 +       SHA1Pad(context);
 677 +       if (digest) {
 678 +               for (i = 0; i < SHA1_DIGEST_LENGTH; i++) {
 679 +                       digest[i] = (uint8_t)
 680 +                          ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
 681 +               }
 682 +               memset(context, 0, sizeof(*context));
 683 +       }
 684 +}
 685 +
 686 diff -urN xorg-server-1.17.0.org/render/sha1.h xorg-server-1.17.0/render/sha1.h
 687 --- xorg-server-1.17.0.org/render/sha1.h        1970-01-01 01:00:00.000000000 +0100
 688 +++ xorg-server-1.17.0/render/sha1.h    2015-02-04 19:34:23.458568095 +0100
 689 @@ -0,0 +1,63 @@
 690 +/*
 691 + * SHA-1 in C
 692 + * By Steve Reid <steve@edmweb.com>
 693 + * 100% Public Domain
 694 + */
 695 +
 696 +#ifndef _SHA1_H
 697 +#define _SHA1_H
 698 +
 699 +#include <stdint.h>
 700 +#include <stddef.h>
 701 +#include <unistd.h>
 702 +
 703 +
 704 +#define        SHA1_BLOCK_LENGTH               64
 705 +#define        SHA1_DIGEST_LENGTH              20
 706 +#define        SHA1_DIGEST_STRING_LENGTH       (SHA1_DIGEST_LENGTH * 2 + 1)
 707 +
 708 +typedef struct {
 709 +    uint32_t state[5];
 710 +    uint64_t count;
 711 +    uint8_t buffer[SHA1_BLOCK_LENGTH];
 712 +} SHA1_CTX;
 713 +
 714 +#include <sys/cdefs.h>
 715 +
 716 +__BEGIN_DECLS
 717 +void SHA1Init(SHA1_CTX *);
 718 +void SHA1Pad(SHA1_CTX *);
 719 +void SHA1Transform(uint32_t [5], const uint8_t [SHA1_BLOCK_LENGTH])
 720 +       __attribute__((__bounded__(__minbytes__,1,5)))
 721 +       __attribute__((__bounded__(__minbytes__,2,SHA1_BLOCK_LENGTH)));
 722 +void SHA1Update(SHA1_CTX *, const uint8_t *, size_t)
 723 +       __attribute__((__bounded__(__string__,2,3)));
 724 +void SHA1Final(uint8_t [SHA1_DIGEST_LENGTH], SHA1_CTX *)
 725 +       __attribute__((__bounded__(__minbytes__,1,SHA1_DIGEST_LENGTH)));
 726 +char *SHA1End(SHA1_CTX *, char *)
 727 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 728 +char *SHA1File(const char *, char *)
 729 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 730 +char *SHA1FileChunk(const char *, char *, off_t, off_t)
 731 +       __attribute__((__bounded__(__minbytes__,2,SHA1_DIGEST_STRING_LENGTH)));
 732 +char *SHA1Data(const uint8_t *, size_t, char *)
 733 +       __attribute__((__bounded__(__string__,1,2)))
 734 +       __attribute__((__bounded__(__minbytes__,3,SHA1_DIGEST_STRING_LENGTH)));
 735 +__END_DECLS
 736 +
 737 +#define HTONDIGEST(x) do {                                              \
 738 +        x[0] = htonl(x[0]);                                             \
 739 +        x[1] = htonl(x[1]);                                             \
 740 +        x[2] = htonl(x[2]);                                             \
 741 +        x[3] = htonl(x[3]);                                             \
 742 +        x[4] = htonl(x[4]); } while (0)
 743 +
 744 +#define NTOHDIGEST(x) do {                                              \
 745 +        x[0] = ntohl(x[0]);                                             \
 746 +        x[1] = ntohl(x[1]);                                             \
 747 +        x[2] = ntohl(x[2]);                                             \
 748 +        x[3] = ntohl(x[3]);                                             \
 749 +        x[4] = ntohl(x[4]); } while (0)
 750 +
 751 +#endif /* _SHA1_H */
 752 +