diff -up libgcrypt-1.5.3/random/drbg.c.drbg-cavs libgcrypt-1.5.3/random/drbg.c
--- libgcrypt-1.5.3/random/drbg.c.drbg-cavs	2017-02-28 14:28:55.695906569 +0100
+++ libgcrypt-1.5.3/random/drbg.c	2017-02-28 14:28:55.700906686 +0100
@@ -2130,6 +2130,16 @@ gcry_drbg_cavs_test (struct gcry_drbg_te
   if (ret)
     goto outbuf;
 
+  if (test->entropyrsd)
+    {
+      gcry_drbg_string_fill (&testentropy, test->entropyrsd,
+			     test->entropyrsdlen);
+      gcry_drbg_string_fill (&addtl, test->addtlrsd,
+			     test->addtlrsdlen);
+      if (gcry_drbg_reseed (drbg, &addtl))
+	goto outbuf;
+    }
+
   gcry_drbg_string_fill (&addtl, test->addtla, test->addtllen);
   if (test->entpra)
     {
diff -up libgcrypt-1.5.3/random/random.h.drbg-cavs libgcrypt-1.5.3/random/random.h
--- libgcrypt-1.5.3/random/random.h.drbg-cavs	2017-02-28 14:28:55.686906357 +0100
+++ libgcrypt-1.5.3/random/random.h	2017-02-28 14:28:55.700906686 +0100
@@ -69,6 +69,10 @@ struct gcry_drbg_test_vector
   size_t perslen;
   unsigned char *expected;
   size_t expectedlen;
+  unsigned char *entropyrsd;
+  size_t entropyrsdlen;
+  unsigned char *addtlrsd;
+  size_t addtlrsdlen;
 };
 
 gpg_err_code_t gcry_drbg_cavs_test (struct gcry_drbg_test_vector *test,
diff -up libgcrypt-1.5.3/tests/cavs_driver.pl.drbg-cavs libgcrypt-1.5.3/tests/cavs_driver.pl
--- libgcrypt-1.5.3/tests/cavs_driver.pl.drbg-cavs	2017-02-28 14:28:55.674906074 +0100
+++ libgcrypt-1.5.3/tests/cavs_driver.pl	2017-02-28 14:41:46.086048300 +0100
@@ -192,15 +192,17 @@ my $rsa_derive;
 # Sign a message with RSA
 # $1: data to be signed in hex form
 # $2: Hash algo
-# $3: Key file in PEM format with the private key
+# $3: PSS flag
+# $4: Key file in PEM format with the private key
 # return: digest in hex format
 my $rsa_sign;
 
 # Verify a message with RSA
 # $1: data to be verified in hex form
 # $2: hash algo
-# $3: file holding the public RSA key in PEM format
-# $4: file holding the signature in binary form
+# $3: PSS flag
+# $4: file holding the public RSA key in PEM format
+# $5: file holding the signature in binary form
 # return: 1 == verified / 0 == not verified
 my $rsa_verify;
 
@@ -329,6 +331,8 @@ my $rsa_keygen;
 
 my $rsa_keygen_kat;
 
+my $drbg_kat;
+
 ################################################################
 ##### OpenSSL interface functions
 ################################################################
@@ -350,9 +354,10 @@ sub openssl_encdec($$$$$) {
 	return bin2hex($data);
 }
 
-sub openssl_rsa_sign($$$) {
+sub openssl_rsa_sign($$$$) {
 	my $data = shift;
 	my $cipher = shift;
+	my $pss = shift; # unsupported
 	my $keyfile = shift;
 
 	$data=hex2bin($data);
@@ -365,6 +370,7 @@ sub openssl_rsa_sign($$$) {
 sub openssl_rsa_verify($$$$) {
 	my $data = shift;
 	my $cipher = shift;
+	my $pss = shift; # unsupported
 	my $keyfile = shift;
 	my $sigfile = shift;
 
@@ -497,27 +503,38 @@ sub libgcrypt_rsa_keygen_kat($$$$) {
 }
 
 
-sub libgcrypt_rsa_sign($$$) {
+sub libgcrypt_rsa_sign($$$$) {
 	my $data = shift;
 	my $hashalgo = shift;
+	my $pss = shift;
 	my $keyfile = shift;
 
 	die "ARCFOUR not available for RSA" if $opt{'R'};
 
+	if ($pss) {
+		return pipe_through_program($data,
+			"fipsdrv --pss --algo $hashalgo --key $keyfile rsa-sign");
+	}
 	return pipe_through_program($data,
 		"fipsdrv --pkcs1 --algo $hashalgo --key $keyfile rsa-sign");
 }
 
-sub libgcrypt_rsa_verify($$$$) {
+sub libgcrypt_rsa_verify($$$$$) {
 	my $data = shift;
 	my $hashalgo = shift;
+	my $pss = shift;
 	my $keyfile = shift;
 	my $sigfile = shift;
 
 	die "ARCFOUR not available for RSA" if $opt{'R'};
+
+	if ($pss) {
+		$data = pipe_through_program($data,
+			"fipsdrv --pss --algo $hashalgo --key $keyfile --signature $sigfile rsa-verify");
+	} else {
 	$data = pipe_through_program($data,
 		"fipsdrv --pkcs1 --algo $hashalgo --key $keyfile --signature $sigfile rsa-verify");
-
+	}
 	# Parse through the output information
 	return ($data =~ /GOOD signature/);
 }
@@ -543,6 +560,16 @@ sub libgcrypt_hash($$) {
 	return pipe_through_program($pt, $program);
 }
 
+sub libgcrypt_hash_mct($$) {
+	my $pt = shift;
+	my $hashalgo = shift;
+
+	my $program = "fipsdrv --algo $hashalgo --loop digest";
+	die "ARCFOUR not available for hashes" if $opt{'R'};
+
+	return pipe_through_program($pt, $program);
+}
+
 sub libgcrypt_state_cipher($$$$$) {
 	my $cipher = shift;
 	my $enc = (shift) ? "encrypt": "decrypt";
@@ -693,6 +720,35 @@ sub libgcrypt_dsa_verify($$$$) {
 	return ($ret =~ /GOOD signature/);
 }
 
+sub libgcrypt_drbg_kat($$$$$$$$$$$$$$$$$) {
+	my $mode = shift;
+	my $cipher = shift;
+	my $pr = shift;
+	my $ent = shift;
+	my $entlen = shift;
+	my $nonce = shift;
+	my $noncelen = shift;
+	my $entrs = shift;
+	my $addtlrs = shift;
+	my $entpra = shift;
+	my $entprb = shift;
+	my $addtla = shift;
+	my $addtlb = shift;
+	my $addtllen = shift;
+	my $pers = shift;
+	my $perslen = shift;
+	my $expectedlen = shift;
+
+	my $entprlen = $entlen;
+
+	# concatenate entropy and nonce
+	$ent .= $nonce;
+	$entlen = $entlen + $noncelen;
+
+	return lc(pipe_through_program("$mode\n$pr\n$entlen\n$ent\n$perslen\n$pers\n$expectedlen\n$addtllen\n$entrs\n$addtlrs\n$addtla\n$addtlb\n$entprlen\n$entpra\n$entprb\n", "./fipsdrv --algo $cipher drbg"));
+}
+
+
 ######### End of libgcrypt implementation ################
 
 ################################################################
@@ -1468,13 +1524,17 @@ sub hash_mct($$) {
 		my $md0=$pt;
 		my $md1=$pt;
 		my $md2=$pt;
-        	for (my $i=0; $i<1000; ++$i) {
-			#print STDERR "outer loop $j; inner loop $i\n";
-			my $mi= $md0 . $md1 . $md2;
-			$md0=$md1;
-			$md1=$md2;
-			$md2 = &$hash($mi, $cipher);
-			$md2 =~ s/\n//;
+		if ($opt{'I'} && $opt{'I'} eq 'libgcrypt') {
+			$md2 = &libgcrypt_hash_mct($pt, $cipher);
+		} else {
+			for (my $i=0; $i<1000; ++$i) {
+				#print STDERR "outer loop $j; inner loop $i\n";
+				my $mi= $md0 . $md1 . $md2;
+				$md0=$md1;
+				$md1=$md2;
+				$md2 = &$hash($mi, $cipher);
+				$md2 =~ s/\n//;
+			}
 		}
                 $out .= "MD = $md2\n\n";
 		$pt=$md2;
@@ -1483,21 +1543,65 @@ sub hash_mct($$) {
 	return $out;
 }
 
+sub drbg_kat_driver($$$$$$$$$$$$$$$$$) {
+	my $mode = shift;
+	my $cipher = shift;
+	my $pr = shift;
+	my $ent = shift;
+	my $entlen = shift;
+	my $nonce = shift;
+	my $noncelen = shift;
+	my $entrs = shift;
+	my $addtlrs = shift;
+	my $entpra = shift;
+	my $entprb = shift;
+	my $addtla = shift;
+	my $addtlb = shift;
+	my $addtllen = shift;
+	my $pers = shift;
+	my $perslen = shift;
+	my $expectedlen = shift;
+
+	my $out = "";
+
+	$out .= "ReturnedBits = " . &$drbg_kat($mode,
+						$cipher,
+						$pr,
+						$ent,
+						$entlen,
+						$nonce,
+						$noncelen,
+						$entrs,
+						$addtlrs,
+						$entpra,
+						$entprb,
+						$addtla,
+						$addtlb,
+						$addtllen,
+						$pers,
+						$perslen,
+						$expectedlen) . "\n";
+
+	return $out;
+}
+
 # RSA SigGen test
 # $1: Message to be signed in hex form
 # $2: Hash algorithm
-# $3: file name with RSA key in PEM form
+# $3: Use PSS
+# $4: file name with RSA key in PEM form
 # return: string formatted as expected by CAVS
-sub rsa_siggen($$$) {
+sub rsa_siggen($$$$) {
 	my $data = shift;
 	my $cipher = shift;
+	my $pss = shift;
 	my $keyfile = shift;
 
 	my $out = "";
 
 	$out .= "SHAAlg = $cipher\n";
 	$out .= "Msg = $data\n";
-	$out .= "S = " . &$rsa_sign($data, lc($cipher), $keyfile) . "\n";
+	$out .= "S = " . &$rsa_sign($data, lc($cipher), $pss, $keyfile) . "\n";
 
 	return $out;
 }
@@ -1505,13 +1609,15 @@ sub rsa_siggen($$$) {
 # RSA SigVer test
 # $1: Message to be verified in hex form
 # $2: Hash algoritm
-# $3: Signature of message in hex form
-# $4: n of the RSA key in hex in hex form
-# $5: e of the RSA key in hex in hex form
+# $3: Use PSS
+# $4: Signature of message in hex form
+# $5: n of the RSA key in hex in hex form
+# $6: e of the RSA key in hex in hex form
 # return: string formatted as expected by CAVS
-sub rsa_sigver($$$$$) {
+sub rsa_sigver($$$$$$) {
 	my $data = shift;
 	my $cipher = shift;
+	my $pss = shift;
 	my $signature = shift;
 	my $n = shift;
 	my $e = shift;
@@ -1534,7 +1640,7 @@ sub rsa_sigver($$$$$) {
 	print FH hex2bin($signature);
 	close FH;
 
-	$out .= "Result = " . (&$rsa_verify($data, lc($cipher), $keyfile, $sigfile) ? "P\n" : "F\n");
+	$out .= "Result = " . (&$rsa_verify($data, lc($cipher), $pss, $keyfile, $sigfile) ? "P\n" : "F\n");
 
 	unlink($keyfile);
 	unlink($sigfile);
@@ -1905,13 +2011,14 @@ sub rsa_keygen_driver($$) {
 # $2 p in hex form
 # $3 q in hex form
 # return: string formatted as expected by CAVS
-sub rsa_keygen_kat_driver($$$) {
+sub rsa_keygen_kat_driver($$$$) {
 	my $mod = shift;
+	my $e = shift;
 	my $p = shift;
 	my $q = shift;
 
 	my $out = "";
-	my $ret = &$rsa_keygen_kat($mod, $p, $q);
+	my $ret = &$rsa_keygen_kat($mod, $e, $p, $q);
 	my ($Result) = split(/\n/, $ret);
 	die "Return value does not contain all expected values of Result for rsa_keygen_kat"
 		if (!defined($Result));
@@ -1999,8 +2106,24 @@ sub parse($$) {
 	my $xq1 = "";
 	my $xq2 = "";
 	my $Xq = "";
+	my $pr = 0;
+	my $ent = "";
+	my $entlen = 0;
+	my $nonce = "";
+	my $noncelen = 0;
+	my $entrs = "";
+	my $addtlrs = "";
+	my $entpra = "x";
+	my $entprb = "x";
+	my $addtla = "x";
+	my $addtlb = "x";
+	my $addtllen = 0;
+	my $pers = "";
+	my $perslen = 0;
+	my $expectedlen = 0;
 
 	my $mode = "";
+	my $pss = 0;
 
 	open(IN, "<$infile");
 	while(<IN>) {
@@ -2029,7 +2152,7 @@ sub parse($$) {
 
 		##### Extract cipher
 		# XXX there may be more - to be added
-		if ($tmpline =~ /^#.*(CBC|ECB|OFB|CFB|SHA-|SigGen|SigVer|RC4VS|ANSI X9\.31|Hash sizes tested|PQGGen|KeyGen RSA|KeyGen - Random Probably Prime|KeyPair|PQGVer)/) {
+		if ($tmpline =~ /^#.*(CBC|ECB|OFB|CFB|SHA-|SigGen|SigVer|RC4VS|ANSI X9\.31|Hash sizes tested|PQGGen|KeyGen RSA|KeyGen - Random Probably Prime|KeyPair|PQGVer|DRBG800-90A)/) {
 			if ($tmpline    =~ /CBC/)   { $mode="cbc"; }
 			elsif ($tmpline =~ /ECB/)   { $mode="ecb"; }
 			elsif ($tmpline =~ /OFB/)   { $mode="ofb"; }
@@ -2078,7 +2201,11 @@ sub parse($$) {
 
 			if ($tt == 0) {
 			##### Identify the test type
-				if ($tmpline =~ /KeyGen - Random Probably Prime Known Answer Test/) {
+				if ($tmpline =~ /DRBG800-90A/) {
+					$tt = 20;
+					die "Interface function drbg_kat for DRBG KAT not defined for tested library"
+						if (!defined($drbg_kat));
+				} elsif ($tmpline =~ /KeyGen - Random Probably Prime Known Answer Test/) {
 					$tt = 19;
 					die "Interface function rsa_keygen_kat for RSA key generation KAT not defined for tested library"
 						if (!defined($rsa_keygen_kat));
@@ -2123,10 +2250,16 @@ sub parse($$) {
 					die "Interface function state_rng for RNG KAT not defined for tested library"
 						if (!defined($state_rng));
 				} elsif ($tmpline =~ /SigVer/ ) {
+					if ($tmpline =~ /RSASSA-PSS/) {
+						$pss = 1;
+					}
 					$tt = 6;
 					die "Interface function rsa_verify or gen_rsakey for RSA verification not defined for tested library"
 						if (!defined($rsa_verify) || !defined($gen_rsakey));
 				} elsif ($tmpline =~ /SigGen/ ) {
+					if ($tmpline =~ /RSASSA-PSS/) {
+						$pss = 1;
+					}
 					$tt = 5;
 					die "Interface function rsa_sign or gen_rsakey for RSA sign not defined for tested library"
 						if (!defined($rsa_sign) || !defined($gen_rsakey));
@@ -2252,7 +2385,7 @@ sub parse($$) {
 				$out .= "G = " . $pqg{'G'} . "\n\n";
                         }
                 }
-		elsif ($line =~ /^\[mod\s*=\s*(.*)\]$/) { # found in RSA requests
+		elsif ($line =~ /^\[mod\s*=\s*(.*)\]/) { # found in RSA requests
 			$modulus = $1;
 			$out .= $line . "\n\n"; # print it
 			# generate the private key with given bit length now
@@ -2277,10 +2410,21 @@ sub parse($$) {
 			$n=$1;
 		}
 		elsif ($line =~ /^e\s*=\s*(.*)/) { # found in RSA requests
-			$e=$1;
 			if ($tt == 19) {
+				if ($modulus ne "" &&
+				    $e ne "" &&
+				    $prandom ne "") {
+					$out .= rsa_keygen_kat_driver($modulus,
+							$e,
+							$prandom,
+							"00");
+					$prandom = "";
+					$qrandom = "";
+					$e = "";
+				}
 				$out .= $line . "\n"; # print it
 			}
+			$e=$1;
 		}
 		elsif ($line =~ /^S\s*=\s*(.*)/) { # found in RSA requests
 			die "S seen twice - input file crap" if ($signature ne "");
@@ -2306,6 +2450,89 @@ sub parse($$) {
 				if ($tlen ne "");
 			$tlen=$1;
 		}
+		elsif ($tt == 20) {
+			if ($line =~ /Hash_DRBG/) { # HASH DRBG request
+				$mode = "hash";
+			}
+			elsif ($line =~ /HMAC_DRBG/) { # HMAC DRBG request
+				$mode = "hmac";
+			}
+			elsif ($line =~ /CTR_DRBG/) { # CTR DRBG request
+				$mode = "ctr";
+			}
+			elsif ($line =~ /^\[SHA-1\]/) {
+				$cipher= "sha-1";
+			}
+			elsif ($line =~ /^\[SHA-256\]/) {
+				$cipher= "sha-256";
+			}
+			elsif ($line =~ /^\[SHA-384\]/) {
+				$cipher= "sha-384";
+			}
+			elsif ($line =~ /^\[SHA-512\]/) {
+				$cipher= "sha-512";
+			}
+			elsif ($line =~ /^\[AES-128 use df\]/) {
+				$cipher= "aes-128";
+			}
+			elsif ($line =~ /^\[AES-192 use df\]/) {
+				$cipher= "aes-192";
+			}
+			elsif ($line =~ /^\[AES-256 use df\]/) {
+				$cipher= "aes-256";
+			}
+			elsif ($line =~ /^\[PredictionResistance\s*=\s*True\]/) {
+				$pr = 1;
+			}
+			elsif ($line =~ /^\[PredictionResistance\s*=\s*False\]/) {
+				$pr = 0;
+			}
+			elsif ($line =~ /^\[EntropyInputLen\s*=\s*(.*)\]/) {
+				$entlen = $1;
+			}
+			elsif ($line =~ /^\[NonceLen\s*=\s*(.*)\]/) {
+				$noncelen = $1;
+			}
+			elsif ($line =~ /^\[PersonalizationStringLen\s*=\s*(.*)\]/) {
+				$perslen = $1;
+			}
+			elsif ($line =~ /^\[AdditionalInputLen\s*=\s*(.*)\]/) {
+				$addtllen = $1;
+			}
+			elsif ($line =~ /^\[ReturnedBitsLen\s*=\s*(.*)\]/) {
+				$expectedlen = $1;
+			}
+			elsif ($line =~ /^EntropyInput\s*=\s*(.*)/) {
+				$ent = $1;
+			}
+			elsif ($line =~ /^EntropyInputReseed\s*=\s*(.*)/) {
+				$entrs = $1;
+			}
+			elsif ($line =~ /^Nonce\s*=\s*(.*)/) {
+				$nonce = $1;
+			}
+			elsif ($line =~ /^PersonalizationString\s*=\s*(.*)/) {
+				$pers = $1;
+			}
+			elsif ($line =~ /^AdditionalInput\s*=\s*(.*)/) {
+				if ($addtla eq "x") {
+					$addtla = $1;
+				} else {
+					$addtlb = $1;
+				}
+			}
+			elsif ($line =~ /^EntropyInputPR\s*=\s*(.*)/) {
+				if ($entpra eq "x") {
+					$entpra = $1;
+				} else {
+					$entprb = $1;
+				}
+			}
+			elsif ($line =~ /^AdditionalInputReseed\s*=\s*(.*)/) {
+				$addtlrs = $1;
+			}
+			$out .= $line . "\n"; # print it
+		}
 		elsif ($line =~ /^N\s*=\s*(.*)/) { #DSA KeyPair
 			die "N seen twice - check input file"
 				if ($capital_n);
@@ -2396,10 +2623,6 @@ sub parse($$) {
 			$qrandom = $1;
 			$out .= $line . "\n"; # print it
 		}
-		elsif ($tt == 19 && $line =~ /^ / && $qrandom eq "") { #RSA key gen KAT
-			$qrandom = "00";
-			$out .= $line . "\n"; # print it
-		}
 		else {
 			$out .= $line . "\n";
 		}
@@ -2442,13 +2665,13 @@ sub parse($$) {
 		}
 		elsif ($tt == 5) {
 			if ($pt ne "" && $cipher ne "" && $rsa_keyfile ne "") {
-				$out .= rsa_siggen($pt, $cipher, $rsa_keyfile);
+				$out .= rsa_siggen($pt, $cipher, $pss, $rsa_keyfile);
 				$pt = "";
 			}
 		}
 		elsif ($tt == 6) {
 			if ($pt ne "" && $cipher ne "" && $signature ne "" && $n ne "" && $e ne "") {
-				$out .= rsa_sigver($pt, $cipher, $signature, $n, $e);
+				$out .= rsa_sigver($pt, $cipher, $pss, $signature, $n, $e);
 				$pt = "";
 				$signature = "";
 			}
@@ -2635,6 +2858,37 @@ sub parse($$) {
 				$e = "";
 			}
 		}
+		elsif ($tt == 20) {
+			if (($pr == 1 && $entpra ne "x" &&  $entprb ne "x") ||
+				($pr == 0 && $addtla ne "x" && $addtlb ne "x")) {
+					$out .= drbg_kat_driver($mode,
+								$cipher,
+								$pr,
+								$ent,
+								$entlen,
+								$nonce,
+								$noncelen,
+								$entrs,
+								$addtlrs,
+								$entpra,
+								$entprb,
+								$addtla,
+								$addtlb,
+								$addtllen,
+								$pers,
+								$perslen,
+								$expectedlen);
+					$entpra = "x";
+					$entprb = "x";
+					$addtla = "x";
+					$addtlb = "x";
+					$ent = "";
+					$nonce = "";
+					$pers = "";
+					$entrs = "";
+					$addtlrs = "";
+			}
+		}
 		elsif ($tt > 0) {
 			die "Test case $tt not defined";
 		}
@@ -2701,6 +2955,7 @@ sub main() {
 		$dsa_genpubkey = \&libgcrypt_dsa_genpubkey;
 		$rsa_keygen = \&libgcrypt_rsa_keygen;
 		$rsa_keygen_kat = \&libgcrypt_rsa_keygen_kat;
+		$drbg_kat = \&libgcrypt_drbg_kat;
         } else {
                 die "Invalid interface option given";
         }
diff -up libgcrypt-1.5.3/tests/fipsdrv.c.drbg-cavs libgcrypt-1.5.3/tests/fipsdrv.c
--- libgcrypt-1.5.3/tests/fipsdrv.c.drbg-cavs	2017-02-28 14:28:55.674906074 +0100
+++ libgcrypt-1.5.3/tests/fipsdrv.c	2017-02-28 14:43:28.320456712 +0100
@@ -22,6 +22,7 @@
 #endif
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include <stdarg.h>
 #include <errno.h>
@@ -893,8 +894,10 @@ print_mpi_line (gcry_mpi_t a, int no_lz)
     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
 
   p = buf;
-  while (*p)
-     *p++ = tolower(*p);
+  while (*p) {
+     *p = tolower(*p);
+     ++p;
+  }
   p = buf;
   if (no_lz && p[0] == '0' && p[1] == '0' && p[2])
     p += 2;
@@ -1256,6 +1259,46 @@ run_digest (int digest_algo,  const void
   gcry_md_close (hd);
 }
 
+/* Run inner loop of digest mct operation.  */
+static void
+run_digest_mct_loop (int digest_algo,  const void *data, size_t datalen, int iter)
+{
+  gpg_error_t err;
+  gcry_md_hd_t hd;
+  const unsigned char *digest;
+  unsigned int digestlen;
+  int i;
+  unsigned char *buf;
+
+  err = gcry_md_open (&hd, digest_algo, 0);
+  if (err)
+    die ("gcry_md_open failed for algo %d: %s\n",
+         digest_algo,  gpg_strerror (err));
+
+  digestlen = gcry_md_get_algo_dlen (digest_algo);
+  if (digestlen != datalen)
+    die ("Unexpected seed size %u for Hash mct algo %d\n", datalen, digest_algo);
+
+  buf = malloc (3*datalen);
+  if (!buf)
+    die ("Buffer allocation failed\n");
+
+  memcpy (buf, data, datalen);
+  memcpy (buf + datalen, data, datalen);
+  memcpy (buf + 2*datalen, data, datalen);
+
+  for (i = 0; i < iter; ++i)
+    {
+      gcry_md_reset (hd);
+      gcry_md_write (hd, buf, 3*datalen);
+      digest = gcry_md_read (hd, digest_algo);
+      memmove (buf, buf + datalen, 2*datalen);
+      memcpy (buf + 2*datalen, digest, datalen);
+    }
+  print_buffer (digest, digestlen);
+  gcry_md_close (hd);
+}
+
 
 /* Run a HMAC operation.  */
 static void
@@ -1403,7 +1446,7 @@ run_rsa_keygen (const void *data, size_t
       gcry_sexp_release (l1);
       if (!mpi)
         die ("parameter %c missing in private-key\n", parmlist[idx]);
-      print_mpi_line (mpi, 1);
+      print_mpi_line (mpi, parmlist[idx] != 'd');
       gcry_mpi_release (mpi);
     }
 
@@ -1592,7 +1635,7 @@ run_rsa_gen (int keysize, int pubexp)
    encoded KEYFILE and the hash algorithm HASHALGO.  */
 static void
 run_rsa_sign (const void *data, size_t datalen,
-              int hashalgo, int pkcs1, const char *keyfile)
+              int hashalgo, int pkcs1, int pss, const char *keyfile)
 
 {
   gpg_error_t err;
@@ -1616,6 +1659,20 @@ run_rsa_sign (const void *data, size_t d
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
+  else if (pss)
+    {
+      unsigned char hash[64];
+      unsigned int hashsize;
+
+      hashsize = gcry_md_get_algo_dlen (hashalgo);
+      if (!hashsize || hashsize > sizeof hash)
+        die ("digest too long for buffer or unknown hash algorithm\n");
+      gcry_md_hash_buffer (hashalgo, hash, data, datalen);
+      err = gcry_sexp_build (&s_data, NULL,
+                             "(data (flags pss)(hash %s %b))",
+                             gcry_md_algo_name (hashalgo),
+                             (int)hashsize, hash);
+    }
   else
     {
       gcry_mpi_t tmp;
@@ -1683,7 +1740,7 @@ run_rsa_sign (const void *data, size_t d
    binary signature in SIGFILE.  */
 static void
 run_rsa_verify (const void *data, size_t datalen, int hashalgo, int pkcs1,
-                const char *keyfile, const char *sigfile)
+                int pss, const char *keyfile, const char *sigfile)
 
 {
   gpg_error_t err;
@@ -1703,6 +1760,20 @@ run_rsa_verify (const void *data, size_t
                              gcry_md_algo_name (hashalgo),
                              (int)hashsize, hash);
     }
+  else if (pss)
+    {
+      unsigned char hash[64];
+      unsigned int hashsize;
+
+      hashsize = gcry_md_get_algo_dlen (hashalgo);
+      if (!hashsize || hashsize > sizeof hash)
+        die ("digest too long for buffer or unknown hash algorithm\n");
+      gcry_md_hash_buffer (hashalgo, hash, data, datalen);
+      err = gcry_sexp_build (&s_data, NULL,
+                             "(data (flags pss)(hash %s %b))",
+                             gcry_md_algo_name (hashalgo),
+                             (int)hashsize, hash);
+    }
   else
     {
       gcry_mpi_t tmp;
@@ -2220,7 +2291,150 @@ run_dsa_verify (const void *data, size_t
   gcry_sexp_release (s_data);
 }
 
+struct gcry_drbg_test_vector
+{
+  uint32_t flags;
+  unsigned char *entropy;
+  size_t entropylen;
+  unsigned char *entpra;
+  unsigned char *entprb;
+  size_t entprlen;
+  unsigned char *addtla;
+  unsigned char *addtlb;
+  size_t addtllen;
+  unsigned char *pers;
+  size_t perslen;
+  unsigned char *expected;
+  size_t expectedlen;
+  unsigned char *entropyrsd;
+  size_t entropyrsdlen;
+  unsigned char *addtlrsd;
+  size_t addtlrsdlen;
+ };
+
+static uint32_t
+decode_drbg_flags(const char *algo, const char *mode, const char *pr)
+{
+	uint32_t flags = 0;
+
+	if (*pr == '1')
+		flags = GCRY_DRBG_PREDICTION_RESIST;
+
+	if (!strcmp(algo, "sha-1"))
+		flags |= GCRY_DRBG_HASHSHA1;
+	else if (!strcmp(algo, "sha-256"))
+		flags |= GCRY_DRBG_HASHSHA256;
+	else if (!strcmp(algo, "sha-384"))
+		flags |= GCRY_DRBG_HASHSHA384;
+	else if (!strcmp(algo, "sha-512"))
+		flags |= GCRY_DRBG_HASHSHA512;
+	else if (!strcmp(algo, "aes-128"))
+		flags |= GCRY_DRBG_SYM128;
+	else if (!strcmp(algo, "aes-192"))
+		flags |= GCRY_DRBG_SYM192;
+	else if (!strcmp(algo, "aes-256"))
+		flags |= GCRY_DRBG_SYM256;
+
+	if (!strcmp(mode, "hmac"))
+		flags |= GCRY_DRBG_HMAC;
+	else if (!strcmp(mode, "ctr"))
+		flags |= GCRY_DRBG_CTRAES;
+
+	return flags;	
+}
+
+static void
+run_drbg_test (const char *algo, void *data, size_t datalen)
+{
+	char *ptr = data;
+	char *mode;
+	char *pr;
+	char *entlen;
+	char *ent;
+	char *perslen;
+	char *pers;
+	char *expectedlen;
+	char *addtllen;
+	char *entrsd;
+	char *addtlrsd;
+	char *addtla;
+	char *addtlb;
+	char *entprlen;
+	char *entpra;
+	char *entprb;
+	unsigned char *buf;
+	size_t len;
+	struct gcry_drbg_test_vector vect;
+
+	mode = strsep(&ptr, "\n");
+	pr = strsep(&ptr, "\n");
+	entlen = strsep(&ptr, "\n");
+	ent = strsep(&ptr, "\n");
+	perslen = strsep(&ptr, "\n");
+	pers = strsep(&ptr, "\n");
+	expectedlen = strsep(&ptr, "\n");
+	addtllen = strsep(&ptr, "\n");
+	entrsd = strsep(&ptr, "\n");
+	addtlrsd = strsep(&ptr, "\n");
+	addtla = strsep(&ptr, "\n");
+	addtlb = strsep(&ptr, "\n");
+	entprlen = strsep(&ptr, "\n");
+	entpra = strsep(&ptr, "\n");
+	entprb = strsep(&ptr, "\n");
+
+	if (entprb == NULL) {
+		fprintf(stderr, "ERROR - Missing input data\n");
+		return;
+	}
+
+	vect.flags = decode_drbg_flags(algo, mode, pr);
+	
+	vect.entropy = hex2buffer(ent, &len);
+	vect.entropylen = atoi(entlen) / 8;
+	if (len != vect.entropylen) {
+		fprintf(stderr, "ERROR - inconsistent input data\n");
+		return;
+	}
+	vect.pers = hex2buffer(pers, &len);
+	vect.perslen = atoi(perslen) / 8;
+	if (len != vect.perslen) {
+		fprintf(stderr, "ERROR - inconsistent input data\n");
+		return;
+	}
+	vect.expectedlen = atoi(expectedlen) / 8;
+	vect.expected = NULL;
+	vect.addtlrsdlen = vect.addtllen = atoi(addtllen) / 8;
+	vect.addtla = hex2buffer(addtla, &len);
+	vect.addtlb = hex2buffer(addtlb, &len);
+	vect.entropyrsdlen = vect.entprlen = atoi(entprlen) / 8;
+	vect.entpra = hex2buffer(entpra, &len);
+	vect.entprb = hex2buffer(entprb, &len);
+	if (*entrsd != '\0') {
+		vect.entropyrsd = hex2buffer(entrsd, &len);
+		if (len != vect.entropyrsdlen) {
+			fprintf(stderr, "ERROR - inconsistent input data\n");
+			return;
+		}
+		if (*addtlrsd != '\0') {
+			vect.addtlrsd = hex2buffer(addtlrsd, &len);
+			if (len != vect.addtlrsdlen) {
+				fprintf(stderr, "ERROR - inconsistent input data\n");
+				return;
+			}
+		} else {
+			vect.addtlrsd = NULL;
+		}
+	} else {
+		vect.entropyrsd = NULL;
+		vect.addtlrsd = NULL;
+	}
+
+	buf = gcry_xmalloc(vect.expectedlen);
 
+	gcry_control(75, &vect, buf);
+
+	print_data_line(buf, vect.expectedlen);
+}
 
 
 static void
@@ -2251,6 +2465,7 @@ usage (int show_help)
      "  --signature NAME Take signature from file NAME\n"
      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
      "  --pkcs1          Use PKCS#1 encoding\n"
+     "  --pss            Use PKCS#1 PSS encoding\n"
      "  --mct-server     Run a monte carlo test server\n"
      "  --loop           Enable random loop mode\n"
      "  --progress       Print pogress indicators\n"
@@ -2268,6 +2483,7 @@ main (int argc, char **argv)
   int no_fips = 0;
   int progress = 0;
   int use_pkcs1 = 0;
+  int use_pss = 0;
   const char *mode_string;
   const char *key_string = NULL;
   const char *iv_string = NULL;
@@ -2398,6 +2614,11 @@ main (int argc, char **argv)
           use_pkcs1 = 1;
           argc--; argv++;
         }
+      else if (!strcmp (*argv, "--pss"))
+        {
+          use_pss = 1;
+          argc--; argv++;
+        }
       else if (!strcmp (*argv, "--mct-server"))
         {
           mct_server = 1;
@@ -2414,7 +2635,10 @@ main (int argc, char **argv)
     usage (0);
   mode_string = *argv;
 
-  if (!strcmp (mode_string, "rsa-derive"))
+  if (!strcmp (mode_string, "rsa-derive") ||
+      !strcmp (mode_string, "rsa-keygen") ||
+      !strcmp (mode_string, "rsa-keygen-kat") ||
+      !strcmp(mode_string, "drbg"))
     binary_input = 1;
 
   if (argc == 2 && strcmp (argv[1], "-"))
@@ -2557,7 +2781,14 @@ main (int argc, char **argv)
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
-      run_digest (algo, data, datalen);
+      if (loop_mode)
+        {
+          run_digest_mct_loop (algo, data, datalen, 1000);
+        }
+      else
+        {
+          run_digest (algo, data, datalen);
+        }
     }
   else if (!strcmp (mode_string, "random"))
     {
@@ -2602,6 +2833,12 @@ main (int argc, char **argv)
 
       deinit_external_rng_test (context);
     }
+  else if (!strcmp (mode_string, "drbg"))
+    {
+      if (!algo_string)
+	die ("--algo required in this mode\n");
+      run_drbg_test (algo_string, data, datalen);
+    }
   else if (!strcmp (mode_string, "hmac-sha"))
     {
       int algo;
@@ -2679,7 +2916,7 @@ main (int argc, char **argv)
       if (!data)
         die ("no data available (do not use --chunk)\n");
 
-      run_rsa_sign (data, datalen, algo, use_pkcs1, key_string);
+      run_rsa_sign (data, datalen, algo, use_pkcs1, use_pss, key_string);
 
     }
   else if (!strcmp (mode_string, "rsa-verify"))
@@ -2702,7 +2939,7 @@ main (int argc, char **argv)
       if (access (signature_string, R_OK))
         die ("option --signature needs to specify an existing file\n");
 
-      run_rsa_verify (data, datalen, algo, use_pkcs1, key_string,
+      run_rsa_verify (data, datalen, algo, use_pkcs1, use_pss, key_string,
                       signature_string);
 
     }
@@ -2783,12 +3020,6 @@ main (int argc, char **argv)
 
   gcry_free (data);
 
-  /* Because Libgcrypt does not enforce FIPS mode in all cases we let
-     the process die if Libgcrypt is not anymore in FIPS mode after
-     the actual operation.  */
-  if (!no_fips && !gcry_fips_mode_active ())
-    die ("FIPS mode is not anymore active\n");
-
   if (verbose)
     fputs (PGM ": ready\n", stderr);