From 21b2cf6a821a41a2ac6be7346728b52dcc7ad329 Mon Sep 17 00:00:00 2001 From: Britney Fransen 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 +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 /* aes-ni */ ++ ++#define EXPAND_KEY128(k, rcon, res) \ ++ tmp_key = _mm_aeskeygenassist_si128(k, rcon); \ ++ tmp_key = _mm_shuffle_epi32(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 = _mm_shuffle_epi32(_mm_aeskeygenassist_si128(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 /* 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 + +-#ifdef NSS_X86_OR_X64 +-#include /* 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 + + #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 /* __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 = _mm_aeskeygenassist_si128(k, rcon); \ +- tmp_key = _mm_shuffle_epi32(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 = _mm_shuffle_epi32(_mm_aeskeygenassist_si128(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 + +-#ifdef NSS_X86_OR_X64 +-#include /* 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 /* __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 < 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 @@ + + + +]> + + + + + &date; + Network Security Services + nss + &version; + + + + nss-config + 1 + + + + nss-config + Return meta information about nss libraries + + + + + nss-config + + + + + + + + + + + + Description + + nss-config is a shell scrip + tool which can be used to obtain gcc options for building client pacakges of nspt. + + + + + Options + + + + + Returns the top level system directory under which the nss libraries are installed. + + + + + returns the top level system directory under which any nss binaries would be installed. + + + + count + returns the path to the directory were the nss libraries are installed. + + + + + returns the upstream version of nss in the form major_version-minor_version-patch_version. + + + + + returns the compiler linking flags. + + + + + returns the compiler include flags. + + + + + returns the path to the directory were the nss libraries are installed. + + + + + + + Examples + + The following example will query for both include path and linkage flags: + + + /usr/bin/nss-config --cflags --libs + + + + + + + + + Files + + /usr/bin/nss-config + + + + + See also + pkg-config(1) + + + + Authors + The nss liraries were written and maintained by developers with Netscape, Red Hat, Sun, Oracle, Mozilla, and Google. + + Authors: Elio Maldonado <emaldona@redhat.com>. + + + + + + LICENSE + 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/. + + + + + 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