From 21b2cf6a821a41a2ac6be7346728b52dcc7ad329 Mon Sep 17 00:00:00 2001
From: Britney Fransen <brfransen@gmail.com>
Date: Fri, 27 Oct 2017 18:20:58 +0000
Subject: nss: update to 3.33

---
 abs/extra/nss/PKGBUILD                        | 120 ++--
 abs/extra/nss/bug1400603.patch                | 942 ++++++++++++++++++++++++++
 abs/extra/nss/bundle.sh                       |  42 +-
 abs/extra/nss/ca-certificates-mozilla.install |  11 -
 abs/extra/nss/certdata2pem.py                 | 198 +++++-
 abs/extra/nss/enable-libpkix.patch            |  12 +
 abs/extra/nss/legacy-certs.patch              |  26 -
 abs/extra/nss/no-plt.diff                     |  48 ++
 abs/extra/nss/nss-config.xml                  | 132 ++++
 abs/extra/nss/nss.install                     |  13 -
 abs/extra/nss/nss.pc.in                       |   2 +-
 11 files changed, 1383 insertions(+), 163 deletions(-)
 create mode 100644 abs/extra/nss/bug1400603.patch
 delete mode 100644 abs/extra/nss/ca-certificates-mozilla.install
 create mode 100644 abs/extra/nss/enable-libpkix.patch
 delete mode 100644 abs/extra/nss/legacy-certs.patch
 create mode 100644 abs/extra/nss/no-plt.diff
 create mode 100644 abs/extra/nss/nss-config.xml
 delete mode 100644 abs/extra/nss/nss.install

diff --git a/abs/extra/nss/PKGBUILD b/abs/extra/nss/PKGBUILD
index 4bf9a60..4e84761 100644
--- a/abs/extra/nss/PKGBUILD
+++ b/abs/extra/nss/PKGBUILD
@@ -3,43 +3,48 @@
 
 pkgbase=nss
 pkgname=(nss ca-certificates-mozilla)
-pkgver=3.20
-pkgrel=1
-pkgdesc="Mozilla Network Security Services"
+pkgver=3.33
+pkgrel=2
+pkgdesc="Network Security Services"
+url="https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS"
 arch=(i686 x86_64)
-url="http://www.mozilla.org/projects/security/pki/nss/"
-license=('MPL' 'GPL')
-_nsprver=4.10.8
-depends=("nspr>=${_nsprver}" 'sqlite' 'zlib' 'sh' 'p11-kit')
-makedepends=('perl' 'python2')
-options=('!strip' '!makeflags' 'staticlibs')
-source=("https://ftp.mozilla.org/pub/mozilla.org/security/nss/releases/NSS_${pkgver//./_}_RTM/src/${pkgbase}-${pkgver}.tar.gz"
-        certdata2pem.py bundle.sh nss.pc.in nss-config.in legacy-certs.patch)
-sha256sums=('5e38d4b9837ca338af966b97fc91c07f67ad647fb38dc4af3cfd0d84e477d15c'
-            '2a2ff9131c21fa3b23ad7c7a2f069eabc783e56c6eb05419ac5f365f48dea0fc'
-            '045f520403f715a4cc7f3607b4e2c9bcc88fee5bce58d462fddaa2fdb0e4c180'
-            'b9f1428ca2305bf30b109507ff335fa00bce5a7ce0434b50acd26ad7c47dd5bd'
+license=(MPL GPL)
+_nsprver=4.15
+depends=("nspr>=${_nsprver}" sqlite zlib sh p11-kit)
+makedepends=(perl python2 xmlto docbook-xsl gyp)
+options=(!strip !makeflags staticlibs)
+source=("https://ftp.mozilla.org/pub/security/nss/releases/NSS_${pkgver//./_}_RTM/src/nss-${pkgver}.tar.gz"
+        certdata2pem.py bundle.sh nss.pc.in nss-config.in nss-config.xml enable-libpkix.patch no-plt.diff bug1400603.patch)
+sha256sums=('98f0dabd36408e83dd3a11727336cc3cdfee4cbdd9aede2b2831eb2389c284e4'
+            '512b12a2f13129be62c008b4df0153f527dd7d71c2c5183de99dfa2a1c49dd8a'
+            '3bfadf722da6773bdabdd25bdf78158648043d1b7e57615574f189a88ca865dd'
+            'f2208c4f70373ff9b60f53d733f8071d4e390c384b776dfc04bf26c306882faf'
             'e44ac5095b4d88f24ec7b2e6a9f1581560bd3ad41a3d198596d67ef22f67adb9'
-            '22330fcde2dac5fa4733f7d77bffbbd31d91cbaa338738afdc2a8ebfccb61184')
+            '98ace873c63e8e870286bce3ed53249aa2655cc1f53e7049061476e650ab06f1'
+            '0b68c5ffbfeec090e950e5703e6b0519eafcb7eaf4fe2f64c355d0ddf17eed30'
+            'ea8e1b871c0f1dd29cdea1b1a2e7f47bf4713e2ae7b947ec832dba7dfcc67daa'
+            'c2a477710a53738e91712a7a203b84d65a514af62d8efffaa977070843a7794a')
 
 prepare() {
-  mkdir certs
+  mkdir certs path
 
-  cd nss-$pkgver
+  ln -s /usr/bin/python2 path/python
+
+  echo -n "$(date +"%e %B %Y")" >date.xml
+  echo -n "$pkgver" >version.xml
+  xmlto man nss-config.xml
 
-  # FS#45479: Reenable two weak Verisign certificates used by login.live.com
-  # Otherwise, accessing this site via Epiphany (GnuTLS) or Skype (OpenSSL) fails
-  # Also see https://gist.github.com/grawity/15eabf67191e17080241
-  patch nss/lib/ckfw/builtins/certdata.txt ../legacy-certs.patch
+  cd nss-$pkgver
 
-  # Respect LDFLAGS
-  sed -e 's/\$(MKSHLIB) -o/\$(MKSHLIB) \$(LDFLAGS) -o/' \
-      -i nss/coreconf/rules.mk
+  patch -Np1 -i ../enable-libpkix.patch
+  patch -Np2 -i ../no-plt.diff
 
   ln -sr nss/lib/ckfw/builtins/certdata.txt ../certs/
   ln -sr nss/lib/ckfw/builtins/nssckbi.h ../certs/
-}
 
+  cd nss
+  patch -Np0 -i ../../bug1400603.patch
+}
 
 build() {
   cd certs
@@ -49,29 +54,15 @@ build() {
   sh bundle.sh
 
   cd nss-$pkgver/nss
-  export BUILD_OPT=1
-  export NSS_USE_SYSTEM_SQLITE=1
-  export NSS_ENABLE_ECC=1
-  export NSPR_INCLUDE_DIR="`nspr-config --includedir`"
-  export NSPR_LIB_DIR="`nspr-config --libdir`"
-  export XCFLAGS="${CFLAGS}"
-
-  [ "$CARCH" = "x86_64" ] && export USE_64=1
-
-  make -C coreconf
-  make -C lib/dbm
-  make
+  PATH="$srcdir/path:$PATH" bash -x ./build.sh -v \
+    --opt --system-sqlite --system-nspr --disable-tests
 }
 
 package_nss() {
-  install=nss.install
-
   cd nss-$pkgver
-  install -d "$pkgdir"/usr/{bin,include/nss,lib/pkgconfig}
 
-  NSS_VMAJOR=$(grep '#define.*NSS_VMAJOR' nss/lib/nss/nss.h | awk '{print $3}')
-  NSS_VMINOR=$(grep '#define.*NSS_VMINOR' nss/lib/nss/nss.h | awk '{print $3}')
-  NSS_VPATCH=$(grep '#define.*NSS_VPATCH' nss/lib/nss/nss.h | awk '{print $3}')
+  { read _vmajor; read _vminor; read _vpatch; } \
+    < <(awk '/#define.*NSS_V(MAJOR|MINOR|PATCH)/ {print $3}' nss/lib/nss/nss.h)
 
   sed ../nss.pc.in \
     -e "s,%libdir%,/usr/lib,g" \
@@ -79,8 +70,8 @@ package_nss() {
     -e "s,%exec_prefix%,/usr/bin,g" \
     -e "s,%includedir%,/usr/include/nss,g" \
     -e "s,%NSPR_VERSION%,${_nsprver},g" \
-    -e "s,%NSS_VERSION%,${pkgver},g" \
-    > "$pkgdir/usr/lib/pkgconfig/nss.pc"
+    -e "s,%NSS_VERSION%,${pkgver},g" |
+    install -Dm644 /dev/stdin "$pkgdir/usr/lib/pkgconfig/nss.pc"
   ln -s nss.pc "$pkgdir/usr/lib/pkgconfig/mozilla-nss.pc"
 
   sed ../nss-config.in \
@@ -88,33 +79,32 @@ package_nss() {
     -e "s,@prefix@,/usr/bin,g" \
     -e "s,@exec_prefix@,/usr/bin,g" \
     -e "s,@includedir@,/usr/include/nss,g" \
-    -e "s,@MOD_MAJOR_VERSION@,${NSS_VMAJOR},g" \
-    -e "s,@MOD_MINOR_VERSION@,${NSS_VMINOR},g" \
-    -e "s,@MOD_PATCH_VERSION@,${NSS_VPATCH},g" \
-    > "$pkgdir/usr/bin/nss-config"
-  chmod 755 "$pkgdir/usr/bin/nss-config"
+    -e "s,@MOD_MAJOR_VERSION@,${_vmajor},g" \
+    -e "s,@MOD_MINOR_VERSION@,${_vminor},g" \
+    -e "s,@MOD_PATCH_VERSION@,${_vpatch},g" |
+    install -D /dev/stdin "$pkgdir/usr/bin/nss-config"
+  install -Dt "$pkgdir/usr/share/man/man1" -m644 ../nss-config.1
 
-  cd dist/*.OBJ/bin
-  install -t "$pkgdir/usr/bin" *util shlibsign signtool signver ssltap
+  cd nss/doc/nroff
+  install -Dt "$pkgdir/usr/share/man/man1" -m644 *util.1 signtool.1 signver.1 ssltap.1
 
-  cd ../lib
-  install -t "$pkgdir/usr/lib" *.so
-  install -t "$pkgdir/usr/lib" -m644 libcrmf.a *.chk
+  cd ../../../dist
+  install -Dt "$pkgdir/usr/include/nss" -m644 public/nss/*.h
 
-  cd ../../public/nss
-  install -t "$pkgdir/usr/include/nss" -m644 *.h
+  cd Release/bin
+  install -Dt "$pkgdir/usr/bin" *util shlibsign signtool signver ssltap
+
+  cd ../lib
+  install -Dt "$pkgdir/usr/lib" *.so
+  install -Dt "$pkgdir/usr/lib" -m644 *.chk
 
-  rm "$pkgdir/usr/lib/libnssckbi.so"
-  ln -s libnssckbi-p11-kit.so "$pkgdir/usr/lib/libnssckbi.so"
+  ln -sf libnssckbi-p11-kit.so "$pkgdir/usr/lib/libnssckbi.so"
 }
 
 package_ca-certificates-mozilla() {
   pkgdesc="Mozilla's set of trusted CA certificates"
   depends=(ca-certificates-utils)
-  install=ca-certificates-mozilla.install
 
-  local _certdir="$pkgdir/usr/share/ca-certificates/trust-source"
-  install -Dm644 ca-bundle.trust.crt "$_certdir/mozilla.trust.crt"
-  install -Dm644 ca-bundle.neutral-trust.crt "$_certdir/mozilla.neutral-trust.crt"
-  install -Dm644 ca-bundle.supplement.p11-kit "$_certdir/mozilla.supplement.p11-kit"
+  install -Dm644 ca-bundle.trust.p11-kit \
+    "$pkgdir/usr/share/ca-certificates/trust-source/mozilla.trust.p11-kit"
 }
diff --git a/abs/extra/nss/bug1400603.patch b/abs/extra/nss/bug1400603.patch
new file mode 100644
index 0000000..321f50d
--- /dev/null
+++ b/abs/extra/nss/bug1400603.patch
@@ -0,0 +1,942 @@
+commit e84403331d99
+Author: Daiki Ueno <dueno@redhat.com>
+Date:   Fri Sep 22 11:27:34 2017 +0200
+
+    Bug 1400603 - freebl: Reorganize AES-GCM source code based on hw/sw implementation, r=franziskus
+    
+    Reviewers: franziskus
+    
+    Reviewed By: franziskus
+    
+    Bug #: 1400603
+    
+    Differential Revision: https://phabricator.services.mozilla.com/D65
+---
+ lib/freebl/Makefile   |   4 +-
+ lib/freebl/aes-x86.c  | 157 +++++++++++++++++++++++++++++++++++++++++
+ lib/freebl/freebl.gyp |  65 ++++++++++-------
+ lib/freebl/gcm-x86.c  | 127 ++++++++++++++++++++++++++++++++++
+ lib/freebl/gcm.c      | 162 +++++++++++++------------------------------
+ lib/freebl/gcm.h      |  14 ++++
+ lib/freebl/rijndael.c | 188 ++++++++------------------------------------------
+ lib/freebl/rijndael.h |  18 ++++-
+ 8 files changed, 436 insertions(+), 299 deletions(-)
+
+diff --git lib/freebl/Makefile lib/freebl/Makefile
+index d50e18696b..bc1ea86a5e 100644
+--- lib/freebl/Makefile
++++ lib/freebl/Makefile
+@@ -110,7 +110,9 @@ endif
+ # NSS_X86_OR_X64 means the target is either x86 or x64
+ ifeq (,$(filter-out i386 x386 x86 x86_64,$(CPU_ARCH)))
+         DEFINES += -DNSS_X86_OR_X64
+-        CFLAGS += -mpclmul -maes
++        EXTRA_SRCS += gcm-x86.c aes-x86.c
++$(OBJDIR)/gcm-x86.o: CFLAGS += -mpclmul -maes
++$(OBJDIR)/aes-x86.o: CFLAGS += -mpclmul -maes
+ ifneq (,$(USE_64)$(USE_X32))
+         DEFINES += -DNSS_X64
+ else
+diff --git lib/freebl/aes-x86.c lib/freebl/aes-x86.c
+new file mode 100644
+index 0000000000..830b4782fe
+--- /dev/null
++++ lib/freebl/aes-x86.c
+@@ -0,0 +1,157 @@
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifdef FREEBL_NO_DEPEND
++#include "stubs.h"
++#endif
++#include "rijndael.h"
++#include "secerr.h"
++
++#include <wmmintrin.h> /* aes-ni */
++
++#define EXPAND_KEY128(k, rcon, res)                   \
++    tmp_key = [REDACTED](k, rcon);     \
++    tmp_key = [REDACTED](tmp_key, 0xFF);       \
++    tmp = _mm_xor_si128(k, _mm_slli_si128(k, 4));     \
++    tmp = _mm_xor_si128(tmp, _mm_slli_si128(tmp, 4)); \
++    tmp = _mm_xor_si128(tmp, _mm_slli_si128(tmp, 4)); \
++    res = _mm_xor_si128(tmp, tmp_key)
++
++static void
++native_key_expansion128(AESContext *cx, const unsigned char *key)
++{
++    __m128i *keySchedule = cx->keySchedule;
++    pre_align __m128i tmp_key post_align;
++    pre_align __m128i tmp post_align;
++    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
++    EXPAND_KEY128(keySchedule[0], 0x01, keySchedule[1]);
++    EXPAND_KEY128(keySchedule[1], 0x02, keySchedule[2]);
++    EXPAND_KEY128(keySchedule[2], 0x04, keySchedule[3]);
++    EXPAND_KEY128(keySchedule[3], 0x08, keySchedule[4]);
++    EXPAND_KEY128(keySchedule[4], 0x10, keySchedule[5]);
++    EXPAND_KEY128(keySchedule[5], 0x20, keySchedule[6]);
++    EXPAND_KEY128(keySchedule[6], 0x40, keySchedule[7]);
++    EXPAND_KEY128(keySchedule[7], 0x80, keySchedule[8]);
++    EXPAND_KEY128(keySchedule[8], 0x1B, keySchedule[9]);
++    EXPAND_KEY128(keySchedule[9], 0x36, keySchedule[10]);
++}
++
++#define EXPAND_KEY192_PART1(res, k0, kt, rcon)                                \
++    tmp2 = _mm_slli_si128(k0, 4);                                             \
++    tmp1 = _mm_xor_si128(k0, tmp2);                                           \
++    tmp2 = _mm_slli_si128(tmp2, 4);                                           \
++    tmp1 = _mm_xor_si128(_mm_xor_si128(tmp1, tmp2), _mm_slli_si128(tmp2, 4)); \
++    tmp2 = _mm_aeskeygenassist_si128(kt, rcon);                               \
++    res = _mm_xor_si128(tmp1, _mm_shuffle_epi32(tmp2, 0x55))
++
++#define EXPAND_KEY192_PART2(res, k1, k2)             \
++    tmp2 = _mm_xor_si128(k1, _mm_slli_si128(k1, 4)); \
++    res = _mm_xor_si128(tmp2, _mm_shuffle_epi32(k2, 0xFF))
++
++#define EXPAND_KEY192(k0, res1, res2, res3, carry, rcon1, rcon2)         \
++    EXPAND_KEY192_PART1(tmp3, k0, res1, rcon1);                          \
++    EXPAND_KEY192_PART2(carry, res1, tmp3);                              \
++    res1 = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(res1),       \
++                                           _mm_castsi128_pd(tmp3), 0));  \
++    res2 = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(tmp3),       \
++                                           _mm_castsi128_pd(carry), 1)); \
++    EXPAND_KEY192_PART1(res3, tmp3, carry, rcon2)
++
++static void
++native_key_expansion192(AESContext *cx, const unsigned char *key)
++{
++    __m128i *keySchedule = cx->keySchedule;
++    pre_align __m128i tmp1 post_align;
++    pre_align __m128i tmp2 post_align;
++    pre_align __m128i tmp3 post_align;
++    pre_align __m128i carry post_align;
++    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
++    keySchedule[1] = _mm_loadu_si128((__m128i *)(key + 16));
++    EXPAND_KEY192(keySchedule[0], keySchedule[1], keySchedule[2],
++                  keySchedule[3], carry, 0x1, 0x2);
++    EXPAND_KEY192_PART2(keySchedule[4], carry, keySchedule[3]);
++    EXPAND_KEY192(keySchedule[3], keySchedule[4], keySchedule[5],
++                  keySchedule[6], carry, 0x4, 0x8);
++    EXPAND_KEY192_PART2(keySchedule[7], carry, keySchedule[6]);
++    EXPAND_KEY192(keySchedule[6], keySchedule[7], keySchedule[8],
++                  keySchedule[9], carry, 0x10, 0x20);
++    EXPAND_KEY192_PART2(keySchedule[10], carry, keySchedule[9]);
++    EXPAND_KEY192(keySchedule[9], keySchedule[10], keySchedule[11],
++                  keySchedule[12], carry, 0x40, 0x80);
++}
++
++#define EXPAND_KEY256_PART(res, rconx, k1x, k2x, X)                           \
++    tmp_key = [REDACTED]([REDACTED](k2x, rconx), X);    \
++    tmp2 = _mm_slli_si128(k1x, 4);                                            \
++    tmp1 = _mm_xor_si128(k1x, tmp2);                                          \
++    tmp2 = _mm_slli_si128(tmp2, 4);                                           \
++    tmp1 = _mm_xor_si128(_mm_xor_si128(tmp1, tmp2), _mm_slli_si128(tmp2, 4)); \
++    res = _mm_xor_si128(tmp1, tmp_key);
++
++#define EXPAND_KEY256(res1, res2, k1, k2, rcon)   \
++    EXPAND_KEY256_PART(res1, rcon, k1, k2, 0xFF); \
++    EXPAND_KEY256_PART(res2, 0x00, k2, res1, 0xAA)
++
++static void
++native_key_expansion256(AESContext *cx, const unsigned char *key)
++{
++    __m128i *keySchedule = cx->keySchedule;
++    pre_align __m128i tmp_key post_align;
++    pre_align __m128i tmp1 post_align;
++    pre_align __m128i tmp2 post_align;
++    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
++    keySchedule[1] = _mm_loadu_si128((__m128i *)(key + 16));
++    EXPAND_KEY256(keySchedule[2], keySchedule[3], keySchedule[0],
++                  keySchedule[1], 0x01);
++    EXPAND_KEY256(keySchedule[4], keySchedule[5], keySchedule[2],
++                  keySchedule[3], 0x02);
++    EXPAND_KEY256(keySchedule[6], keySchedule[7], keySchedule[4],
++                  keySchedule[5], 0x04);
++    EXPAND_KEY256(keySchedule[8], keySchedule[9], keySchedule[6],
++                  keySchedule[7], 0x08);
++    EXPAND_KEY256(keySchedule[10], keySchedule[11], keySchedule[8],
++                  keySchedule[9], 0x10);
++    EXPAND_KEY256(keySchedule[12], keySchedule[13], keySchedule[10],
++                  keySchedule[11], 0x20);
++    EXPAND_KEY256_PART(keySchedule[14], 0x40, keySchedule[12],
++                       keySchedule[13], 0xFF);
++}
++
++/*
++ * AES key expansion using aes-ni instructions.
++ */
++void
++rijndael_native_key_expansion(AESContext *cx, const unsigned char *key,
++                              unsigned int Nk)
++{
++    switch (Nk) {
++        case 4:
++            native_key_expansion128(cx, key);
++            return;
++        case 6:
++            native_key_expansion192(cx, key);
++            return;
++        case 8:
++            native_key_expansion256(cx, key);
++            return;
++        default:
++            /* This shouldn't happen (checked by the caller). */
++            return;
++    }
++}
++
++void
++rijndael_native_encryptBlock(AESContext *cx,
++                             unsigned char *output,
++                             const unsigned char *input)
++{
++    int i;
++    pre_align __m128i m post_align = _mm_loadu_si128((__m128i *)input);
++    m = _mm_xor_si128(m, cx->keySchedule[0]);
++    for (i = 1; i < cx->Nr; ++i) {
++        m = _mm_aesenc_si128(m, cx->keySchedule[i]);
++    }
++    m = _mm_aesenclast_si128(m, cx->keySchedule[cx->Nr]);
++    _mm_storeu_si128((__m128i *)output, m);
++}
+diff --git lib/freebl/freebl.gyp lib/freebl/freebl.gyp
+index 1e93475004..5f59eef29c 100644
+--- lib/freebl/freebl.gyp
++++ lib/freebl/freebl.gyp
+@@ -22,6 +22,37 @@
+         '-mssse3'
+       ]
+     },
++    {
++      'target_name': 'gcm-aes-x86_c_lib',
++      'type': 'static_library',
++      'sources': [
++        'gcm-x86.c', 'aes-x86.c'
++      ],
++      'dependencies': [
++        '<(DEPTH)/exports.gyp:nss_exports'
++      ],
++      # Enable isa option for pclmul and aes-ni; supported since gcc 4.4.
++      # This is only supported by x84/x64. It's not needed for Windows,
++      # unless clang-cl is used.
++      'cflags_mozilla': [
++        '-mpclmul', '-maes'
++      ],
++      'conditions': [
++        [ 'OS=="linux" or OS=="android" or OS=="dragonfly" or OS=="freebsd" or OS=="netbsd" or OS=="openbsd"', {
++          'cflags': [
++            '-mpclmul', '-maes'
++          ],
++        }],
++        # macOS build doesn't use cflags.
++        [ 'OS=="mac"', {
++          'xcode_settings': {
++            'OTHER_CFLAGS': [
++              '-mpclmul', '-maes'
++            ],
++          },
++        }]
++      ]
++    },
+     {
+       'target_name': 'freebl',
+       'type': 'static_library',
+@@ -45,6 +76,11 @@
+         '<(DEPTH)/exports.gyp:nss_exports',
+       ],
+       'conditions': [
++        [ 'target_arch=="ia32" or target_arch=="x64"', {
++          'dependencies': [
++            'gcm-aes-x86_c_lib'
++          ],
++        }],
+         [ 'OS=="linux"', {
+           'defines!': [
+             'FREEBL_NO_DEPEND',
+@@ -76,6 +112,11 @@
+         '<(DEPTH)/exports.gyp:nss_exports',
+       ],
+       'conditions': [
++        [ 'target_arch=="ia32" or target_arch=="x64"', {
++          'dependencies': [
++            'gcm-aes-x86_c_lib'
++          ]
++        }],
+         [ 'OS!="linux" and OS!="android"', {
+           'conditions': [
+             [ 'moz_fold_libs==0', {
+@@ -154,27 +195,11 @@
+       'MP_API_COMPATIBLE'
+     ],
+     'conditions': [
+-      [ 'target_arch=="ia32" or target_arch=="x64"', {
+-        'cflags_mozilla': [
+-          '-mpclmul',
+-          '-maes',
+-        ],
+-        'conditions': [
+-          [ 'OS=="dragonfly" or OS=="freebsd" or OS=="netbsd" or OS=="openbsd"', {
+-            'cflags': [
+-              '-mpclmul',
+-              '-maes',
+-            ],
+-          }],
+-        ],
+-      }],
+       [ 'OS=="mac"', {
+         'xcode_settings': {
+           # I'm not sure since when this is supported.
+           # But I hope that doesn't matter. We also assume this is x86/x64.
+           'OTHER_CFLAGS': [
+-            '-mpclmul',
+-            '-maes',
+             '-std=gnu99',
+           ],
+         },
+@@ -268,14 +293,6 @@
+               'MP_USE_UINT_DIGIT',
+             ],
+           }],
+-          [ 'target_arch=="ia32" or target_arch=="x64"', {
+-            'cflags': [
+-              # enable isa option for pclmul am aes-ni; supported since gcc 4.4
+-              # This is only support by x84/x64. It's not needed for Windows.
+-              '-mpclmul',
+-              '-maes',
+-            ],
+-          }],
+           [ 'target_arch=="arm"', {
+             'defines': [
+               'MP_ASSEMBLY_MULTIPLY',
+diff --git lib/freebl/gcm-x86.c lib/freebl/gcm-x86.c
+new file mode 100644
+index 0000000000..e34d633943
+--- /dev/null
++++ lib/freebl/gcm-x86.c
+@@ -0,0 +1,127 @@
++/* This Source Code Form is subject to the terms of the Mozilla Public
++ * License, v. 2.0. If a copy of the MPL was not distributed with this
++ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
++
++#ifdef FREEBL_NO_DEPEND
++#include "stubs.h"
++#endif
++#include "gcm.h"
++#include "secerr.h"
++
++#include <wmmintrin.h> /* clmul */
++
++#define WRITE64(x, bytes)   \
++    (bytes)[0] = (x) >> 56; \
++    (bytes)[1] = (x) >> 48; \
++    (bytes)[2] = (x) >> 40; \
++    (bytes)[3] = (x) >> 32; \
++    (bytes)[4] = (x) >> 24; \
++    (bytes)[5] = (x) >> 16; \
++    (bytes)[6] = (x) >> 8;  \
++    (bytes)[7] = (x);
++
++SECStatus
++gcm_HashWrite_hw(gcmHashContext *ghash, unsigned char *outbuf)
++{
++    uint64_t tmp_out[2];
++    _mm_storeu_si128((__m128i *)tmp_out, ghash->x);
++    /* maxout must be larger than 16 byte (checked by the caller). */
++    WRITE64(tmp_out[0], outbuf + 8);
++    WRITE64(tmp_out[1], outbuf);
++    return SECSuccess;
++}
++
++SECStatus
++gcm_HashMult_hw(gcmHashContext *ghash, const unsigned char *buf,
++                unsigned int count)
++{
++    size_t i;
++    pre_align __m128i z_high post_align;
++    pre_align __m128i z_low post_align;
++    pre_align __m128i C post_align;
++    pre_align __m128i D post_align;
++    pre_align __m128i E post_align;
++    pre_align __m128i F post_align;
++    pre_align __m128i bin post_align;
++    pre_align __m128i Ci post_align;
++    pre_align __m128i tmp post_align;
++
++    for (i = 0; i < count; i++, buf += 16) {
++        bin = _mm_set_epi16(((uint16_t)buf[0] << 8) | buf[1],
++                            ((uint16_t)buf[2] << 8) | buf[3],
++                            ((uint16_t)buf[4] << 8) | buf[5],
++                            ((uint16_t)buf[6] << 8) | buf[7],
++                            ((uint16_t)buf[8] << 8) | buf[9],
++                            ((uint16_t)buf[10] << 8) | buf[11],
++                            ((uint16_t)buf[12] << 8) | buf[13],
++                            ((uint16_t)buf[14] << 8) | buf[15]);
++        Ci = _mm_xor_si128(bin, ghash->x);
++
++        /* Do binary mult ghash->X = Ci * ghash->H. */
++        C = _mm_clmulepi64_si128(Ci, ghash->h, 0x00);
++        D = _mm_clmulepi64_si128(Ci, ghash->h, 0x11);
++        E = _mm_clmulepi64_si128(Ci, ghash->h, 0x01);
++        F = _mm_clmulepi64_si128(Ci, ghash->h, 0x10);
++        tmp = _mm_xor_si128(E, F);
++        z_high = _mm_xor_si128(tmp, _mm_slli_si128(D, 8));
++        z_high = _mm_unpackhi_epi64(z_high, D);
++        z_low = _mm_xor_si128(_mm_slli_si128(tmp, 8), C);
++        z_low = _mm_unpackhi_epi64(_mm_slli_si128(C, 8), z_low);
++
++        /* Shift one to the left (multiply by x) as gcm spec is stupid. */
++        C = _mm_slli_si128(z_low, 8);
++        E = _mm_srli_epi64(C, 63);
++        D = _mm_slli_si128(z_high, 8);
++        F = _mm_srli_epi64(D, 63);
++        /* Carry over */
++        C = _mm_srli_si128(z_low, 8);
++        D = _mm_srli_epi64(C, 63);
++        z_low = _mm_or_si128(_mm_slli_epi64(z_low, 1), E);
++        z_high = _mm_or_si128(_mm_or_si128(_mm_slli_epi64(z_high, 1), F), D);
++
++        /* Reduce */
++        C = _mm_slli_si128(z_low, 8);
++        /* D = z_low << 127 */
++        D = _mm_slli_epi64(C, 63);
++        /* E = z_low << 126 */
++        E = _mm_slli_epi64(C, 62);
++        /* F = z_low << 121 */
++        F = _mm_slli_epi64(C, 57);
++        /* z_low ^= (z_low << 127) ^ (z_low << 126) ^ (z_low << 121); */
++        z_low = _mm_xor_si128(_mm_xor_si128(_mm_xor_si128(z_low, D), E), F);
++        C = _mm_srli_si128(z_low, 8);
++        /* D = z_low >> 1 */
++        D = _mm_slli_epi64(C, 63);
++        D = _mm_or_si128(_mm_srli_epi64(z_low, 1), D);
++        /* E = z_low >> 2 */
++        E = _mm_slli_epi64(C, 62);
++        E = _mm_or_si128(_mm_srli_epi64(z_low, 2), E);
++        /* F = z_low >> 7 */
++        F = _mm_slli_epi64(C, 57);
++        F = _mm_or_si128(_mm_srli_epi64(z_low, 7), F);
++        /* ghash->x ^= z_low ^ (z_low >> 1) ^ (z_low >> 2) ^ (z_low >> 7); */
++        ghash->x = _mm_xor_si128(_mm_xor_si128(
++                                     _mm_xor_si128(_mm_xor_si128(z_high, z_low), D), E),
++                                 F);
++    }
++    return SECSuccess;
++}
++
++SECStatus
++gcm_HashInit_hw(gcmHashContext *ghash)
++{
++    ghash->ghash_mul = gcm_HashMult_hw;
++    ghash->x = _mm_setzero_si128();
++    /* MSVC requires __m64 to load epi64. */
++    ghash->h = _mm_set_epi32(ghash->h_high >> 32, (uint32_t)ghash->h_high,
++                             ghash->h_low >> 32, (uint32_t)ghash->h_low);
++    ghash->hw = PR_TRUE;
++    return SECSuccess;
++}
++
++SECStatus
++gcm_HashZeroX_hw(gcmHashContext *ghash)
++{
++    ghash->x = _mm_setzero_si128();
++    return SECSuccess;
++}
+diff --git lib/freebl/gcm.c lib/freebl/gcm.c
+index 780b7a6322..f1e16da78e 100644
+--- lib/freebl/gcm.c
++++ lib/freebl/gcm.c
+@@ -17,18 +17,50 @@
+ 
+ #include <limits.h>
+ 
+-#ifdef NSS_X86_OR_X64
+-#include <wmmintrin.h> /* clmul */
+-#endif
+-
+ /* Forward declarations */
++SECStatus gcm_HashInit_hw(gcmHashContext *ghash);
++SECStatus gcm_HashWrite_hw(gcmHashContext *ghash, unsigned char *outbuf);
+ SECStatus gcm_HashMult_hw(gcmHashContext *ghash, const unsigned char *buf,
+                           unsigned int count);
++SECStatus gcm_HashZeroX_hw(gcmHashContext *ghash);
+ SECStatus gcm_HashMult_sftw(gcmHashContext *ghash, const unsigned char *buf,
+                             unsigned int count);
+ SECStatus gcm_HashMult_sftw32(gcmHashContext *ghash, const unsigned char *buf,
+                               unsigned int count);
+ 
++/* Stub definitions for the above *_hw functions, which shouldn't be
++ * used unless NSS_X86_OR_X64 is defined */
++#ifndef NSS_X86_OR_X64
++SECStatus
++gcm_HashWrite_hw(gcmHashContext *ghash, unsigned char *outbuf)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    return SECFailure;
++}
++
++SECStatus
++gcm_HashMult_hw(gcmHashContext *ghash, const unsigned char *buf,
++                unsigned int count)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    return SECFailure;
++}
++
++SECStatus
++gcm_HashInit_hw(gcmHashContext *ghash)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    return SECFailure;
++}
++
++SECStatus
++gcm_HashZeroX_hw(gcmHashContext *ghash)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    return SECFailure;
++}
++#endif /* NSS_X86_OR_X64 */
++
+ uint64_t
+ get64(const unsigned char *bytes)
+ {
+@@ -46,6 +78,8 @@ get64(const unsigned char *bytes)
+ SECStatus
+ gcmHash_InitContext(gcmHashContext *ghash, const unsigned char *H, PRBool sw)
+ {
++    SECStatus rv = SECSuccess;
++
+     ghash->cLen = 0;
+     ghash->bufLen = 0;
+     PORT_Memset(ghash->counterBuf, 0, sizeof(ghash->counterBuf));
+@@ -53,17 +87,7 @@ gcmHash_InitContext(gcmHashContext *ghash, const unsigned char *H, PRBool sw)
+     ghash->h_low = get64(H + 8);
+     ghash->h_high = get64(H);
+     if (clmul_support() && !sw) {
+-#ifdef NSS_X86_OR_X64
+-        ghash->ghash_mul = gcm_HashMult_hw;
+-        ghash->x = _mm_setzero_si128();
+-        /* MSVC requires __m64 to load epi64. */
+-        ghash->h = _mm_set_epi32(ghash->h_high >> 32, (uint32_t)ghash->h_high,
+-                                 ghash->h_low >> 32, (uint32_t)ghash->h_low);
+-        ghash->hw = PR_TRUE;
+-#else
+-        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+-        return SECFailure;
+-#endif /* NSS_X86_OR_X64 */
++        rv = gcm_HashInit_hw(ghash);
+     } else {
+ /* We fall back to the software implementation if we can't use / don't
+          * want to use pclmul. */
+@@ -75,7 +99,7 @@ gcmHash_InitContext(gcmHashContext *ghash, const unsigned char *H, PRBool sw)
+         ghash->x_high = ghash->x_low = 0;
+         ghash->hw = PR_FALSE;
+     }
+-    return SECSuccess;
++    return rv;
+ }
+ 
+ #ifdef HAVE_INT128_SUPPORT
+@@ -283,102 +307,17 @@ gcm_HashMult_sftw32(gcmHashContext *ghash, const unsigned char *buf,
+ }
+ #endif /* HAVE_INT128_SUPPORT */
+ 
+-SECStatus
+-gcm_HashMult_hw(gcmHashContext *ghash, const unsigned char *buf,
+-                unsigned int count)
+-{
+-#ifdef NSS_X86_OR_X64
+-    size_t i;
+-    pre_align __m128i z_high post_align;
+-    pre_align __m128i z_low post_align;
+-    pre_align __m128i C post_align;
+-    pre_align __m128i D post_align;
+-    pre_align __m128i E post_align;
+-    pre_align __m128i F post_align;
+-    pre_align __m128i bin post_align;
+-    pre_align __m128i Ci post_align;
+-    pre_align __m128i tmp post_align;
+-
+-    for (i = 0; i < count; i++, buf += 16) {
+-        bin = _mm_set_epi16(((uint16_t)buf[0] << 8) | buf[1],
+-                            ((uint16_t)buf[2] << 8) | buf[3],
+-                            ((uint16_t)buf[4] << 8) | buf[5],
+-                            ((uint16_t)buf[6] << 8) | buf[7],
+-                            ((uint16_t)buf[8] << 8) | buf[9],
+-                            ((uint16_t)buf[10] << 8) | buf[11],
+-                            ((uint16_t)buf[12] << 8) | buf[13],
+-                            ((uint16_t)buf[14] << 8) | buf[15]);
+-        Ci = _mm_xor_si128(bin, ghash->x);
+-
+-        /* Do binary mult ghash->X = Ci * ghash->H. */
+-        C = _mm_clmulepi64_si128(Ci, ghash->h, 0x00);
+-        D = _mm_clmulepi64_si128(Ci, ghash->h, 0x11);
+-        E = _mm_clmulepi64_si128(Ci, ghash->h, 0x01);
+-        F = _mm_clmulepi64_si128(Ci, ghash->h, 0x10);
+-        tmp = _mm_xor_si128(E, F);
+-        z_high = _mm_xor_si128(tmp, _mm_slli_si128(D, 8));
+-        z_high = _mm_unpackhi_epi64(z_high, D);
+-        z_low = _mm_xor_si128(_mm_slli_si128(tmp, 8), C);
+-        z_low = _mm_unpackhi_epi64(_mm_slli_si128(C, 8), z_low);
+-
+-        /* Shift one to the left (multiply by x) as gcm spec is stupid. */
+-        C = _mm_slli_si128(z_low, 8);
+-        E = _mm_srli_epi64(C, 63);
+-        D = _mm_slli_si128(z_high, 8);
+-        F = _mm_srli_epi64(D, 63);
+-        /* Carry over */
+-        C = _mm_srli_si128(z_low, 8);
+-        D = _mm_srli_epi64(C, 63);
+-        z_low = _mm_or_si128(_mm_slli_epi64(z_low, 1), E);
+-        z_high = _mm_or_si128(_mm_or_si128(_mm_slli_epi64(z_high, 1), F), D);
+-
+-        /* Reduce */
+-        C = _mm_slli_si128(z_low, 8);
+-        /* D = z_low << 127 */
+-        D = _mm_slli_epi64(C, 63);
+-        /* E = z_low << 126 */
+-        E = _mm_slli_epi64(C, 62);
+-        /* F = z_low << 121 */
+-        F = _mm_slli_epi64(C, 57);
+-        /* z_low ^= (z_low << 127) ^ (z_low << 126) ^ (z_low << 121); */
+-        z_low = _mm_xor_si128(_mm_xor_si128(_mm_xor_si128(z_low, D), E), F);
+-        C = _mm_srli_si128(z_low, 8);
+-        /* D = z_low >> 1 */
+-        D = _mm_slli_epi64(C, 63);
+-        D = _mm_or_si128(_mm_srli_epi64(z_low, 1), D);
+-        /* E = z_low >> 2 */
+-        E = _mm_slli_epi64(C, 62);
+-        E = _mm_or_si128(_mm_srli_epi64(z_low, 2), E);
+-        /* F = z_low >> 7 */
+-        F = _mm_slli_epi64(C, 57);
+-        F = _mm_or_si128(_mm_srli_epi64(z_low, 7), F);
+-        /* ghash->x ^= z_low ^ (z_low >> 1) ^ (z_low >> 2) ^ (z_low >> 7); */
+-        ghash->x = _mm_xor_si128(_mm_xor_si128(
+-                                     _mm_xor_si128(_mm_xor_si128(z_high, z_low), D), E),
+-                                 F);
+-    }
+-    return SECSuccess;
+-#else
+-    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+-    return SECFailure;
+-#endif /* NSS_X86_OR_X64 */
+-}
+-
+ static SECStatus
+ gcm_zeroX(gcmHashContext *ghash)
+ {
++    SECStatus rv = SECSuccess;
++
+     if (ghash->hw) {
+-#ifdef NSS_X86_OR_X64
+-        ghash->x = _mm_setzero_si128();
+-        return SECSuccess;
+-#else
+-        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+-        return SECFailure;
+-#endif /* NSS_X86_OR_X64 */
++        rv = gcm_HashZeroX_hw(ghash);
+     }
+ 
+     ghash->x_high = ghash->x_low = 0;
+-    return SECSuccess;
++    return rv;
+ }
+ 
+ /*
+@@ -503,15 +442,10 @@ gcmHash_Final(gcmHashContext *ghash, unsigned char *outbuf,
+     }
+ 
+     if (ghash->hw) {
+-#ifdef NSS_X86_OR_X64
+-        uint64_t tmp_out[2];
+-        _mm_storeu_si128((__m128i *)tmp_out, ghash->x);
+-        WRITE64(tmp_out[0], T + 8);
+-        WRITE64(tmp_out[1], T);
+-#else
+-        PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+-        return SECFailure;
+-#endif /* NSS_X86_OR_X64 */
++        rv = gcm_HashWrite_hw(ghash, T);
++        if (rv != SECSuccess) {
++            goto cleanup;
++        }
+     } else {
+         WRITE64(ghash->x_low, T + 8);
+         WRITE64(ghash->x_high, T);
+diff --git lib/freebl/gcm.h lib/freebl/gcm.h
+index 0c707a0811..42ef0f7179 100644
+--- lib/freebl/gcm.h
++++ lib/freebl/gcm.h
+@@ -9,7 +9,21 @@
+ #include <stdint.h>
+ 
+ #ifdef NSS_X86_OR_X64
++/* GCC <= 4.8 doesn't support including emmintrin.h without enabling SSE2 */
++#if !defined(__clang__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && \
++    (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 8))
++#pragma GCC push_options
++#pragma GCC target("sse2")
++#undef NSS_DISABLE_SSE2
++#define NSS_DISABLE_SSE2 1
++#endif /* GCC <= 4.8 */
++
+ #include <emmintrin.h> /* __m128i */
++
++#ifdef NSS_DISABLE_SSE2
++#undef NSS_DISABLE_SSE2
++#pragma GCC pop_options
++#endif /* NSS_DISABLE_SSE2 */
+ #endif
+ 
+ SEC_BEGIN_PROTOS
+diff --git lib/freebl/rijndael.c lib/freebl/rijndael.c
+index a09f13098e..5de27de9ce 100644
+--- lib/freebl/rijndael.c
++++ lib/freebl/rijndael.c
+@@ -27,6 +27,34 @@
+ #include "intel-gcm.h"
+ #endif /* INTEL_GCM */
+ 
++/* Forward declarations */
++void rijndael_native_key_expansion(AESContext *cx, const unsigned char *key,
++                                   unsigned int Nk);
++void rijndael_native_encryptBlock(AESContext *cx,
++                                  unsigned char *output,
++                                  const unsigned char *input);
++
++/* Stub definitions for the above rijndael_native_* functions, which
++ * shouldn't be used unless NSS_X86_OR_X64 is defined */
++#ifndef NSS_X86_OR_X64
++void
++rijndael_native_key_expansion(AESContext *cx, const unsigned char *key,
++                              unsigned int Nk)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    PORT_Assert(0);
++}
++
++void
++rijndael_native_encryptBlock(AESContext *cx,
++                             unsigned char *output,
++                             const unsigned char *input)
++{
++    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
++    PORT_Assert(0);
++}
++#endif /* NSS_X86_OR_X64 */
++
+ /*
+  * There are currently three ways to build this code, varying in performance
+  * and code size.
+@@ -309,162 +337,6 @@ rijndael_key_expansion7(AESContext *cx, const unsigned char *key, unsigned int N
+     }
+ }
+ 
+-#if defined(NSS_X86_OR_X64)
+-#define EXPAND_KEY128(k, rcon, res)                   \
+-    tmp_key = [REDACTED](k, rcon);     \
+-    tmp_key = [REDACTED](tmp_key, 0xFF);       \
+-    tmp = _mm_xor_si128(k, _mm_slli_si128(k, 4));     \
+-    tmp = _mm_xor_si128(tmp, _mm_slli_si128(tmp, 4)); \
+-    tmp = _mm_xor_si128(tmp, _mm_slli_si128(tmp, 4)); \
+-    res = _mm_xor_si128(tmp, tmp_key)
+-
+-static void
+-native_key_expansion128(AESContext *cx, const unsigned char *key)
+-{
+-    __m128i *keySchedule = cx->keySchedule;
+-    pre_align __m128i tmp_key post_align;
+-    pre_align __m128i tmp post_align;
+-    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
+-    EXPAND_KEY128(keySchedule[0], 0x01, keySchedule[1]);
+-    EXPAND_KEY128(keySchedule[1], 0x02, keySchedule[2]);
+-    EXPAND_KEY128(keySchedule[2], 0x04, keySchedule[3]);
+-    EXPAND_KEY128(keySchedule[3], 0x08, keySchedule[4]);
+-    EXPAND_KEY128(keySchedule[4], 0x10, keySchedule[5]);
+-    EXPAND_KEY128(keySchedule[5], 0x20, keySchedule[6]);
+-    EXPAND_KEY128(keySchedule[6], 0x40, keySchedule[7]);
+-    EXPAND_KEY128(keySchedule[7], 0x80, keySchedule[8]);
+-    EXPAND_KEY128(keySchedule[8], 0x1B, keySchedule[9]);
+-    EXPAND_KEY128(keySchedule[9], 0x36, keySchedule[10]);
+-}
+-
+-#define EXPAND_KEY192_PART1(res, k0, kt, rcon)                                \
+-    tmp2 = _mm_slli_si128(k0, 4);                                             \
+-    tmp1 = _mm_xor_si128(k0, tmp2);                                           \
+-    tmp2 = _mm_slli_si128(tmp2, 4);                                           \
+-    tmp1 = _mm_xor_si128(_mm_xor_si128(tmp1, tmp2), _mm_slli_si128(tmp2, 4)); \
+-    tmp2 = _mm_aeskeygenassist_si128(kt, rcon);                               \
+-    res = _mm_xor_si128(tmp1, _mm_shuffle_epi32(tmp2, 0x55))
+-
+-#define EXPAND_KEY192_PART2(res, k1, k2)             \
+-    tmp2 = _mm_xor_si128(k1, _mm_slli_si128(k1, 4)); \
+-    res = _mm_xor_si128(tmp2, _mm_shuffle_epi32(k2, 0xFF))
+-
+-#define EXPAND_KEY192(k0, res1, res2, res3, carry, rcon1, rcon2)         \
+-    EXPAND_KEY192_PART1(tmp3, k0, res1, rcon1);                          \
+-    EXPAND_KEY192_PART2(carry, res1, tmp3);                              \
+-    res1 = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(res1),       \
+-                                           _mm_castsi128_pd(tmp3), 0));  \
+-    res2 = _mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(tmp3),       \
+-                                           _mm_castsi128_pd(carry), 1)); \
+-    EXPAND_KEY192_PART1(res3, tmp3, carry, rcon2)
+-
+-static void
+-native_key_expansion192(AESContext *cx, const unsigned char *key)
+-{
+-    __m128i *keySchedule = cx->keySchedule;
+-    pre_align __m128i tmp1 post_align;
+-    pre_align __m128i tmp2 post_align;
+-    pre_align __m128i tmp3 post_align;
+-    pre_align __m128i carry post_align;
+-    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
+-    keySchedule[1] = _mm_loadu_si128((__m128i *)(key + 16));
+-    EXPAND_KEY192(keySchedule[0], keySchedule[1], keySchedule[2],
+-                  keySchedule[3], carry, 0x1, 0x2);
+-    EXPAND_KEY192_PART2(keySchedule[4], carry, keySchedule[3]);
+-    EXPAND_KEY192(keySchedule[3], keySchedule[4], keySchedule[5],
+-                  keySchedule[6], carry, 0x4, 0x8);
+-    EXPAND_KEY192_PART2(keySchedule[7], carry, keySchedule[6]);
+-    EXPAND_KEY192(keySchedule[6], keySchedule[7], keySchedule[8],
+-                  keySchedule[9], carry, 0x10, 0x20);
+-    EXPAND_KEY192_PART2(keySchedule[10], carry, keySchedule[9]);
+-    EXPAND_KEY192(keySchedule[9], keySchedule[10], keySchedule[11],
+-                  keySchedule[12], carry, 0x40, 0x80);
+-}
+-
+-#define EXPAND_KEY256_PART(res, rconx, k1x, k2x, X)                           \
+-    tmp_key = [REDACTED]([REDACTED](k2x, rconx), X);    \
+-    tmp2 = _mm_slli_si128(k1x, 4);                                            \
+-    tmp1 = _mm_xor_si128(k1x, tmp2);                                          \
+-    tmp2 = _mm_slli_si128(tmp2, 4);                                           \
+-    tmp1 = _mm_xor_si128(_mm_xor_si128(tmp1, tmp2), _mm_slli_si128(tmp2, 4)); \
+-    res = _mm_xor_si128(tmp1, tmp_key);
+-
+-#define EXPAND_KEY256(res1, res2, k1, k2, rcon)   \
+-    EXPAND_KEY256_PART(res1, rcon, k1, k2, 0xFF); \
+-    EXPAND_KEY256_PART(res2, 0x00, k2, res1, 0xAA)
+-
+-static void
+-native_key_expansion256(AESContext *cx, const unsigned char *key)
+-{
+-    __m128i *keySchedule = cx->keySchedule;
+-    pre_align __m128i tmp_key post_align;
+-    pre_align __m128i tmp1 post_align;
+-    pre_align __m128i tmp2 post_align;
+-    keySchedule[0] = _mm_loadu_si128((__m128i *)key);
+-    keySchedule[1] = _mm_loadu_si128((__m128i *)(key + 16));
+-    EXPAND_KEY256(keySchedule[2], keySchedule[3], keySchedule[0],
+-                  keySchedule[1], 0x01);
+-    EXPAND_KEY256(keySchedule[4], keySchedule[5], keySchedule[2],
+-                  keySchedule[3], 0x02);
+-    EXPAND_KEY256(keySchedule[6], keySchedule[7], keySchedule[4],
+-                  keySchedule[5], 0x04);
+-    EXPAND_KEY256(keySchedule[8], keySchedule[9], keySchedule[6],
+-                  keySchedule[7], 0x08);
+-    EXPAND_KEY256(keySchedule[10], keySchedule[11], keySchedule[8],
+-                  keySchedule[9], 0x10);
+-    EXPAND_KEY256(keySchedule[12], keySchedule[13], keySchedule[10],
+-                  keySchedule[11], 0x20);
+-    EXPAND_KEY256_PART(keySchedule[14], 0x40, keySchedule[12],
+-                       keySchedule[13], 0xFF);
+-}
+-
+-#endif /* NSS_X86_OR_X64 */
+-
+-/*
+- * AES key expansion using aes-ni instructions.
+- */
+-static void
+-native_key_expansion(AESContext *cx, const unsigned char *key, unsigned int Nk)
+-{
+-#ifdef NSS_X86_OR_X64
+-    switch (Nk) {
+-        case 4:
+-            native_key_expansion128(cx, key);
+-            return;
+-        case 6:
+-            native_key_expansion192(cx, key);
+-            return;
+-        case 8:
+-            native_key_expansion256(cx, key);
+-            return;
+-        default:
+-            /* This shouldn't happen. */
+-            PORT_Assert(0);
+-    }
+-#else
+-    PORT_Assert(0);
+-#endif /* NSS_X86_OR_X64 */
+-}
+-
+-static void
+-native_encryptBlock(AESContext *cx,
+-                    unsigned char *output,
+-                    const unsigned char *input)
+-{
+-#ifdef NSS_X86_OR_X64
+-    int i;
+-    pre_align __m128i m post_align = _mm_loadu_si128((__m128i *)input);
+-    m = _mm_xor_si128(m, cx->keySchedule[0]);
+-    for (i = 1; i < cx->Nr; ++i) {
+-        m = _mm_aesenc_si128(m, cx->keySchedule[i]);
+-    }
+-    m = _mm_aesenclast_si128(m, cx->keySchedule[cx->Nr]);
+-    _mm_storeu_si128((__m128i *)output, m);
+-#else
+-    PORT_Assert(0);
+-#endif /* NSS_X86_OR_X64 */
+-}
+-
+ /* rijndael_key_expansion
+  *
+  * Generate the expanded key from the key input by the user.
+@@ -830,7 +702,7 @@ rijndael_encryptECB(AESContext *cx, unsigned char *output,
+ 
+     if (aesni_support()) {
+         /* Use hardware acceleration for normal AES parameters. */
+-        encryptor = &native_encryptBlock;
++        encryptor = &rijndael_native_encryptBlock;
+     } else {
+         encryptor = &rijndael_encryptBlock128;
+     }
+@@ -1026,7 +898,7 @@ aes_InitContext(AESContext *cx, const unsigned char *key, unsigned int keysize,
+                                cx->mode == NSS_AES_CTR)) {
+                 PORT_Assert(keysize == 16 || keysize == 24 || keysize == 32);
+                 /* Prepare hardware key for normal AES parameters. */
+-                native_key_expansion(cx, key, Nk);
++                rijndael_native_key_expansion(cx, key, Nk);
+             } else {
+                 rijndael_key_expansion(cx, key, Nk);
+             }
+diff --git lib/freebl/rijndael.h lib/freebl/rijndael.h
+index 1f4a8a9f73..1b63a323da 100644
+--- lib/freebl/rijndael.h
++++ lib/freebl/rijndael.h
+@@ -8,8 +8,22 @@
+ #include "blapii.h"
+ #include <stdint.h>
+ 
+-#ifdef NSS_X86_OR_X64
+-#include <wmmintrin.h> /* aes-ni */
++#if defined(NSS_X86_OR_X64)
++/* GCC <= 4.8 doesn't support including emmintrin.h without enabling SSE2 */
++#if !defined(__clang__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && \
++    (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 8))
++#pragma GCC push_options
++#pragma GCC target("sse2")
++#undef NSS_DISABLE_SSE2
++#define NSS_DISABLE_SSE2 1
++#endif /* GCC <= 4.8 */
++
++#include <emmintrin.h> /* __m128i */
++
++#ifdef NSS_DISABLE_SSE2
++#undef NSS_DISABLE_SSE2
++#pragma GCC pop_options
++#endif /* NSS_DISABLE_SSE2 */
+ #endif
+ 
+ typedef void AESBlockFunc(AESContext *cx,
diff --git a/abs/extra/nss/bundle.sh b/abs/extra/nss/bundle.sh
index 253e64a..531a496 100644
--- a/abs/extra/nss/bundle.sh
+++ b/abs/extra/nss/bundle.sh
@@ -5,11 +5,8 @@
   cat <<EOF
 # This is a bundle of X.509 certificates of public Certificate
 # Authorities.  It was generated from the Mozilla root CA list.
-# These certificates are in the OpenSSL "TRUSTED CERTIFICATE"
-# format and have trust bits set accordingly.
-# An exception are auxiliary certificates, without positive or negative
-# trust, but are used to assist in finding a preferred trust path.
-# Those neutral certificates use the plain BEGIN CERTIFICATE format.
+# These certificates and trust/distrust attributes use the file format accepted
+# by the p11-kit-trust module.
 #
 # Source: nss/lib/ckfw/builtins/certdata.txt
 # Source: nss/lib/ckfw/builtins/nssckbi.h
@@ -18,37 +15,8 @@
 EOF
   cat certs/nssckbi.h | grep -w NSS_BUILTINS_LIBRARY_VERSION | awk '{print "# " $2 " " $3}'
   echo '#'
-) > ca-bundle.trust.crt
-for f in certs/*.crt; do 
-  echo "processing $f"
-  tbits=`sed -n '/^# openssl-trust/{s/^.*=//;p;}' $f`
-  distbits=`sed -n '/^# openssl-distrust/{s/^.*=//;p;}' $f`
-  alias=`sed -n '/^# alias=/{s/^.*=//;p;q;}' $f | sed "s/'//g" | sed 's/"//g'`
-  targs=""
-  if [ -n "$tbits" ]; then
-    for t in $tbits; do
-       targs="${targs} -addtrust $t"
-    done
-  fi
-  if [ -n "$distbits" ]; then
-    for t in $distbits; do
-       targs="${targs} -addreject $t"
-    done
-  fi
-  if [ -n "$targs" ]; then
-    echo "trust flags $targs for $f" >> info.trust
-    openssl x509 -text -in "$f" -trustout $targs -setalias "$alias" >> ca-bundle.trust.crt
-  else
-    echo "no trust flags for $f" >> info.notrust
-    # p11-kit-trust defines empty trust lists as "rejected for all purposes".
-    # That's why we use the simple file format
-    #   (BEGIN CERTIFICATE, no trust information)
-    # because p11-kit-trust will treat it as a certificate with neutral trust.
-    # This means we cannot use the -setalias feature for neutral trust certs.
-    openssl x509 -text -in "$f" >> ca-bundle.neutral-trust.crt
-  fi
-done
+) > ca-bundle.trust.p11-kit
 
-for p in certs/*.p11-kit; do 
-  cat "$p" >> ca-bundle.supplement.p11-kit
+for p in certs/*.tmp-p11-kit; do 
+  cat "$p" >> ca-bundle.trust.p11-kit
 done
diff --git a/abs/extra/nss/ca-certificates-mozilla.install b/abs/extra/nss/ca-certificates-mozilla.install
deleted file mode 100644
index 433c35a..0000000
--- a/abs/extra/nss/ca-certificates-mozilla.install
+++ /dev/null
@@ -1,11 +0,0 @@
-post_install() {
-  usr/bin/update-ca-trust
-}
-
-post_upgrade() {
-  post_install
-}
-
-pre_remove() {
-  post_install
-}
diff --git a/abs/extra/nss/certdata2pem.py b/abs/extra/nss/certdata2pem.py
index 021772a..e63ca0f 100644
--- a/abs/extra/nss/certdata2pem.py
+++ b/abs/extra/nss/certdata2pem.py
@@ -27,6 +27,7 @@ import re
 import sys
 import textwrap
 import urllib
+import subprocess
 
 objects = []
 
@@ -113,6 +114,17 @@ def obj_to_filename(obj):
     serial = printable_serial(obj)
     return label + ":" + serial
 
+def write_cert_ext_to_file(f, oid, value, public_key):
+    f.write("[p11-kit-object-v1]\n")
+    f.write("label: ");
+    f.write(tobj['CKA_LABEL'])
+    f.write("\n")
+    f.write("class: x-certificate-extension\n");
+    f.write("object-id: " + oid + "\n")
+    f.write("value: \"" + value + "\"\n")
+    f.write("modifiable: false\n");
+    f.write(public_key)
+
 trust_types = {
   "CKA_TRUST_DIGITAL_SIGNATURE": "digital-signature",
   "CKA_TRUST_NON_REPUDIATION": "non-repudiation",
@@ -132,6 +144,18 @@ trust_types = {
   "CKA_TRUST_STEP_UP_APPROVED": "step-up-approved",
 }
 
+legacy_trust_types = {
+  "LEGACY_CKA_TRUST_SERVER_AUTH": "server-auth",
+  "LEGACY_CKA_TRUST_CODE_SIGNING": "code-signing",
+  "LEGACY_CKA_TRUST_EMAIL_PROTECTION": "email-protection",
+}
+
+legacy_to_real_trust_types = {
+  "LEGACY_CKA_TRUST_SERVER_AUTH": "CKA_TRUST_SERVER_AUTH",
+  "LEGACY_CKA_TRUST_CODE_SIGNING": "CKA_TRUST_CODE_SIGNING",
+  "LEGACY_CKA_TRUST_EMAIL_PROTECTION": "CKA_TRUST_EMAIL_PROTECTION",
+}
+
 openssl_trust = {
   "CKA_TRUST_SERVER_AUTH": "serverAuth",
   "CKA_TRUST_CLIENT_AUTH": "clientAuth",
@@ -147,6 +171,8 @@ for tobj in objects:
         distrustbits = []
         openssl_trustflags = []
         openssl_distrustflags = []
+        legacy_trustbits = []
+        legacy_openssl_trustflags = []
         for t in trust_types.keys():
             if tobj.has_key(t) and tobj[t] == 'CKT_NSS_TRUSTED_DELEGATOR':
                 trustbits.append(t)
@@ -157,29 +183,180 @@ for tobj in objects:
                 if t in openssl_trust:
                     openssl_distrustflags.append(openssl_trust[t])
 
+        for t in legacy_trust_types.keys():
+            if tobj.has_key(t) and tobj[t] == 'CKT_NSS_TRUSTED_DELEGATOR':
+                real_t = legacy_to_real_trust_types[t]
+                legacy_trustbits.append(real_t)
+                if real_t in openssl_trust:
+                    legacy_openssl_trustflags.append(openssl_trust[real_t])
+            if tobj.has_key(t) and tobj[t] == 'CKT_NSS_NOT_TRUSTED':
+                raise NotImplementedError, 'legacy distrust not supported.\n' + line
+
         fname = obj_to_filename(tobj)
         try:
             obj = certmap[key]
         except:
             obj = None
 
+        # optional debug code, that dumps the parsed input to files
+        #fulldump = "dump-" + fname
+        #dumpf = open(fulldump, 'w')
+        #dumpf.write(str(obj));
+        #dumpf.write(str(tobj));
+        #dumpf.close();
+
+        is_legacy = 0
+        if tobj.has_key('LEGACY_CKA_TRUST_SERVER_AUTH') or tobj.has_key('LEGACY_CKA_TRUST_EMAIL_PROTECTION') or tobj.has_key('LEGACY_CKA_TRUST_CODE_SIGNING'):
+            is_legacy = 1
+            if obj == None:
+                raise NotImplementedError, 'found legacy trust without certificate.\n' + line
+
+            legacy_fname = "legacy-default/" + fname + ".crt"
+            f = open(legacy_fname, 'w')
+            f.write("# alias=%s\n"%tobj['CKA_LABEL'])
+            f.write("# trust=" + " ".join(legacy_trustbits) + "\n")
+            if legacy_openssl_trustflags:
+                f.write("# openssl-trust=" + " ".join(legacy_openssl_trustflags) + "\n")
+            f.write("-----BEGIN CERTIFICATE-----\n")
+            f.write("\n".join(textwrap.wrap(base64.b64encode(obj['CKA_VALUE']), 64)))
+            f.write("\n-----END CERTIFICATE-----\n")
+            f.close()
+
+            if tobj.has_key('CKA_TRUST_SERVER_AUTH') or tobj.has_key('CKA_TRUST_EMAIL_PROTECTION') or tobj.has_key('CKA_TRUST_CODE_SIGNING'):
+                legacy_fname = "legacy-disable/" + fname + ".crt"
+                f = open(legacy_fname, 'w')
+                f.write("# alias=%s\n"%tobj['CKA_LABEL'])
+                f.write("# trust=" + " ".join(trustbits) + "\n")
+                if openssl_trustflags:
+                    f.write("# openssl-trust=" + " ".join(openssl_trustflags) + "\n")
+                f.write("-----BEGIN CERTIFICATE-----\n")
+                f.write("\n".join(textwrap.wrap(base64.b64encode(obj['CKA_VALUE']), 64)))
+                f.write("\n-----END CERTIFICATE-----\n")
+                f.close()
+
+            # don't produce p11-kit output for legacy certificates
+            continue
+
+        pk = ''
+        cert_comment = ''
         if obj != None:
-            fname += ".crt"
-        else:
-            fname += ".p11-kit"
+            # must extract the public key from the cert, let's use openssl
+            cert_fname = "cert-" + fname
+            fc = open(cert_fname, 'w')
+            fc.write("-----BEGIN CERTIFICATE-----\n")
+            fc.write("\n".join(textwrap.wrap(base64.b64encode(obj['CKA_VALUE']), 64)))
+            fc.write("\n-----END CERTIFICATE-----\n")
+            fc.close();
+            pk_fname = "pubkey-" + fname
+            fpkout = open(pk_fname, "w")
+            dump_pk_command = ["openssl", "x509", "-in", cert_fname, "-noout", "-pubkey"]
+            subprocess.call(dump_pk_command, stdout=fpkout)
+            fpkout.close()
+            with open (pk_fname, "r") as myfile:
+                pk=myfile.read()
+            # obtain certificate information suitable as a comment
+            comment_fname = "comment-" + fname
+            fcout = open(comment_fname, "w")
+            comment_command = ["openssl", "x509", "-in", cert_fname, "-noout", "-text"]
+            subprocess.call(comment_command, stdout=fcout)
+            fcout.close()
+            sed_command = ["sed", "--in-place", "s/^/#/", comment_fname]
+            subprocess.call(sed_command)
+            with open (comment_fname, "r") as myfile:
+                cert_comment=myfile.read()
 
+        fname += ".tmp-p11-kit"
         f = open(fname, 'w')
+
         if obj != None:
-            f.write("# alias=%s\n"%tobj['CKA_LABEL'])
-            f.write("# trust=" + " ".join(trustbits) + "\n")
-            f.write("# distrust=" + " ".join(distrustbits) + "\n")
-            if openssl_trustflags:
-                f.write("# openssl-trust=" + " ".join(openssl_trustflags) + "\n")
-            if openssl_distrustflags:
-                f.write("# openssl-distrust=" + " ".join(openssl_distrustflags) + "\n")
+            is_distrusted = False
+            has_server_trust = False
+            has_email_trust = False
+            has_code_trust = False
+
+            if tobj.has_key('CKA_TRUST_SERVER_AUTH'):
+                if tobj['CKA_TRUST_SERVER_AUTH'] == 'CKT_NSS_NOT_TRUSTED':
+                    is_distrusted = True
+                elif tobj['CKA_TRUST_SERVER_AUTH'] == 'CKT_NSS_TRUSTED_DELEGATOR':
+                    has_server_trust = True
+
+            if tobj.has_key('CKA_TRUST_EMAIL_PROTECTION'):
+                if tobj['CKA_TRUST_EMAIL_PROTECTION'] == 'CKT_NSS_NOT_TRUSTED':
+                    is_distrusted = True
+                elif tobj['CKA_TRUST_EMAIL_PROTECTION'] == 'CKT_NSS_TRUSTED_DELEGATOR':
+                    has_email_trust = True
+
+            if tobj.has_key('CKA_TRUST_CODE_SIGNING'):
+                if tobj['CKA_TRUST_CODE_SIGNING'] == 'CKT_NSS_NOT_TRUSTED':
+                    is_distrusted = True
+                elif tobj['CKA_TRUST_CODE_SIGNING'] == 'CKT_NSS_TRUSTED_DELEGATOR':
+                    has_code_trust = True
+
+            if is_distrusted:
+                trust_ext_oid = "1.3.6.1.4.1.3319.6.10.1"
+                trust_ext_value = "0.%06%0a%2b%06%01%04%01%99w%06%0a%01%04 0%1e%06%08%2b%06%01%05%05%07%03%04%06%08%2b%06%01%05%05%07%03%01%06%08%2b%06%01%05%05%07%03%03"
+                write_cert_ext_to_file(f, trust_ext_oid, trust_ext_value, pk)
+
+            trust_ext_oid = "2.5.29.37"
+            if has_server_trust:
+                if has_email_trust:
+                    if has_code_trust:
+                        # server + email + code
+                        trust_ext_value = "0%2a%06%03U%1d%25%01%01%ff%04 0%1e%06%08%2b%06%01%05%05%07%03%04%06%08%2b%06%01%05%05%07%03%01%06%08%2b%06%01%05%05%07%03%03"
+                    else:
+                        # server + email
+                        trust_ext_value = "0 %06%03U%1d%25%01%01%ff%04%160%14%06%08%2b%06%01%05%05%07%03%04%06%08%2b%06%01%05%05%07%03%01"
+                else:
+                    if has_code_trust:
+                        # server + code
+                        trust_ext_value = "0 %06%03U%1d%25%01%01%ff%04%160%14%06%08%2b%06%01%05%05%07%03%01%06%08%2b%06%01%05%05%07%03%03"
+                    else:
+                        # server
+                        trust_ext_value = "0%16%06%03U%1d%25%01%01%ff%04%0c0%0a%06%08%2b%06%01%05%05%07%03%01"
+            else:
+                if has_email_trust:
+                    if has_code_trust:
+                        # email + code
+                        trust_ext_value = "0 %06%03U%1d%25%01%01%ff%04%160%14%06%08%2b%06%01%05%05%07%03%04%06%08%2b%06%01%05%05%07%03%03"
+                    else:
+                        # email
+                        trust_ext_value = "0%16%06%03U%1d%25%01%01%ff%04%0c0%0a%06%08%2b%06%01%05%05%07%03%04"
+                else:
+                    if has_code_trust:
+                        # code
+                        trust_ext_value = "0%16%06%03U%1d%25%01%01%ff%04%0c0%0a%06%08%2b%06%01%05%05%07%03%03"
+                    else:
+                        # none
+                        trust_ext_value = "0%18%06%03U%1d%25%01%01%ff%04%0e0%0c%06%0a%2b%06%01%04%01%99w%06%0a%10"
+
+            # no 2.5.29.37 for neutral certificates
+            if (is_distrusted or has_server_trust or has_email_trust or has_code_trust):
+                write_cert_ext_to_file(f, trust_ext_oid, trust_ext_value, pk)
+
+            pk = ''
+            f.write("\n")
+
+            f.write("[p11-kit-object-v1]\n")
+            f.write("label: ");
+            f.write(tobj['CKA_LABEL'])
+            f.write("\n")
+            if is_distrusted:
+                f.write("x-distrusted: true\n")
+            elif has_server_trust or has_email_trust or has_code_trust:
+                f.write("trusted: true\n")
+            else:
+                f.write("trusted: false\n")
+
+            # requires p11-kit >= 0.23.4
+            f.write("nss-mozilla-ca-policy: true\n")
+            f.write("modifiable: false\n");
+
             f.write("-----BEGIN CERTIFICATE-----\n")
             f.write("\n".join(textwrap.wrap(base64.b64encode(obj['CKA_VALUE']), 64)))
             f.write("\n-----END CERTIFICATE-----\n")
+            f.write(cert_comment)
+            f.write("\n")
+
         else:
             f.write("[p11-kit-object-v1]\n")
             f.write("label: ");
@@ -187,6 +364,7 @@ for tobj in objects:
             f.write("\n")
             f.write("class: certificate\n")
             f.write("certificate-type: x-509\n")
+            f.write("modifiable: false\n");
             f.write("issuer: \"");
             f.write(urllib.quote(tobj['CKA_ISSUER']));
             f.write("\"\n")
diff --git a/abs/extra/nss/enable-libpkix.patch b/abs/extra/nss/enable-libpkix.patch
new file mode 100644
index 0000000..2071c2b
--- /dev/null
+++ b/abs/extra/nss/enable-libpkix.patch
@@ -0,0 +1,12 @@
+diff -u -r nss-3.31/nss/build.sh nss-3.31-libpkix/nss/build.sh
+--- nss-3.31/nss/build.sh	2017-06-08 12:53:01.000000000 +0200
++++ nss-3.31-libpkix/nss/build.sh	2017-06-09 19:11:21.746133040 +0200
+@@ -52,7 +52,7 @@
+ no_local_nspr=0
+ armhf=0
+ 
+-gyp_params=(--depth="$cwd" --generator-output=".")
++gyp_params=(--depth="$cwd" --generator-output="." -Ddisable_libpkix=0)
+ nspr_params=()
+ ninja_params=()
+ 
diff --git a/abs/extra/nss/legacy-certs.patch b/abs/extra/nss/legacy-certs.patch
deleted file mode 100644
index 863cef9..0000000
--- a/abs/extra/nss/legacy-certs.patch
+++ /dev/null
@@ -1,26 +0,0 @@
---- certdata.txt	2015-06-27 23:31:01.419795911 +0200
-+++ certdata-legacy-less.txt	2015-06-27 23:57:47.106199639 +0200
-@@ -577,9 +577,9 @@
- \002\020\160\272\344\035\020\331\051\064\266\070\312\173\003\314
- \272\277
- END
--CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
-+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
- CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
--CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
-+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
- CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
- 
- #
-@@ -17186,9 +17186,9 @@
- \002\020\074\221\061\313\037\366\320\033\016\232\270\320\104\277
- \022\276
- END
--CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
-+CKA_TRUST_SERVER_AUTH CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
- CKA_TRUST_EMAIL_PROTECTION CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
--CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_MUST_VERIFY_TRUST
-+CKA_TRUST_CODE_SIGNING CK_TRUST CKT_NSS_TRUSTED_DELEGATOR
- CKA_TRUST_STEP_UP_APPROVED CK_BBOOL CK_FALSE
- 
- #
diff --git a/abs/extra/nss/no-plt.diff b/abs/extra/nss/no-plt.diff
new file mode 100644
index 0000000..9014f8b
--- /dev/null
+++ b/abs/extra/nss/no-plt.diff
@@ -0,0 +1,48 @@
+diff --git i/security/nss/lib/freebl/mpi/mpi_x86.s w/security/nss/lib/freebl/mpi/mpi_x86.s
+index 8f7e2130c3264754..b3ca1ce5b41b3771 100644
+--- i/security/nss/lib/freebl/mpi/mpi_x86.s
++++ w/security/nss/lib/freebl/mpi/mpi_x86.s
+@@ -22,22 +22,41 @@ is_sse: .long	-1
+ #
+ .ifndef NO_PIC
+ .macro GET   var,reg
+-    movl   \var@GOTOFF(%ebx),\reg
++    call   thunk.ax
++    addl   $_GLOBAL_OFFSET_TABLE_, %eax
++    movl   \var@GOTOFF(%eax),\reg
+ .endm
+ .macro PUT   reg,var
+-    movl   \reg,\var@GOTOFF(%ebx)
++    call   thunk.dx
++    addl   $_GLOBAL_OFFSET_TABLE_, %edx
++    movl   \reg,\var@GOTOFF(%edx)
+ .endm
+ .else
+ .macro GET   var,reg
+     movl   \var,\reg
+ .endm
+ .macro PUT   reg,var
+     movl   \reg,\var
+ .endm
+ .endif
+ 
+ .text
+ 
++.ifndef NO_PIC
++.globl	thunk.ax
++.hidden	thunk.ax
++.type	thunk.ax, @function
++thunk.ax:
++       movl   (%esp),%eax
++       ret
++
++.globl	thunk.dx
++.hidden	thunk.dx
++.type	thunk.dx, @function
++thunk.dx:
++       movl   (%esp),%edx
++       ret
++.endif
+ 
+  #  ebp - 36:	caller's esi
+  #  ebp - 32:	caller's edi
diff --git a/abs/extra/nss/nss-config.xml b/abs/extra/nss/nss-config.xml
new file mode 100644
index 0000000..f9518c9
--- /dev/null
+++ b/abs/extra/nss/nss-config.xml
@@ -0,0 +1,132 @@
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
+  "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd" [
+<!ENTITY date SYSTEM "date.xml">
+<!ENTITY version SYSTEM "version.xml">
+]>
+
+<refentry id="nss-config">
+
+  <refentryinfo>
+    <date>&date;</date>
+    <title>Network Security Services</title>
+    <productname>nss</productname>
+    <productnumber>&version;</productnumber>
+  </refentryinfo>
+
+  <refmeta>
+    <refentrytitle>nss-config</refentrytitle>
+    <manvolnum>1</manvolnum>
+  </refmeta>
+
+  <refnamediv>
+    <refname>nss-config</refname>
+    <refpurpose>Return meta information about nss libraries</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nss-config</command>
+      <arg><option>--prefix</option></arg>
+      <arg><option>--exec-prefix</option></arg>
+      <arg><option>--includedir</option></arg>
+      <arg><option>--libs</option></arg>
+      <arg><option>--cflags</option></arg>
+      <arg><option>--libdir</option></arg>
+      <arg><option>--version</option></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+<refsection id="description">
+    <title>Description</title>
+
+    <para><command>nss-config</command> is a shell scrip
+    tool which can be used to obtain gcc options for building client pacakges of nspt. </para>
+
+  </refsection>
+  
+  <refsection>
+    <title>Options</title>
+    
+    <variablelist>
+      <varlistentry>
+        <term><option>--prefix</option></term>
+        <listitem><simpara>Returns the top level system directory under which the nss libraries are installed.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--exec-prefix</option></term>
+        <listitem><simpara>returns the top level system directory under which any nss binaries would be installed.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--includedir</option> <replaceable>count</replaceable></term>
+        <listitem><simpara>returns the path to the directory were the nss libraries are installed.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--version</option></term>
+        <listitem><simpara>returns the upstream version of nss in the form major_version-minor_version-patch_version.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--libs</option></term>
+        <listitem><simpara>returns the compiler linking flags.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--cflags</option></term>
+        <listitem><simpara>returns the compiler include flags.</simpara></listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><option>--libdir</option></term>
+        <listitem><simpara>returns the path to the directory were the nss libraries are installed.</simpara></listitem>
+      </varlistentry>
+
+    </variablelist>
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <para>The following example will query for both include path and linkage flags:
+    
+      <programlisting>
+        /usr/bin/nss-config --cflags --libs
+      </programlisting>
+
+    </para>
+
+   
+  </refsection>
+
+  <refsection>
+    <title>Files</title>
+
+    <para><filename>/usr/bin/nss-config</filename></para>
+
+  </refsection>
+
+  <refsection>
+    <title>See also</title>
+    <para>pkg-config(1)</para>
+  </refsection>
+
+  <refsection id="authors">
+    <title>Authors</title>
+    <para>The nss liraries were written and maintained by developers with Netscape, Red Hat,  Sun, Oracle, Mozilla, and Google.</para>
+    <para>
+	Authors: Elio Maldonado &lt;emaldona@redhat.com>.
+    </para>
+  </refsection>
+
+<!-- don't change -->
+  <refsection id="license">
+    <title>LICENSE</title>
+    <para>Licensed under the Mozilla Public License, v. 2.0.  If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    </para>
+  </refsection>
+
+</refentry>
+
diff --git a/abs/extra/nss/nss.install b/abs/extra/nss/nss.install
deleted file mode 100644
index 24f9ec6..0000000
--- a/abs/extra/nss/nss.install
+++ /dev/null
@@ -1,13 +0,0 @@
-post_upgrade() {
-  if (($(vercmp $2 3.18-3) < 0)); then
-    # This symlink was created by ldconfig because we linked to
-    # pkcs11/p11-kit-trust.so from libnssckbi.so; the chain was:
-    #   p11-kit-trust.so -> libnssckbi.so -> pkcs11/p11-kit-trust.so
-    # Now we have:
-    #   libnssckbi.so -> libnssckbi-p11-kit.so
-    # which no longer creates an incorrect p11-kit-trust.so symlink
-    if [[ $(readlink usr/lib/p11-kit-trust.so) == libnssckbi.so ]]; then
-      rm usr/lib/p11-kit-trust.so
-    fi
-  fi
-}
diff --git a/abs/extra/nss/nss.pc.in b/abs/extra/nss/nss.pc.in
index d47b9e1..42cca9f 100644
--- a/abs/extra/nss/nss.pc.in
+++ b/abs/extra/nss/nss.pc.in
@@ -7,5 +7,5 @@ Name: NSS
 Description: Network Security Services
 Version: %NSS_VERSION%
 Requires: nspr >= %NSPR_VERSION%
-Libs: -lssl3 -lsmime3 -lnss3 -lnssutil3
+Libs: -L${libdir} -lssl3 -lsmime3 -lnss3 -lnssutil3
 Cflags: -I${includedir}
-- 
cgit v0.12

