Merge branch 'modexps6' into config_core_selector_sra

8 files changed, 1640 insertions, 6 deletions

diff --git a/sw/Makefile b/sw/Makefile
index d1f33f2..015f6f0 100755
--- a/sw/Makefile
+++ b/sw/Makefile
@@ -1,8 +1,9 @@
 CC = gcc
+AR = ar
 CFLAGS = -Wall -fPIC
 
 LIB = libcryptech.a
-BIN = hash hash_tester trng_extractor trng_tester aes_tester modexp_tester
+BIN = hash hash_tester trng_extractor trng_tester aes_tester modexp_tester modexps6_tester devmem3
 INC = cryptech.h
 
 PREFIX = /usr/local
@@ -16,7 +17,7 @@ all: $(LIB) $(BIN)
 	$(CC) $(CFLAGS) -c -o $@ $<
 
 libcryptech.a: tc_eim.o novena-eim.o capability.o
-	ar rcs $@ $^
+	$(AR) rcs $@ $^
 
 hash_tester: hash_tester.o $(LIB)
 	$(CC) -o $@ $^
@@ -30,20 +31,26 @@ aes_tester: aes_tester.o $(LIB)
 modexp_tester: modexp_tester.o $(LIB)
 	$(CC) -o $@ $^
 
+modexps6_tester: modexps6_tester.o $(LIB)
+	$(CC) -o $@ $^
+
 hash: hash.o $(LIB)
 	$(CC) -o $@ $^
 
 trng_extractor: trng_extractor.o $(LIB)
 	$(CC) -o $@ $^
 
+devmem3: devmem3.o $(LIB)
+	$(CC) -o $@ $^
+
 install: $(LIB) $(BIN) $(INC)
 	install $(LIB) $(LIB_DIR)
-	install $(BIN) $(BIN_DIR)
+	install $(BIN) configure-fpga.sh $(BIN_DIR)
 	install $(INC) $(INC_DIR)
 
 uninstall:
 	rm -f $(LIB_DIR)/$(LIB)
-	rm -f $(foreach bin,$(BIN),$(BIN_DIR)/$(bin))
+	rm -f $(foreach bin,$(BIN) configure-fpga.sh,$(BIN_DIR)/$(bin))
 	rm -f $(INC_DIR)/$(INC)
 
 clean:
diff --git a/sw/Makefile.i2c b/sw/Makefile.i2c
index 1294360..5c69069 100755
--- a/sw/Makefile.i2c
+++ b/sw/Makefile.i2c
@@ -1,8 +1,9 @@
 CC = gcc
+AR = AR
 CFLAGS = -Wall -fPIC
 
 LIB = libcryptech_i2c.a
-BIN = hash_i2c hash_tester_i2c trng_extractor_i2c trng_tester_i2c
+BIN = hash_i2c hash_tester_i2c trng_extractor_i2c trng_tester_i2c aes_tester_i2c modexp_tester_i2c
 INC = cryptech.h
 
 PREFIX = /usr/local
@@ -16,7 +17,7 @@ all: $(LIB) $(BIN)
 	$(CC) $(CFLAGS) -c -o $@ $<
 
 libcryptech_i2c.a: tc_i2c.o capability.o
-	ar rcs $@ $^
+	$(AR) rcs $@ $^
 
 hash_tester_i2c: hash_tester.o $(LIB)
 	$(CC) -o $@ $^
@@ -24,6 +25,12 @@ hash_tester_i2c: hash_tester.o $(LIB)
 trng_tester_i2c: trng_tester.o $(LIB)
 	$(CC) -o $@ $^
 
+aes_tester_i2c: aes_tester.o $(LIB)
+	$(CC) -o $@ $^
+
+modexp_tester_i2c: modexp_tester.o $(LIB)
+	$(CC) -o $@ $^
+
 hash_i2c: hash.o $(LIB)
 	$(CC) -o $@ $^
 
diff --git a/sw/configure-fpga.sh b/sw/configure-fpga.sh
new file mode 100644
index 0000000..7ebfb6b
--- /dev/null
+++ b/sw/configure-fpga.sh
@@ -0,0 +1,13 @@
+#!/bin/sh -
+bitfile="${1-novena_eim.bit}"
+echo "Setting export of reset pin"
+echo 135 > /sys/class/gpio/export
+echo "setting reset pin to out"
+echo out > /sys/class/gpio/gpio135/direction
+echo "flipping reset"                       
+echo 0 > /sys/class/gpio/gpio135/value
+echo 1 > /sys/class/gpio/gpio135/value
+echo "configuring FPGA"               
+dd if=${bitfile} of=/dev/spidev2.0 bs=128
+echo "turning on clock to FPGA"                              
+devmem3 0x020c8160 w 0x00000D2B
diff --git a/sw/cryptech.h b/sw/cryptech.h
index 9535061..8a7361f 100644
--- a/sw/cryptech.h
+++ b/sw/cryptech.h
@@ -400,6 +400,37 @@ in order to map it into a 16-bit address space.
 #define MODEXP_NAME1            "xp  "
 #define MODEXP_VERSION          "0.51"
 
+// Experimental ModexpS6 core.
+// XXX AT THE SAME CORE PREFIX - YOU CAN'T HAVE BOTH AT THE SAME TIME
+#define MODEXPS6_ADDR_BASE           SEGMENT_OFFSET_MATH + (0x00 * CORE_SIZE)
+#define MODEXPS6_ADDR_NAME0          MODEXPS6_ADDR_BASE + ADDR_NAME0
+#define MODEXPS6_ADDR_NAME1          MODEXPS6_ADDR_BASE + ADDR_NAME1
+#define MODEXPS6_ADDR_VERSION        MODEXPS6_ADDR_BASE + ADDR_VERSION
+#define MODEXPS6_ADDR_CTRL           MODEXPS6_ADDR_BASE + ADDR_CTRL
+#define MODEXPS6_CTRL_INIT_BIT       1
+#define MODEXPS6_CTRL_NEXT_BIT       2
+#define MODEXPS6_ADDR_STATUS         MODEXPS6_ADDR_BASE + ADDR_STATUS
+
+/* 4096-bit operands are stored as 128 words of 32 bits */
+#define MODEXPS6_OPERAND_SIZE        4096/32
+
+#define MODEXPS6_ADDR_REGISTERS      MODEXPS6_ADDR_BASE + 0*MODEXPS6_OPERAND_SIZE
+#define MODEXPS6_ADDR_OPERANDS       MODEXPS6_ADDR_BASE + 4*MODEXPS6_OPERAND_SIZE
+
+#define MODEXPS6_ADDR_MODE           MODEXPS6_ADDR_REGISTERS + 0x10
+#define MODEXPS6_ADDR_MODULUS_WIDTH  MODEXPS6_ADDR_REGISTERS + 0x11
+#define MODEXPS6_ADDR_EXPONENT_WIDTH MODEXPS6_ADDR_REGISTERS + 0x12
+
+/* addresses of block memories for operands */
+#define MODEXPS6_ADDR_MODULUS        MODEXPS6_ADDR_OPERANDS + 0*MODEXPS6_OPERAND_SIZE
+#define MODEXPS6_ADDR_MESSAGE        MODEXPS6_ADDR_OPERANDS + 1*MODEXPS6_OPERAND_SIZE
+#define MODEXPS6_ADDR_EXPONENT       MODEXPS6_ADDR_OPERANDS + 2*MODEXPS6_OPERAND_SIZE
+#define MODEXPS6_ADDR_RESULT         MODEXPS6_ADDR_OPERANDS + 3*MODEXPS6_OPERAND_SIZE
+
+#define MODEXPS6_NAME0            "mode"
+#define MODEXPS6_NAME1            "xps6"
+#define MODEXPS6_VERSION          "0.10"
+
 
 //------------------------------------------------------------------
 // Test case public functions
diff --git a/sw/devmem3.c b/sw/devmem3.c
new file mode 100644
index 0000000..3c3fa16
--- /dev/null
+++ b/sw/devmem3.c
@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "novena-eim.h"
+
+int
+main(int argc, char *argv[])
+{
+    off_t offset;
+    uint32_t value, result;
+
+    if (argc < 3 || argc > 4) {
+    usage:
+	fprintf(stderr, "usage: %s offset r\n", argv[0]);
+	fprintf(stderr, "usage: %s offset w value\n", argv[0]);
+	exit(EXIT_FAILURE);
+    }
+
+    if (eim_setup() != 0) {
+        fprintf(stderr, "EIM setup failed\n");
+	exit(EXIT_FAILURE);
+    }
+
+    offset = (off_t)strtoul(argv[1], NULL, 0);
+    if (argv[2][0] == 'r') {
+	eim_read_32(offset, &result);
+	printf("%08x\n", result);
+    }
+    else if (argv[2][0] == 'w') {
+	value = strtoul(argv[3], NULL, 0);
+	eim_write_32(offset, &value);
+    }
+    else {
+	fprintf(stderr, "unknown command '%s'\n", argv[2]);
+	goto usage;
+    }
+
+    exit(EXIT_SUCCESS);
+}
+
diff --git a/sw/modexps6_tester.c b/sw/modexps6_tester.c
new file mode 100644
index 0000000..a9e3b74
--- /dev/null
+++ b/sw/modexps6_tester.c
@@ -0,0 +1,650 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <ctype.h>
+#include <signal.h>
+#include <assert.h>
+
+#include "cryptech.h"
+#include "test-rsa.h"
+#include "test-modexp-for-pavel.h"
+
+int quiet = 0;
+int repeat = 0;
+
+int tc_width(off_t offset, uint32_t length)
+{
+  length = htonl(length);	// !
+	
+  uint8_t width[4];
+  memcpy(width, &length, 4);
+	
+  return tc_write(offset, width, sizeof(width));
+}
+
+/*
+ * Utility to madly swap 32-bit words within an operand so that the
+ * first word becomes the last word and so forth.
+ */
+
+static void two_card_monty(void *output, const void * const input, const size_t byte_count)
+{
+  const size_t word_count = byte_count / 4;
+  const uint32_t * const i32 = input;
+  uint32_t * const o32 = output;
+  int i;
+
+  assert(byte_count % 4 == 0);
+
+  for (i = 0; i < word_count; i++)
+    o32[i] = i32[word_count - i - 1];
+}
+
+/*
+ * Clone operand into a reversed buffer.  Necessary lack of curly
+ * braces makes this unsuitable for use in library code, but it
+ * simplifies test setup here.
+ */
+
+#define clone_reversed(_clone, _orig)		\
+  uint8_t _clone[sizeof(_orig)];		\
+  two_card_monty(_clone, _orig, sizeof(_orig))
+
+
+/* TC0: Read name and version from ModExpS6 core. */
+int TC0(void)
+{
+  uint8_t name0[4]   = { 'm', 'o', 'd', 'e'};
+  uint8_t name1[4]   = { 'x', 'p', 's', '6'};
+  uint8_t version[4] = { '0', '.', '1', '0'};
+
+  if (!quiet)
+    printf("TC0: Reading name and version words from ModExpS6 core.\n");
+
+  return
+    tc_expected(MODEXPS6_ADDR_NAME0, name0, sizeof(name0)) ||
+    tc_expected(MODEXPS6_ADDR_NAME1, name1, sizeof(name1)) ||
+    tc_expected(MODEXPS6_ADDR_VERSION, version, sizeof(version));
+}
+
+/* TC1: Fast single 1024-bit message. */
+int TC1(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC1: Sign 1024-bit message (fast & unsafe public mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_1024);
+  clone_reversed(message,  m_1024);
+  clone_reversed(exponent, d_1024);
+  clone_reversed(result,   s_1024);
+
+  /* Set fast mode */
+  /*uint8_t mode_slow_secure[] = {0, 0, 0, 0};*/
+  uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};
+  tc_write(MODEXPS6_ADDR_MODE, mode_fast_unsafe, sizeof(mode_fast_unsafe));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC2: Slow single 1024-bit message. */
+int TC2(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC2: Sign 1024-bit message (slow & secure private mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_1024);
+  clone_reversed(message,  m_1024);
+  clone_reversed(exponent, d_1024);
+  clone_reversed(result,   s_1024);
+
+  /* Set slow mode */
+  uint8_t mode_slow_secure[] = {0, 0, 0, 0};
+  /*uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};*/
+  tc_write(MODEXPS6_ADDR_MODE, mode_slow_secure, sizeof(mode_slow_secure));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC3: Fast single 2048-bit message. */
+int TC3(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC3: Sign 2048-bit message (fast & unsafe public mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_2048);
+  clone_reversed(message,  m_2048);
+  clone_reversed(exponent, d_2048);
+  clone_reversed(result,   s_2048);
+
+  /* Set fast mode */
+  /*uint8_t mode_slow_secure[] = {0, 0, 0, 0};*/
+  uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};
+  tc_write(MODEXPS6_ADDR_MODE, mode_fast_unsafe, sizeof(mode_fast_unsafe));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC4: Slow single 2048-bit message. */
+int TC4(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC4: Sign 2048-bit message (slow & secure private mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_2048);
+  clone_reversed(message,  m_2048);
+  clone_reversed(exponent, d_2048);
+  clone_reversed(result,   s_2048);
+
+  /* Set slow mode */
+  uint8_t mode_slow_secure[] = {0, 0, 0, 0};
+  /*uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};*/
+  tc_write(MODEXPS6_ADDR_MODE, mode_slow_secure, sizeof(mode_slow_secure));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC5: Fast single 4096-bit message. */
+int TC5(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC5: Sign 4096-bit message (fast & unsafe public mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_4096);
+  clone_reversed(message,  m_4096);
+  clone_reversed(exponent, d_4096);
+  clone_reversed(result,   s_4096);
+
+  /* Set fast mode */
+  /*uint8_t mode_slow_secure[] = {0, 0, 0, 0};*/
+  uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};
+  tc_write(MODEXPS6_ADDR_MODE, mode_fast_unsafe, sizeof(mode_fast_unsafe));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC6: Slow single 4096-bit message. */
+int TC6(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC6: Sign 4096-bit message (slow & secure private mode).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_4096);
+  clone_reversed(message,  m_4096);
+  clone_reversed(exponent, d_4096);
+  clone_reversed(result,   s_4096);
+
+  /* Set slow mode */
+  uint8_t mode_slow_secure[] = {0, 0, 0, 0};
+  /*uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};*/
+  tc_write(MODEXPS6_ADDR_MODE, mode_slow_secure, sizeof(mode_slow_secure));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+/* TC7: Signing of multiple 1024-bit messages with same key. */
+int TC7(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC7: Sign several 1024-bit messages (without pre-calculation every time).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,   n_1024);
+  clone_reversed(exponent,  d_1024);
+  clone_reversed(message_0, m_1024_0);
+  clone_reversed(message_1, m_1024_1);
+  clone_reversed(message_2, m_1024_2);
+  clone_reversed(message_3, m_1024_3);
+  clone_reversed(result_0,  s_1024_0);
+  clone_reversed(result_1,  s_1024_1);
+  clone_reversed(result_2,  s_1024_2);
+  clone_reversed(result_3,  s_1024_3);
+		
+  /* Set fast mode */
+  /*uint8_t mode_slow_secure[] = {0, 0, 0, 0};*/
+  uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};
+  tc_write(MODEXPS6_ADDR_MODE, mode_fast_unsafe, sizeof(mode_fast_unsafe));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Set new exponent length */
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, sizeof(exponent) * 8);	// number of bits
+
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));	
+	
+  {
+    /* Write new message #0 */
+    tc_write(MODEXPS6_ADDR_MESSAGE, message_0, sizeof(message_0));
+	
+    /* Start calculation */
+    tc_next(MODEXPS6_ADDR_CTRL);
+	
+    /* Wait while core is calculating */
+    tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+    /* Compare actual result with expected value */
+    ret = tc_expected(MODEXPS6_ADDR_RESULT, result_0, sizeof(result_0));
+    if (ret) return 1;
+  }
+  {
+    /* Write new message #1 */
+    tc_write(MODEXPS6_ADDR_MESSAGE, message_1, sizeof(message_1));
+	
+    /* Start calculation */
+    tc_next(MODEXPS6_ADDR_CTRL);
+	
+    /* Wait while core is calculating */
+    tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+    /* Compare actual result with expected value */
+    ret = tc_expected(MODEXPS6_ADDR_RESULT, result_1, sizeof(result_1));
+    if (ret) return 1;
+  }
+  {
+    /* Write new message #2 */
+    tc_write(MODEXPS6_ADDR_MESSAGE, message_2, sizeof(message_2));
+	
+    /* Start calculation */
+    tc_next(MODEXPS6_ADDR_CTRL);
+	
+    /* Wait while core is calculating */
+    tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+    /* Compare actual result with expected value */
+    ret = tc_expected(MODEXPS6_ADDR_RESULT, result_2, sizeof(result_2));
+    if (ret) return 1;
+  }
+  {
+    /* Write new message #3 */
+    tc_write(MODEXPS6_ADDR_MESSAGE, message_3, sizeof(message_3));
+	
+    /* Start calculation */
+    tc_next(MODEXPS6_ADDR_CTRL);
+	
+    /* Wait while core is calculating */
+    tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+    /* Compare actual result with expected value */
+    ret = tc_expected(MODEXPS6_ADDR_RESULT, result_3, sizeof(result_3));
+    if (ret) return 1;
+  }
+	
+  return 0;
+}
+
+/* TC8: Fast 4096-bit message verification. */
+int TC8(void)
+{
+  int ret;
+		
+  if (!quiet)
+    printf("TC8: Verify 4096-bit message (fast mode using public exponent).\n");
+
+  /* Change order of 32-bit words for all the operands (first word becomes last word, and so on...) */
+  clone_reversed(modulus,  n_4096);
+  clone_reversed(message,  s_4096);
+  clone_reversed(exponent, e_4096);
+  clone_reversed(result,   m_4096);
+		
+  /* Set fast mode */
+  /*uint8_t mode_slow_secure[] = {0, 0, 0, 0};*/
+  uint8_t mode_fast_unsafe[] = {0, 0, 0, 1};
+  tc_write(MODEXPS6_ADDR_MODE, mode_fast_unsafe, sizeof(mode_fast_unsafe));
+	
+  /* Set new modulus size */
+  tc_width(MODEXPS6_ADDR_MODULUS_WIDTH, sizeof(modulus) * 8);	// number of bits
+	
+  /* Write new modulus */
+  tc_write(MODEXPS6_ADDR_MODULUS, modulus, sizeof(modulus));
+	
+  /* Pre-calculate speed-up coefficient */
+  tc_init(MODEXPS6_ADDR_CTRL);
+
+  /* Wait while core is calculating */
+  tc_wait_ready(MODEXPS6_ADDR_STATUS);
+	
+  /* Write new message */
+  tc_write(MODEXPS6_ADDR_MESSAGE, message, sizeof(message));
+	
+  /* Set new exponent length */
+#if 1
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, 18);	// number of bits
+#else
+  tc_width(MODEXPS6_ADDR_EXPONENT_WIDTH, 24);	// number of bits
+#endif
+	
+  /* Write new exponent */
+  tc_write(MODEXPS6_ADDR_EXPONENT, exponent, sizeof(exponent));
+	
+  /* Start calculation */
+  tc_next(MODEXPS6_ADDR_CTRL);
+	
+  /* Wait while core is calculating */
+  tc_wait_valid(MODEXPS6_ADDR_STATUS);	
+	
+  /* Compare actual result with expected value */
+  ret = tc_expected(MODEXPS6_ADDR_RESULT, result, sizeof(result));
+	
+  return ret;
+}
+
+
+/* signal handler for ctrl-c to end repeat testing */
+unsigned long iter = 0;
+struct timeval tv_start, tv_end;
+void sighandler(int unused)
+{
+  double tv_diff;
+
+  gettimeofday(&tv_end, NULL);
+  tv_diff = (double)(tv_end.tv_sec - tv_start.tv_sec) +
+    (double)(tv_end.tv_usec - tv_start.tv_usec)/1000000;
+  printf("\n%lu iterations in %.3f seconds (%.3f iterations/sec)\n",
+	 iter, tv_diff, (double)iter/tv_diff);
+  exit(EXIT_SUCCESS);
+}
+
+int main(int argc, char *argv[])
+{
+  typedef int (*tcfp)(void);
+  tcfp all_tests[] = { TC0, TC1, TC2, TC3, TC4, TC5, TC6, TC7, TC8 };
+
+  char *usage = "Usage: %s [-h] [-d] [-q] [-r] tc...\n";
+  int i, j, opt;
+
+  while ((opt = getopt(argc, argv, "h?dqr")) != -1) {
+    switch (opt) {
+    case 'h':
+    case '?':
+      printf(usage, argv[0]);
+      return EXIT_SUCCESS;
+    case 'd':
+      tc_set_debug(1);
+      break;
+    case 'q':
+      quiet = 1;
+      break;
+    case 'r':
+      repeat = 1;
+      break;
+    default:
+      fprintf(stderr, usage, argv[0]);
+      return EXIT_FAILURE;
+    }
+  }
+
+  /* repeat one test until interrupted */
+  if (repeat) {
+    tcfp tc;
+    if (optind != argc - 1) {
+      fprintf(stderr, "only one test case can be repeated\n");
+      return EXIT_FAILURE;
+    }
+    j = atoi(argv[optind]);
+    if (j < 0 || j >= sizeof(all_tests)/sizeof(all_tests[0])) {
+      fprintf(stderr, "invalid test number %s\n", argv[optind]);
+      return EXIT_FAILURE;
+    }
+    tc = (all_tests[j]);
+    srand(time(NULL));
+    signal(SIGINT, sighandler);
+    gettimeofday(&tv_start, NULL);
+    while (1) {
+      ++iter;
+      if ((iter & 0xffff) == 0) {
+	printf(".");
+	fflush(stdout);
+      }
+      if (tc() != 0)
+	sighandler(0);
+    }
+    return EXIT_SUCCESS;    /*NOTREACHED*/
+  }
+
+  /* no args == run all tests */
+  if (optind >= argc) {
+    for (j = 0; j < sizeof(all_tests)/sizeof(all_tests[0]); ++j)
+      if (all_tests[j]() != 0)
+	return EXIT_FAILURE;
+    return EXIT_SUCCESS;
+  }
+
+  /* run one or more tests (by number) or groups of tests (by name) */
+  for (i = optind; i < argc; ++i) {
+    if (strcmp(argv[i], "all") == 0) {
+      for (j = 0; j < sizeof(all_tests)/sizeof(all_tests[0]); ++j)
+	if (all_tests[j]() != 0)
+	  return EXIT_FAILURE;
+    }
+    else if (isdigit(argv[i][0]) &&
+	     (((j = atoi(argv[i])) >= 0) &&
+	      (j < sizeof(all_tests)/sizeof(all_tests[0])))) {
+      if (all_tests[j]() != 0)
+	return EXIT_FAILURE;
+    }
+    else {
+      fprintf(stderr, "unknown test case %s\n", argv[i]);
+      return EXIT_FAILURE;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/sw/test-modexp-for-pavel.h b/sw/test-modexp-for-pavel.h
new file mode 100644
index 0000000..79889ee
--- /dev/null
+++ b/sw/test-modexp-for-pavel.h
@@ -0,0 +1,140 @@
+/*
+ * Test vectors.  First should be same as in test-rsa.h, for check.
+ */
+
+/*
+ * Message #0
+ * Plaintext: "You can hack anything you want with TECO and DDT."
+ * SHA-256: 8e36fc9aa31724c32416263c0366a175fabbb92b741ca6496107074d0343b597
+ */
+
+static const uint8_t m_1024_0[] = { /* message to be signed, 128 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x8e, 0x36, 0xfc, 0x9a, 0xa3, 0x17, 0x24, 0xc3, 0x24, 0x16, 0x26, 0x3c,
+  0x03, 0x66, 0xa1, 0x75, 0xfa, 0xbb, 0xb9, 0x2b, 0x74, 0x1c, 0xa6, 0x49,
+  0x61, 0x07, 0x07, 0x4d, 0x03, 0x43, 0xb5, 0x97
+};
+
+static const uint8_t s_1024_0[] = { /* signed message, 128 bytes */
+  0x3b, 0x09, 0xcc, 0x3d, 0x2f, 0xa1, 0x68, 0x1c, 0xa9, 0x29, 0x1b, 0xb7,
+  0xcf, 0xc9, 0xe7, 0xb4, 0xfd, 0x3e, 0x5a, 0x22, 0x1c, 0x29, 0xdf, 0x4a,
+  0x32, 0xcf, 0xa5, 0xae, 0x30, 0xd4, 0xee, 0x8f, 0x3a, 0xc8, 0xc1, 0xee,
+  0x79, 0x40, 0xb2, 0xbf, 0xc7, 0x12, 0x82, 0x73, 0x3c, 0x6b, 0x8a, 0xd1,
+  0xa4, 0x4a, 0x6d, 0x60, 0x9f, 0x00, 0xb4, 0x51, 0x8b, 0x6c, 0xcd, 0xae,
+  0xad, 0xf4, 0x0a, 0x48, 0xd5, 0xb9, 0x4b, 0x9e, 0xca, 0x77, 0x10, 0xc2,
+  0x9b, 0x26, 0x8c, 0x65, 0x17, 0x96, 0xd0, 0xc7, 0x5e, 0x55, 0x20, 0x17,
+  0x06, 0x74, 0x2d, 0x94, 0xe0, 0xfc, 0x09, 0xa2, 0xb1, 0x94, 0xe4, 0x83,
+  0x0d, 0x8d, 0x9e, 0x26, 0x0a, 0x25, 0x93, 0xfb, 0xef, 0x4f, 0xb3, 0x0e,
+  0x7a, 0x9b, 0x2f, 0x17, 0x94, 0xd8, 0xca, 0x64, 0x1e, 0xa6, 0x2e, 0xc9,
+  0xf3, 0x54, 0x87, 0x34, 0xed, 0xf7, 0xa5, 0x00
+};
+
+/*
+ * Message #1
+ * Plaintext: "$U in and begin to hack."
+ * SHA-256: 6592ba987edef196b98beed2f618198b109ad93d9a32939e2134863f4f7aff4a
+ */
+
+static const uint8_t m_1024_1[] = { /* message to be signed, 128 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x65, 0x92, 0xba, 0x98, 0x7e, 0xde, 0xf1, 0x96, 0xb9, 0x8b, 0xee, 0xd2,
+  0xf6, 0x18, 0x19, 0x8b, 0x10, 0x9a, 0xd9, 0x3d, 0x9a, 0x32, 0x93, 0x9e,
+  0x21, 0x34, 0x86, 0x3f, 0x4f, 0x7a, 0xff, 0x4a
+};
+
+static const uint8_t s_1024_1[] = { /* signed message, 128 bytes */
+  0x30, 0x23, 0x3d, 0x81, 0xa0, 0xa5, 0xc3, 0xcc, 0x48, 0xb2, 0x69, 0xe6,
+  0xe8, 0xb1, 0xc7, 0x34, 0xed, 0x56, 0xc6, 0x3b, 0xfb, 0xfe, 0x2f, 0xba,
+  0x1d, 0xa5, 0x3f, 0x18, 0xa8, 0xb9, 0xd6, 0x80, 0x2f, 0x30, 0x39, 0x54,
+  0x00, 0xed, 0x1b, 0x54, 0x4e, 0x28, 0x90, 0xc6, 0xe6, 0x58, 0x43, 0x1b,
+  0x84, 0x94, 0x59, 0x46, 0xc2, 0xb3, 0x22, 0x38, 0x49, 0xf9, 0x2a, 0x7f,
+  0xfc, 0xef, 0xe7, 0xb4, 0x6e, 0x77, 0xf9, 0x9c, 0x41, 0x79, 0x65, 0x72,
+  0x18, 0xa4, 0xb6, 0x98, 0x28, 0x98, 0xba, 0xfe, 0xdc, 0x71, 0x8f, 0x58,
+  0x2f, 0x6d, 0x25, 0x67, 0x35, 0x23, 0x6a, 0x98, 0xbb, 0xfa, 0x3b, 0x13,
+  0x3b, 0x6f, 0x4b, 0x2a, 0x1e, 0x59, 0x7b, 0x0b, 0x62, 0x45, 0xe2, 0x4e,
+  0xc1, 0x9d, 0x66, 0x38, 0x71, 0xca, 0xcf, 0x91, 0x66, 0x7d, 0x81, 0xf4,
+  0x78, 0x68, 0x41, 0x08, 0xd1, 0xad, 0xda, 0xf0
+};
+
+/*
+ * Message #2
+ * Plaintext: "Twiddle bits in a core dump and write 'em back."
+ * SHA-256: 0633b9805544473dd4169773ff708f3868eb7f0ecbda0349012ea6ff7798b7b4
+ */
+
+static const uint8_t m_1024_2[] = { /* message to be signed, 128 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x06, 0x33, 0xb9, 0x80, 0x55, 0x44, 0x47, 0x3d, 0xd4, 0x16, 0x97, 0x73,
+  0xff, 0x70, 0x8f, 0x38, 0x68, 0xeb, 0x7f, 0x0e, 0xcb, 0xda, 0x03, 0x49,
+  0x01, 0x2e, 0xa6, 0xff, 0x77, 0x98, 0xb7, 0xb4
+};
+
+static const uint8_t s_1024_2[] = { /* signed message, 128 bytes */
+  0x6b, 0x29, 0x54, 0xa3, 0x05, 0x5a, 0x92, 0xa5, 0x65, 0x00, 0x72, 0x3a,
+  0xdf, 0x85, 0x11, 0x47, 0x96, 0x7f, 0x67, 0x38, 0xf0, 0xae, 0x06, 0xe4,
+  0x7e, 0x99, 0xc3, 0x17, 0x85, 0x7d, 0x03, 0xbe, 0xf8, 0xae, 0x1e, 0x89,
+  0x99, 0x9e, 0x03, 0xb3, 0xe0, 0xfb, 0x15, 0xce, 0xed, 0x11, 0x21, 0xc4,
+  0x20, 0x0d, 0x35, 0x84, 0xcc, 0xba, 0x53, 0xe0, 0x88, 0x5b, 0xa6, 0x25,
+  0xdb, 0xa5, 0x6e, 0x4f, 0x06, 0xce, 0x81, 0xf7, 0x15, 0x15, 0x54, 0x15,
+  0x11, 0x0d, 0x67, 0x73, 0x08, 0xd0, 0x15, 0x22, 0x8d, 0xef, 0x46, 0xda,
+  0x61, 0x29, 0xc6, 0xe7, 0x37, 0x63, 0x2d, 0x0a, 0x82, 0x79, 0x17, 0xed,
+  0xf4, 0x07, 0x79, 0xa2, 0x56, 0xb2, 0xbb, 0xf5, 0x4a, 0x40, 0x34, 0xec,
+  0x9a, 0x92, 0x8f, 0xd4, 0x66, 0xc1, 0x83, 0xe0, 0x45, 0xa8, 0xe6, 0x4e,
+  0x52, 0xb1, 0x11, 0xe9, 0x17, 0xc0, 0xcb, 0x5c
+};
+
+/*
+ * Message #3
+ * Plaintext: "(But be careful typing <RET>)"
+ * SHA-256: 524bb716e35f7ca6e54fa59c75e395d4e6a9a567e2c928aa34c7ef7b09ed7b45
+ */
+
+static const uint8_t m_1024_3[] = { /* message to be signed, 128 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x52, 0x4b, 0xb7, 0x16, 0xe3, 0x5f, 0x7c, 0xa6, 0xe5, 0x4f, 0xa5, 0x9c,
+  0x75, 0xe3, 0x95, 0xd4, 0xe6, 0xa9, 0xa5, 0x67, 0xe2, 0xc9, 0x28, 0xaa,
+  0x34, 0xc7, 0xef, 0x7b, 0x09, 0xed, 0x7b, 0x45
+};
+
+static const uint8_t s_1024_3[] = { /* signed message, 128 bytes */
+  0x56, 0x20, 0xa9, 0xd5, 0x0e, 0x61, 0xa4, 0xb6, 0xfc, 0x8a, 0xf6, 0x27,
+  0x40, 0x3c, 0x8c, 0x7a, 0x3f, 0x27, 0xdb, 0x1e, 0xb8, 0xf7, 0xf1, 0x35,
+  0x21, 0xbc, 0xcd, 0x0d, 0xd9, 0x39, 0x98, 0x40, 0x1c, 0x48, 0x19, 0x85,
+  0x57, 0xed, 0xa2, 0x59, 0x9d, 0xef, 0x13, 0x4c, 0xe7, 0x9e, 0x8b, 0x15,
+  0x66, 0xce, 0xbf, 0x57, 0xcf, 0x43, 0x00, 0xf4, 0xb3, 0xf4, 0x6b, 0xcd,
+  0x77, 0x34, 0xdd, 0xbd, 0x13, 0xdf, 0xe7, 0xf5, 0xb1, 0xe7, 0xa0, 0x2c,
+  0xfc, 0x03, 0x00, 0x33, 0x78, 0x51, 0x28, 0x0c, 0x7c, 0x8a, 0x8b, 0xaa,
+  0x8d, 0xb2, 0x72, 0x43, 0x54, 0x19, 0xf2, 0xf2, 0x53, 0xba, 0x16, 0x64,
+  0x65, 0x69, 0xbd, 0xc4, 0x26, 0x08, 0xa2, 0x12, 0x4d, 0xbd, 0x6f, 0x9d,
+  0x2f, 0x9d, 0x34, 0x41, 0xa8, 0x5f, 0x92, 0xa1, 0xc8, 0xa4, 0x27, 0xa8,
+  0x34, 0x26, 0x3d, 0x4e, 0x6d, 0xc4, 0x0e, 0x66
+};
+
diff --git a/sw/test-rsa.h b/sw/test-rsa.h
new file mode 100644
index 0000000..400ffd0
--- /dev/null
+++ b/sw/test-rsa.h
@@ -0,0 +1,746 @@
+/*
+ * RSA signature test data for Cryptech project, automatically generated by
+ * test-rsa.py using PyCrypto version 2.6.1. Do not edit.
+ *
+ * Plaintext: "You can hack anything you want with TECO and DDT."
+ * SHA-256: 8e36fc9aa31724c32416263c0366a175fabbb92b741ca6496107074d0343b597
+ */
+
+/* 1024-bit RSA private key (PKCS #8)
+-----BEGIN PRIVATE KEY-----
+MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIwSaEpCTVJvbd4Z
+B1P8H9EgFlZqats7PeBIOlC2Q1zla7wBmNJkX5Jkez8tF3l22Sn99c6c6PuhyhzB
+dZtifQbZniKCJEzyby5MXZeSr20rPdrqiB9FX13mmtLN7ii4nLyAYFAQ4R8ZvdH2
+dRIWtxwhS7d4AyrWYhJkemIvSApfAgMBAAECgYAmL1Zy+AQwNuRSqawPvynFTuQI
+Bta+kTXbEJWlLyrKBlkKVb0djfNn6zCWFmrR2A53nh4Gh0wUXRTGJg8znvPKJPcp
+45znc7aGQFmDivvl5m/UkbqET6SB6JyCOCKzYa1Rtn3YFMkf/3MgzrWIhFv+UNH/
+I5lSjzJcCrN4mgI+AQJBALcTNa0mOWRXX+6jssbf65Cx6wmHsrrptXiP9gKfwdkx
+697EzyvPDL8xwL20O+xBFehj866O/f8nOPP47imOPoECQQDD3gU8wD8MeWLqYcXI
+AdERIuuk1VnL36QOzn9NoPF01DLJcrcbN24i5/9tcza3Kdec8fexJTh/PMBvR8Zr
+w5jfAkAnFgrXtNl7+suYf4qjuxroAZRUrIwUK+F6pAG5/bG9VVMudIZmrAXkrBKi
+beB9SEgNHYnhMtY3q4AVVohChwQBAkAR1I5Jf3691fcJOylUEcZEdxdYhAuOoac/
+qdCw8mvIpOCSshy1H5CpINGB1zEt72MvaF+SAr9n5dHmz3Pir4WlAkB/ZccJ5QBH
+uBP0/flXdmhG5lC3MTMiiE7Rls/3L2t6S4xVDnQ81RYf7Car53WN7qSVSZnhDGsn
+BJpghq2nYUH1
+-----END PRIVATE KEY-----
+*/
+
+static const uint8_t n_1024[] = { /* key component n, 128 bytes */
+  0x8c, 0x12, 0x68, 0x4a, 0x42, 0x4d, 0x52, 0x6f, 0x6d, 0xde, 0x19, 0x07,
+  0x53, 0xfc, 0x1f, 0xd1, 0x20, 0x16, 0x56, 0x6a, 0x6a, 0xdb, 0x3b, 0x3d,
+  0xe0, 0x48, 0x3a, 0x50, 0xb6, 0x43, 0x5c, 0xe5, 0x6b, 0xbc, 0x01, 0x98,
+  0xd2, 0x64, 0x5f, 0x92, 0x64, 0x7b, 0x3f, 0x2d, 0x17, 0x79, 0x76, 0xd9,
+  0x29, 0xfd, 0xf5, 0xce, 0x9c, 0xe8, 0xfb, 0xa1, 0xca, 0x1c, 0xc1, 0x75,
+  0x9b, 0x62, 0x7d, 0x06, 0xd9, 0x9e, 0x22, 0x82, 0x24, 0x4c, 0xf2, 0x6f,
+  0x2e, 0x4c, 0x5d, 0x97, 0x92, 0xaf, 0x6d, 0x2b, 0x3d, 0xda, 0xea, 0x88,
+  0x1f, 0x45, 0x5f, 0x5d, 0xe6, 0x9a, 0xd2, 0xcd, 0xee, 0x28, 0xb8, 0x9c,
+  0xbc, 0x80, 0x60, 0x50, 0x10, 0xe1, 0x1f, 0x19, 0xbd, 0xd1, 0xf6, 0x75,
+  0x12, 0x16, 0xb7, 0x1c, 0x21, 0x4b, 0xb7, 0x78, 0x03, 0x2a, 0xd6, 0x62,
+  0x12, 0x64, 0x7a, 0x62, 0x2f, 0x48, 0x0a, 0x5f
+};
+
+static const uint8_t e_1024[] = { /* key component e, 4 bytes */
+  0x00, 0x01, 0x00, 0x01
+};
+
+static const uint8_t d_1024[] = { /* key component d, 128 bytes */
+  0x26, 0x2f, 0x56, 0x72, 0xf8, 0x04, 0x30, 0x36, 0xe4, 0x52, 0xa9, 0xac,
+  0x0f, 0xbf, 0x29, 0xc5, 0x4e, 0xe4, 0x08, 0x06, 0xd6, 0xbe, 0x91, 0x35,
+  0xdb, 0x10, 0x95, 0xa5, 0x2f, 0x2a, 0xca, 0x06, 0x59, 0x0a, 0x55, 0xbd,
+  0x1d, 0x8d, 0xf3, 0x67, 0xeb, 0x30, 0x96, 0x16, 0x6a, 0xd1, 0xd8, 0x0e,
+  0x77, 0x9e, 0x1e, 0x06, 0x87, 0x4c, 0x14, 0x5d, 0x14, 0xc6, 0x26, 0x0f,
+  0x33, 0x9e, 0xf3, 0xca, 0x24, 0xf7, 0x29, 0xe3, 0x9c, 0xe7, 0x73, 0xb6,
+  0x86, 0x40, 0x59, 0x83, 0x8a, 0xfb, 0xe5, 0xe6, 0x6f, 0xd4, 0x91, 0xba,
+  0x84, 0x4f, 0xa4, 0x81, 0xe8, 0x9c, 0x82, 0x38, 0x22, 0xb3, 0x61, 0xad,
+  0x51, 0xb6, 0x7d, 0xd8, 0x14, 0xc9, 0x1f, 0xff, 0x73, 0x20, 0xce, 0xb5,
+  0x88, 0x84, 0x5b, 0xfe, 0x50, 0xd1, 0xff, 0x23, 0x99, 0x52, 0x8f, 0x32,
+  0x5c, 0x0a, 0xb3, 0x78, 0x9a, 0x02, 0x3e, 0x01
+};
+
+static const uint8_t p_1024[] = { /* key component p, 64 bytes */
+  0xb7, 0x13, 0x35, 0xad, 0x26, 0x39, 0x64, 0x57, 0x5f, 0xee, 0xa3, 0xb2,
+  0xc6, 0xdf, 0xeb, 0x90, 0xb1, 0xeb, 0x09, 0x87, 0xb2, 0xba, 0xe9, 0xb5,
+  0x78, 0x8f, 0xf6, 0x02, 0x9f, 0xc1, 0xd9, 0x31, 0xeb, 0xde, 0xc4, 0xcf,
+  0x2b, 0xcf, 0x0c, 0xbf, 0x31, 0xc0, 0xbd, 0xb4, 0x3b, 0xec, 0x41, 0x15,
+  0xe8, 0x63, 0xf3, 0xae, 0x8e, 0xfd, 0xff, 0x27, 0x38, 0xf3, 0xf8, 0xee,
+  0x29, 0x8e, 0x3e, 0x81
+};
+
+static const uint8_t q_1024[] = { /* key component q, 64 bytes */
+  0xc3, 0xde, 0x05, 0x3c, 0xc0, 0x3f, 0x0c, 0x79, 0x62, 0xea, 0x61, 0xc5,
+  0xc8, 0x01, 0xd1, 0x11, 0x22, 0xeb, 0xa4, 0xd5, 0x59, 0xcb, 0xdf, 0xa4,
+  0x0e, 0xce, 0x7f, 0x4d, 0xa0, 0xf1, 0x74, 0xd4, 0x32, 0xc9, 0x72, 0xb7,
+  0x1b, 0x37, 0x6e, 0x22, 0xe7, 0xff, 0x6d, 0x73, 0x36, 0xb7, 0x29, 0xd7,
+  0x9c, 0xf1, 0xf7, 0xb1, 0x25, 0x38, 0x7f, 0x3c, 0xc0, 0x6f, 0x47, 0xc6,
+  0x6b, 0xc3, 0x98, 0xdf
+};
+
+static const uint8_t dP_1024[] = { /* key component dP, 64 bytes */
+  0x27, 0x16, 0x0a, 0xd7, 0xb4, 0xd9, 0x7b, 0xfa, 0xcb, 0x98, 0x7f, 0x8a,
+  0xa3, 0xbb, 0x1a, 0xe8, 0x01, 0x94, 0x54, 0xac, 0x8c, 0x14, 0x2b, 0xe1,
+  0x7a, 0xa4, 0x01, 0xb9, 0xfd, 0xb1, 0xbd, 0x55, 0x53, 0x2e, 0x74, 0x86,
+  0x66, 0xac, 0x05, 0xe4, 0xac, 0x12, 0xa2, 0x6d, 0xe0, 0x7d, 0x48, 0x48,
+  0x0d, 0x1d, 0x89, 0xe1, 0x32, 0xd6, 0x37, 0xab, 0x80, 0x15, 0x56, 0x88,
+  0x42, 0x87, 0x04, 0x01
+};
+
+static const uint8_t dQ_1024[] = { /* key component dQ, 64 bytes */
+  0x11, 0xd4, 0x8e, 0x49, 0x7f, 0x7e, 0xbd, 0xd5, 0xf7, 0x09, 0x3b, 0x29,
+  0x54, 0x11, 0xc6, 0x44, 0x77, 0x17, 0x58, 0x84, 0x0b, 0x8e, 0xa1, 0xa7,
+  0x3f, 0xa9, 0xd0, 0xb0, 0xf2, 0x6b, 0xc8, 0xa4, 0xe0, 0x92, 0xb2, 0x1c,
+  0xb5, 0x1f, 0x90, 0xa9, 0x20, 0xd1, 0x81, 0xd7, 0x31, 0x2d, 0xef, 0x63,
+  0x2f, 0x68, 0x5f, 0x92, 0x02, 0xbf, 0x67, 0xe5, 0xd1, 0xe6, 0xcf, 0x73,
+  0xe2, 0xaf, 0x85, 0xa5
+};
+
+static const uint8_t u_1024[] = { /* key component u, 64 bytes */
+  0x7f, 0x65, 0xc7, 0x09, 0xe5, 0x00, 0x47, 0xb8, 0x13, 0xf4, 0xfd, 0xf9,
+  0x57, 0x76, 0x68, 0x46, 0xe6, 0x50, 0xb7, 0x31, 0x33, 0x22, 0x88, 0x4e,
+  0xd1, 0x96, 0xcf, 0xf7, 0x2f, 0x6b, 0x7a, 0x4b, 0x8c, 0x55, 0x0e, 0x74,
+  0x3c, 0xd5, 0x16, 0x1f, 0xec, 0x26, 0xab, 0xe7, 0x75, 0x8d, 0xee, 0xa4,
+  0x95, 0x49, 0x99, 0xe1, 0x0c, 0x6b, 0x27, 0x04, 0x9a, 0x60, 0x86, 0xad,
+  0xa7, 0x61, 0x41, 0xf5
+};
+
+static const uint8_t m_1024[] = { /* message to be signed, 128 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x8e, 0x36, 0xfc, 0x9a, 0xa3, 0x17, 0x24, 0xc3, 0x24, 0x16, 0x26, 0x3c,
+  0x03, 0x66, 0xa1, 0x75, 0xfa, 0xbb, 0xb9, 0x2b, 0x74, 0x1c, 0xa6, 0x49,
+  0x61, 0x07, 0x07, 0x4d, 0x03, 0x43, 0xb5, 0x97
+};
+
+static const uint8_t s_1024[] = { /* signed message, 128 bytes */
+  0x3b, 0x09, 0xcc, 0x3d, 0x2f, 0xa1, 0x68, 0x1c, 0xa9, 0x29, 0x1b, 0xb7,
+  0xcf, 0xc9, 0xe7, 0xb4, 0xfd, 0x3e, 0x5a, 0x22, 0x1c, 0x29, 0xdf, 0x4a,
+  0x32, 0xcf, 0xa5, 0xae, 0x30, 0xd4, 0xee, 0x8f, 0x3a, 0xc8, 0xc1, 0xee,
+  0x79, 0x40, 0xb2, 0xbf, 0xc7, 0x12, 0x82, 0x73, 0x3c, 0x6b, 0x8a, 0xd1,
+  0xa4, 0x4a, 0x6d, 0x60, 0x9f, 0x00, 0xb4, 0x51, 0x8b, 0x6c, 0xcd, 0xae,
+  0xad, 0xf4, 0x0a, 0x48, 0xd5, 0xb9, 0x4b, 0x9e, 0xca, 0x77, 0x10, 0xc2,
+  0x9b, 0x26, 0x8c, 0x65, 0x17, 0x96, 0xd0, 0xc7, 0x5e, 0x55, 0x20, 0x17,
+  0x06, 0x74, 0x2d, 0x94, 0xe0, 0xfc, 0x09, 0xa2, 0xb1, 0x94, 0xe4, 0x83,
+  0x0d, 0x8d, 0x9e, 0x26, 0x0a, 0x25, 0x93, 0xfb, 0xef, 0x4f, 0xb3, 0x0e,
+  0x7a, 0x9b, 0x2f, 0x17, 0x94, 0xd8, 0xca, 0x64, 0x1e, 0xa6, 0x2e, 0xc9,
+  0xf3, 0x54, 0x87, 0x34, 0xed, 0xf7, 0xa5, 0x00
+};
+
+/* 2048-bit RSA private key (PKCS #8)
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCzvgb90hKxeDJy
+zeWz/F4JGZ3Acl1i3url3VPXHyoldyhuNC+8jf4iM7TGBYGLH+sYkBXWu9GD0erl
+KBMJMTBO8OdXulSAJh8r1Z8qNPSVNguvNgGQlRDGc7tZJ6gWFlzM2g5flED24bN9
+6Ir9O1cZi7xMc0Nzkn9Rms5IwPW8OB4IZZlbFC6Ih9vUSp06Tm3rQ/eQJkhLFbzM
+ejc9OH1LSpYtji44ohmy/jPJsmSlzwK5JSchZqbxl/msVw1t/nZS3loqKUMvzn9F
+iARLiaIrUKNCmSmL8HqEt2qKt0ESHG0vX07h5W5iHIJOuKhqcX3li8nFcwsOV3AB
+RsCRgeppAgMBAAECggEANEeTVQRjN4dUdRv6Me23lEIFJlKdYwKfpBhKKIoCAj+0
+XMmFEPzj7CLJ88bqNQMlqFFQaNLcT9Eg12Jelw/dkzhysYuaxGNSMbfCwc4BTd0Y
+bO/yaJFS/cXvujDUrQf4GgVapOZENwrS4E5hDuLRpLaGIF5uQhFcQuoaEgM99m6H
+TzOIhtu3DjdbfSsmkGVQ7xUVFcvaCrMVoq06dvUH4HpYTKeeqgcVv++XjIe83Nzv
++oN5U2oFOzrYpGGHN6jrekmmbEaxy8UHOySC6Y+UyRrPEy9q1ZgkkC9VCrM7E28/
+4PETw8MI7uNoosuFXofctKjtRvC5Sn9zW3dyv9NkAQKBgQDSkdDy4+xN2kA7gdry
+4eLKUzKRNSbnoPrCu2TENUR8oTjbJ52LQEbGa9HIKaM33701hJsc34C6adJgoY9c
+PoBcJgxOI7N40A/rI3c8krKS5X/ViBY3TzJsP3LaBKDdfioaTDVTjhYD6v2eu7Lt
+4eIqa8sVA4PhLSVGRW53ZSYjwQKBgQDahY6cR8WgPseQJTkCbKyfKCSuz6nioZpC
+stkpKhJepzE6AKZTLLWvNIPNT/khl40aby5seLNkY3Tb9cYBX2iShGv4cguPMiAl
+hb7Uljz19i6YaX74gkTjsYpv44ddLSZp+/FTOl0C0I8WocQpb8B2d4BgvfxgHrHb
+KCHnyihQqQKBgQC7PKPixt7hnzdMcrxhCpDiPbaSPgQZJSC1NXJ1sbPzalynKwPA
+xefpGgiRBs02qsGRLBfNRcQuflhuSlqyuHTk+4Qnm0FEJSZyfLfS6dLWIjJYikjO
+56I7dPPIfyMXsM75UVh9srNKypK4qciCFEBKXk1XoyeKe91QLf77NbsDQQKBgDnY
+CLwNs56Lf8AEWmbt5XPr6GntxoabSH5HYXyoClzL3RgBfAWgXCeYuxrqBISD3XIV
+5DAKc1IrkY94K4XJf6DpNLt7VNv+5MuJ783ORyzEkej+ZAHcWef74y1jCT386aI8
+ctEZLe3Ez1uqToa5cjTpxS3WnKvE9EeTBAabWLihAoGBAKft+PG+j+QhZeHSGxRz
+mY6AQHH4z7IU94fmXiT2kTsG8/svhPNfsmVt7UCSJbCaYsrcuR2NonVV8wn/U793
+LcnLAV+WObeduMTBCasJw8IniFwFhhfkxOtmlevExE1I3ENwkRlJ7NdROky4pnd5
+LGmN2EOOlFijEGxBfw+Wb1rQ
+-----END PRIVATE KEY-----
+*/
+
+static const uint8_t n_2048[] = { /* key component n, 256 bytes */
+  0xb3, 0xbe, 0x06, 0xfd, 0xd2, 0x12, 0xb1, 0x78, 0x32, 0x72, 0xcd, 0xe5,
+  0xb3, 0xfc, 0x5e, 0x09, 0x19, 0x9d, 0xc0, 0x72, 0x5d, 0x62, 0xde, 0xea,
+  0xe5, 0xdd, 0x53, 0xd7, 0x1f, 0x2a, 0x25, 0x77, 0x28, 0x6e, 0x34, 0x2f,
+  0xbc, 0x8d, 0xfe, 0x22, 0x33, 0xb4, 0xc6, 0x05, 0x81, 0x8b, 0x1f, 0xeb,
+  0x18, 0x90, 0x15, 0xd6, 0xbb, 0xd1, 0x83, 0xd1, 0xea, 0xe5, 0x28, 0x13,
+  0x09, 0x31, 0x30, 0x4e, 0xf0, 0xe7, 0x57, 0xba, 0x54, 0x80, 0x26, 0x1f,
+  0x2b, 0xd5, 0x9f, 0x2a, 0x34, 0xf4, 0x95, 0x36, 0x0b, 0xaf, 0x36, 0x01,
+  0x90, 0x95, 0x10, 0xc6, 0x73, 0xbb, 0x59, 0x27, 0xa8, 0x16, 0x16, 0x5c,
+  0xcc, 0xda, 0x0e, 0x5f, 0x94, 0x40, 0xf6, 0xe1, 0xb3, 0x7d, 0xe8, 0x8a,
+  0xfd, 0x3b, 0x57, 0x19, 0x8b, 0xbc, 0x4c, 0x73, 0x43, 0x73, 0x92, 0x7f,
+  0x51, 0x9a, 0xce, 0x48, 0xc0, 0xf5, 0xbc, 0x38, 0x1e, 0x08, 0x65, 0x99,
+  0x5b, 0x14, 0x2e, 0x88, 0x87, 0xdb, 0xd4, 0x4a, 0x9d, 0x3a, 0x4e, 0x6d,
+  0xeb, 0x43, 0xf7, 0x90, 0x26, 0x48, 0x4b, 0x15, 0xbc, 0xcc, 0x7a, 0x37,
+  0x3d, 0x38, 0x7d, 0x4b, 0x4a, 0x96, 0x2d, 0x8e, 0x2e, 0x38, 0xa2, 0x19,
+  0xb2, 0xfe, 0x33, 0xc9, 0xb2, 0x64, 0xa5, 0xcf, 0x02, 0xb9, 0x25, 0x27,
+  0x21, 0x66, 0xa6, 0xf1, 0x97, 0xf9, 0xac, 0x57, 0x0d, 0x6d, 0xfe, 0x76,
+  0x52, 0xde, 0x5a, 0x2a, 0x29, 0x43, 0x2f, 0xce, 0x7f, 0x45, 0x88, 0x04,
+  0x4b, 0x89, 0xa2, 0x2b, 0x50, 0xa3, 0x42, 0x99, 0x29, 0x8b, 0xf0, 0x7a,
+  0x84, 0xb7, 0x6a, 0x8a, 0xb7, 0x41, 0x12, 0x1c, 0x6d, 0x2f, 0x5f, 0x4e,
+  0xe1, 0xe5, 0x6e, 0x62, 0x1c, 0x82, 0x4e, 0xb8, 0xa8, 0x6a, 0x71, 0x7d,
+  0xe5, 0x8b, 0xc9, 0xc5, 0x73, 0x0b, 0x0e, 0x57, 0x70, 0x01, 0x46, 0xc0,
+  0x91, 0x81, 0xea, 0x69
+};
+
+static const uint8_t e_2048[] = { /* key component e, 4 bytes */
+  0x00, 0x01, 0x00, 0x01
+};
+
+static const uint8_t d_2048[] = { /* key component d, 256 bytes */
+  0x34, 0x47, 0x93, 0x55, 0x04, 0x63, 0x37, 0x87, 0x54, 0x75, 0x1b, 0xfa,
+  0x31, 0xed, 0xb7, 0x94, 0x42, 0x05, 0x26, 0x52, 0x9d, 0x63, 0x02, 0x9f,
+  0xa4, 0x18, 0x4a, 0x28, 0x8a, 0x02, 0x02, 0x3f, 0xb4, 0x5c, 0xc9, 0x85,
+  0x10, 0xfc, 0xe3, 0xec, 0x22, 0xc9, 0xf3, 0xc6, 0xea, 0x35, 0x03, 0x25,
+  0xa8, 0x51, 0x50, 0x68, 0xd2, 0xdc, 0x4f, 0xd1, 0x20, 0xd7, 0x62, 0x5e,
+  0x97, 0x0f, 0xdd, 0x93, 0x38, 0x72, 0xb1, 0x8b, 0x9a, 0xc4, 0x63, 0x52,
+  0x31, 0xb7, 0xc2, 0xc1, 0xce, 0x01, 0x4d, 0xdd, 0x18, 0x6c, 0xef, 0xf2,
+  0x68, 0x91, 0x52, 0xfd, 0xc5, 0xef, 0xba, 0x30, 0xd4, 0xad, 0x07, 0xf8,
+  0x1a, 0x05, 0x5a, 0xa4, 0xe6, 0x44, 0x37, 0x0a, 0xd2, 0xe0, 0x4e, 0x61,
+  0x0e, 0xe2, 0xd1, 0xa4, 0xb6, 0x86, 0x20, 0x5e, 0x6e, 0x42, 0x11, 0x5c,
+  0x42, 0xea, 0x1a, 0x12, 0x03, 0x3d, 0xf6, 0x6e, 0x87, 0x4f, 0x33, 0x88,
+  0x86, 0xdb, 0xb7, 0x0e, 0x37, 0x5b, 0x7d, 0x2b, 0x26, 0x90, 0x65, 0x50,
+  0xef, 0x15, 0x15, 0x15, 0xcb, 0xda, 0x0a, 0xb3, 0x15, 0xa2, 0xad, 0x3a,
+  0x76, 0xf5, 0x07, 0xe0, 0x7a, 0x58, 0x4c, 0xa7, 0x9e, 0xaa, 0x07, 0x15,
+  0xbf, 0xef, 0x97, 0x8c, 0x87, 0xbc, 0xdc, 0xdc, 0xef, 0xfa, 0x83, 0x79,
+  0x53, 0x6a, 0x05, 0x3b, 0x3a, 0xd8, 0xa4, 0x61, 0x87, 0x37, 0xa8, 0xeb,
+  0x7a, 0x49, 0xa6, 0x6c, 0x46, 0xb1, 0xcb, 0xc5, 0x07, 0x3b, 0x24, 0x82,
+  0xe9, 0x8f, 0x94, 0xc9, 0x1a, 0xcf, 0x13, 0x2f, 0x6a, 0xd5, 0x98, 0x24,
+  0x90, 0x2f, 0x55, 0x0a, 0xb3, 0x3b, 0x13, 0x6f, 0x3f, 0xe0, 0xf1, 0x13,
+  0xc3, 0xc3, 0x08, 0xee, 0xe3, 0x68, 0xa2, 0xcb, 0x85, 0x5e, 0x87, 0xdc,
+  0xb4, 0xa8, 0xed, 0x46, 0xf0, 0xb9, 0x4a, 0x7f, 0x73, 0x5b, 0x77, 0x72,
+  0xbf, 0xd3, 0x64, 0x01
+};
+
+static const uint8_t p_2048[] = { /* key component p, 128 bytes */
+  0xd2, 0x91, 0xd0, 0xf2, 0xe3, 0xec, 0x4d, 0xda, 0x40, 0x3b, 0x81, 0xda,
+  0xf2, 0xe1, 0xe2, 0xca, 0x53, 0x32, 0x91, 0x35, 0x26, 0xe7, 0xa0, 0xfa,
+  0xc2, 0xbb, 0x64, 0xc4, 0x35, 0x44, 0x7c, 0xa1, 0x38, 0xdb, 0x27, 0x9d,
+  0x8b, 0x40, 0x46, 0xc6, 0x6b, 0xd1, 0xc8, 0x29, 0xa3, 0x37, 0xdf, 0xbd,
+  0x35, 0x84, 0x9b, 0x1c, 0xdf, 0x80, 0xba, 0x69, 0xd2, 0x60, 0xa1, 0x8f,
+  0x5c, 0x3e, 0x80, 0x5c, 0x26, 0x0c, 0x4e, 0x23, 0xb3, 0x78, 0xd0, 0x0f,
+  0xeb, 0x23, 0x77, 0x3c, 0x92, 0xb2, 0x92, 0xe5, 0x7f, 0xd5, 0x88, 0x16,
+  0x37, 0x4f, 0x32, 0x6c, 0x3f, 0x72, 0xda, 0x04, 0xa0, 0xdd, 0x7e, 0x2a,
+  0x1a, 0x4c, 0x35, 0x53, 0x8e, 0x16, 0x03, 0xea, 0xfd, 0x9e, 0xbb, 0xb2,
+  0xed, 0xe1, 0xe2, 0x2a, 0x6b, 0xcb, 0x15, 0x03, 0x83, 0xe1, 0x2d, 0x25,
+  0x46, 0x45, 0x6e, 0x77, 0x65, 0x26, 0x23, 0xc1
+};
+
+static const uint8_t q_2048[] = { /* key component q, 128 bytes */
+  0xda, 0x85, 0x8e, 0x9c, 0x47, 0xc5, 0xa0, 0x3e, 0xc7, 0x90, 0x25, 0x39,
+  0x02, 0x6c, 0xac, 0x9f, 0x28, 0x24, 0xae, 0xcf, 0xa9, 0xe2, 0xa1, 0x9a,
+  0x42, 0xb2, 0xd9, 0x29, 0x2a, 0x12, 0x5e, 0xa7, 0x31, 0x3a, 0x00, 0xa6,
+  0x53, 0x2c, 0xb5, 0xaf, 0x34, 0x83, 0xcd, 0x4f, 0xf9, 0x21, 0x97, 0x8d,
+  0x1a, 0x6f, 0x2e, 0x6c, 0x78, 0xb3, 0x64, 0x63, 0x74, 0xdb, 0xf5, 0xc6,
+  0x01, 0x5f, 0x68, 0x92, 0x84, 0x6b, 0xf8, 0x72, 0x0b, 0x8f, 0x32, 0x20,
+  0x25, 0x85, 0xbe, 0xd4, 0x96, 0x3c, 0xf5, 0xf6, 0x2e, 0x98, 0x69, 0x7e,
+  0xf8, 0x82, 0x44, 0xe3, 0xb1, 0x8a, 0x6f, 0xe3, 0x87, 0x5d, 0x2d, 0x26,
+  0x69, 0xfb, 0xf1, 0x53, 0x3a, 0x5d, 0x02, 0xd0, 0x8f, 0x16, 0xa1, 0xc4,
+  0x29, 0x6f, 0xc0, 0x76, 0x77, 0x80, 0x60, 0xbd, 0xfc, 0x60, 0x1e, 0xb1,
+  0xdb, 0x28, 0x21, 0xe7, 0xca, 0x28, 0x50, 0xa9
+};
+
+static const uint8_t dP_2048[] = { /* key component dP, 128 bytes */
+  0xbb, 0x3c, 0xa3, 0xe2, 0xc6, 0xde, 0xe1, 0x9f, 0x37, 0x4c, 0x72, 0xbc,
+  0x61, 0x0a, 0x90, 0xe2, 0x3d, 0xb6, 0x92, 0x3e, 0x04, 0x19, 0x25, 0x20,
+  0xb5, 0x35, 0x72, 0x75, 0xb1, 0xb3, 0xf3, 0x6a, 0x5c, 0xa7, 0x2b, 0x03,
+  0xc0, 0xc5, 0xe7, 0xe9, 0x1a, 0x08, 0x91, 0x06, 0xcd, 0x36, 0xaa, 0xc1,
+  0x91, 0x2c, 0x17, 0xcd, 0x45, 0xc4, 0x2e, 0x7e, 0x58, 0x6e, 0x4a, 0x5a,
+  0xb2, 0xb8, 0x74, 0xe4, 0xfb, 0x84, 0x27, 0x9b, 0x41, 0x44, 0x25, 0x26,
+  0x72, 0x7c, 0xb7, 0xd2, 0xe9, 0xd2, 0xd6, 0x22, 0x32, 0x58, 0x8a, 0x48,
+  0xce, 0xe7, 0xa2, 0x3b, 0x74, 0xf3, 0xc8, 0x7f, 0x23, 0x17, 0xb0, 0xce,
+  0xf9, 0x51, 0x58, 0x7d, 0xb2, 0xb3, 0x4a, 0xca, 0x92, 0xb8, 0xa9, 0xc8,
+  0x82, 0x14, 0x40, 0x4a, 0x5e, 0x4d, 0x57, 0xa3, 0x27, 0x8a, 0x7b, 0xdd,
+  0x50, 0x2d, 0xfe, 0xfb, 0x35, 0xbb, 0x03, 0x41
+};
+
+static const uint8_t dQ_2048[] = { /* key component dQ, 128 bytes */
+  0x39, 0xd8, 0x08, 0xbc, 0x0d, 0xb3, 0x9e, 0x8b, 0x7f, 0xc0, 0x04, 0x5a,
+  0x66, 0xed, 0xe5, 0x73, 0xeb, 0xe8, 0x69, 0xed, 0xc6, 0x86, 0x9b, 0x48,
+  0x7e, 0x47, 0x61, 0x7c, 0xa8, 0x0a, 0x5c, 0xcb, 0xdd, 0x18, 0x01, 0x7c,
+  0x05, 0xa0, 0x5c, 0x27, 0x98, 0xbb, 0x1a, 0xea, 0x04, 0x84, 0x83, 0xdd,
+  0x72, 0x15, 0xe4, 0x30, 0x0a, 0x73, 0x52, 0x2b, 0x91, 0x8f, 0x78, 0x2b,
+  0x85, 0xc9, 0x7f, 0xa0, 0xe9, 0x34, 0xbb, 0x7b, 0x54, 0xdb, 0xfe, 0xe4,
+  0xcb, 0x89, 0xef, 0xcd, 0xce, 0x47, 0x2c, 0xc4, 0x91, 0xe8, 0xfe, 0x64,
+  0x01, 0xdc, 0x59, 0xe7, 0xfb, 0xe3, 0x2d, 0x63, 0x09, 0x3d, 0xfc, 0xe9,
+  0xa2, 0x3c, 0x72, 0xd1, 0x19, 0x2d, 0xed, 0xc4, 0xcf, 0x5b, 0xaa, 0x4e,
+  0x86, 0xb9, 0x72, 0x34, 0xe9, 0xc5, 0x2d, 0xd6, 0x9c, 0xab, 0xc4, 0xf4,
+  0x47, 0x93, 0x04, 0x06, 0x9b, 0x58, 0xb8, 0xa1
+};
+
+static const uint8_t u_2048[] = { /* key component u, 128 bytes */
+  0xa7, 0xed, 0xf8, 0xf1, 0xbe, 0x8f, 0xe4, 0x21, 0x65, 0xe1, 0xd2, 0x1b,
+  0x14, 0x73, 0x99, 0x8e, 0x80, 0x40, 0x71, 0xf8, 0xcf, 0xb2, 0x14, 0xf7,
+  0x87, 0xe6, 0x5e, 0x24, 0xf6, 0x91, 0x3b, 0x06, 0xf3, 0xfb, 0x2f, 0x84,
+  0xf3, 0x5f, 0xb2, 0x65, 0x6d, 0xed, 0x40, 0x92, 0x25, 0xb0, 0x9a, 0x62,
+  0xca, 0xdc, 0xb9, 0x1d, 0x8d, 0xa2, 0x75, 0x55, 0xf3, 0x09, 0xff, 0x53,
+  0xbf, 0x77, 0x2d, 0xc9, 0xcb, 0x01, 0x5f, 0x96, 0x39, 0xb7, 0x9d, 0xb8,
+  0xc4, 0xc1, 0x09, 0xab, 0x09, 0xc3, 0xc2, 0x27, 0x88, 0x5c, 0x05, 0x86,
+  0x17, 0xe4, 0xc4, 0xeb, 0x66, 0x95, 0xeb, 0xc4, 0xc4, 0x4d, 0x48, 0xdc,
+  0x43, 0x70, 0x91, 0x19, 0x49, 0xec, 0xd7, 0x51, 0x3a, 0x4c, 0xb8, 0xa6,
+  0x77, 0x79, 0x2c, 0x69, 0x8d, 0xd8, 0x43, 0x8e, 0x94, 0x58, 0xa3, 0x10,
+  0x6c, 0x41, 0x7f, 0x0f, 0x96, 0x6f, 0x5a, 0xd0
+};
+
+static const uint8_t m_2048[] = { /* message to be signed, 256 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65,
+  0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20, 0x8e, 0x36, 0xfc, 0x9a,
+  0xa3, 0x17, 0x24, 0xc3, 0x24, 0x16, 0x26, 0x3c, 0x03, 0x66, 0xa1, 0x75,
+  0xfa, 0xbb, 0xb9, 0x2b, 0x74, 0x1c, 0xa6, 0x49, 0x61, 0x07, 0x07, 0x4d,
+  0x03, 0x43, 0xb5, 0x97
+};
+
+static const uint8_t s_2048[] = { /* signed message, 256 bytes */
+  0x4a, 0xf7, 0x47, 0xbb, 0xf2, 0x11, 0xd4, 0x4a, 0x03, 0xe5, 0xce, 0xbb,
+  0x07, 0xae, 0xc9, 0x74, 0xf9, 0xc5, 0x05, 0xa2, 0xbc, 0xe8, 0x8f, 0x38,
+  0x8c, 0xde, 0x7e, 0xdf, 0x29, 0xab, 0xd6, 0x0c, 0x9a, 0x3f, 0xdf, 0x4d,
+  0xd1, 0xe4, 0x19, 0x51, 0x46, 0x94, 0xb6, 0x3b, 0xc3, 0xf1, 0x45, 0xba,
+  0x30, 0x34, 0x18, 0x03, 0xf6, 0x86, 0xaf, 0x45, 0xe3, 0x1d, 0x33, 0x4e,
+  0x08, 0x09, 0x95, 0xf5, 0x52, 0xad, 0xbe, 0x56, 0xb9, 0xb4, 0x5a, 0xed,
+  0xd5, 0xd1, 0xff, 0x52, 0x59, 0x75, 0x7b, 0x95, 0xfa, 0x8f, 0x29, 0x87,
+  0x48, 0x50, 0x37, 0xf6, 0x62, 0x7d, 0x4b, 0x4c, 0xdc, 0xe4, 0xee, 0xc2,
+  0xaa, 0x93, 0x2f, 0x94, 0x97, 0x8a, 0xfe, 0xa8, 0x12, 0x31, 0x09, 0x4f,
+  0x8a, 0xe7, 0x49, 0x69, 0xc8, 0xa0, 0xf0, 0xb6, 0xb8, 0x64, 0x53, 0x5b,
+  0xce, 0xe2, 0xc7, 0xac, 0xa1, 0x20, 0x24, 0x90, 0xd3, 0xcd, 0xee, 0x08,
+  0xfb, 0xa0, 0xa0, 0xf7, 0x5f, 0xaa, 0x3b, 0x4f, 0xa2, 0x3b, 0xb6, 0xe9,
+  0x20, 0x79, 0xca, 0x8f, 0xb3, 0x68, 0x07, 0x4b, 0x79, 0x42, 0x60, 0xf3,
+  0x18, 0xd1, 0x6f, 0xff, 0xdd, 0xe2, 0x96, 0x44, 0xea, 0x5c, 0x36, 0x43,
+  0x07, 0xdc, 0xaa, 0xae, 0xba, 0x6b, 0xe9, 0x10, 0x0e, 0xf2, 0x12, 0xf3,
+  0xb4, 0x6c, 0xeb, 0x8a, 0x1e, 0xf7, 0xfd, 0x23, 0x2c, 0x56, 0x30, 0xf4,
+  0x29, 0xf3, 0x75, 0x7b, 0xd8, 0xfb, 0x80, 0xb9, 0x26, 0x01, 0x69, 0xa5,
+  0x92, 0x7c, 0x56, 0x56, 0x2d, 0x0d, 0x91, 0x54, 0x81, 0x76, 0x21, 0xe5,
+  0x70, 0x1f, 0x1e, 0x8f, 0xc3, 0xc8, 0x9f, 0x2a, 0xa5, 0xfa, 0x96, 0xf2,
+  0x62, 0x99, 0xb8, 0x6e, 0xf0, 0x5f, 0x83, 0x15, 0x8f, 0x33, 0xe4, 0xe7,
+  0xaf, 0xe2, 0xac, 0x23, 0x2e, 0x38, 0x5f, 0x45, 0x41, 0x9b, 0xe9, 0xb4,
+  0x79, 0xd0, 0xf8, 0xcf
+};
+
+/* 4096-bit RSA private key (PKCS #8)
+-----BEGIN PRIVATE KEY-----
+MIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQCuW+hI3vfWBlm/
+CiwGlQLLG/6WCAB5eNWfgWpjxBTKcGG+nKniAYrLtskG4fu0zJl5zf1HvGhJXW65
+6id3lcE4dCmtIDciebLexvkVcHGj+3dsh0i/RZ2hfNJQJa9BpzZ3DtsuDK4f5Tkj
+1B5DScDEVfInSHDAU2rDxuDXBMnVXd08CDTLUiNU/BFQz0XEZJZ0Y4BeCmTm0cGE
+V3LhahNgFh+1Lpi4cBwSt+EoFYWisPr9KXjAbHVCAYUHfvXvE1wXql0YexNTRHEf
+EQG24EeEdj2XR72Ms36xrHhykIsSxuMjodsJlqG/JO/SAdeLMj4j68SD28F1fInW
+2Szi1teXGDYBaMyT0Gw5kQ4TFlq8XED5hB5I8pOCtwuoQlw7vVjp1t90WL/bbA7Y
+cwv9I4V3rOCkOkkCJe/mVB9Z0XmY7CnDYUXm211+oIcJyzTnk0iLV1cRiTAMEExK
+S7wGJ1ZAh4CMTpk2FBx0tGb948Bny+gxjGLsYgNYUbp9GkOD8tYxo77k4Wjj7YgU
+TA2A41zxA0LH/apfHRo8bSnIkLYw2NyzZ+OOGa7tW3oZ27yMlWnQGEErH6EcKNvB
+2d4gUslWEjOn9XzqFnXRD2RUPfDPesMJ4Xlll2r7w4hMB9/VNkPtebE+rh5NB+cW
+kvwrZWqlwXMCG/6o3a5Dden/b5387QIDAQABAoICAAlPxzv9DGdVt31IYcmIM7n9
+KL+CdeQG3AHEu5XQZvvYvJ+dZkU3p93xSRMhBnxFYPzsT1aBbWBdqQgsxSbRzJvj
+OEaSrd8deLwFDFBkzOzhBSO6pdvxL9XsAJ9fI9jxwSrilDoFW1dAuqh7L5KQYcca
+f/AxIjRjQBRsjp1tGApZFPObzJX/MPvc6l/ScftnE9HrbnOXQoRBN4CF2xDGxXog
+NFlMv8M52YX2ZAPsAlMJ+J2ElXpRUIHR6vTXhvLZqdVpt8cS65lK0m/CTMEjgS5F
+0kw9/JWDEIUUnOohZgv+qyq//h6o+MJoipZAmu5IJKFuefRAzDgmCoZ62rbSmnjU
+m3N2DceHaAAw78Zf9RdT0w08fp/hXVO39HMnME5sFQGnlJsbNv74qfBIH6+8fDU7
+6rWWCq67E0gQkAnuYXczFSOPwZJn8E4Nce67UeyQq6CQEuC1XTrW34ZBUHy5pua9
+UuFymGYSNRBOUC3kurTYZmhpcAs9j8tVYSb62vNDZbvkYXRyPjpvRThpttCoa6Ds
+3fiMfsN/AbpQqiSDxR2MX0okhHlrar2ucbNMJoxHf5iUo0Pj9LIRtmyIK/hh1uAI
+eOks8M63wAmiuuHeDkXAMjuT3j59aS1jRSuJLZmxgnqttNbeYPqr74epMsFje7gy
+0AXh5QS3BinxH7s4KONRAoIBAQDAPeQp+kSsYVR0SuiaSCn+O+9ytPUevVjt/Wcl
+nx9XNTeaoj2rBwlqua50x1BPVXfOIXrQL2AV0xY+7aLmhVBQJ+FfA5hMFo0s6h+F
+EeJdjBS1wd3uH40OUKbsIepnd7zxjbXgJzmChmaiVRUxwqi1mqWhMGgrvt42zwMZ
+UAkXXbsyk1J3j+mlwsyLN887fHjW8tZPNr2f0uVs8ctmvSEIlDmMsaItu3DBN/Jz
+6eOL6YBO1YGiinQHZk0aEbOd0uJ274wmQ24pAmrhH2btvuQ05/d+aSssJQBzoSqZ
+3I81nSlZAjCigi6syj8Z9O90d2zdLQx4I6w46Rrat/Y3mWirAoIBAQDoL7Kjqv0i
+Uk/VFbixpvUwf0GwlJnAuyrcpUlUqM5BBk/jbLTKPXzkTTIIzZvY32qmSNpdf/n/
+lNR7li07dJtd9RvfXDAFkf0GxwhRNOAn+KSWNqTQK7C8w2HGrdqkZRF3ZxQOWMbW
+Z1ovSqcXwx3yFCSm/q6EdGSpXdiA9MmuDI5HO+U7t94VeTwg2slo8/kpLLtgF8OX
+Ol65rO5lPuPRr0b2gVv8B+Lqd9wUThgQiDSPgLBGVbQ+GEERGL7JfzzxgW2YE3mL
+0q0Susoi1hDVgnBw+TwzH74hyDSRVLDbMI2yIIfP77eYrygrUfF23eNGj6L+ogmD
+f7+gC/oDWODHAoIBABt//waePXqnRayJFrMTRaaPrlYrWrE2BuWsjTfNhm80NqsR
+MF8p14gD3dfoty1SHZxIH8huLoGQu6ru1ZHCWlXNDqlH215vD2zwZOflQgt9wWyq
+ufOZYdU9ZlN7GowIjefEDNNu6QQp876fCzQeE4I/CBiB0zUGzcTrYhcZ4uMLzn6S
+ooZl+Nd0gUwdBLEOwj6FaHDWdNPLGHS4Ng+RWItgoMbmljuSh7OsLCu2to1KLseY
+NT4qLiTs1nS3OYmHJEw9QkAq/zQwm1du5Yt29jA3SqkzpDBhbqob0PtHmNjjjYml
+DY4Br2maWOJ+rk5r0w/kpNb+y2Esv2GwVTFo6ZcCggEBAIg282ZxefAYuh0YkTIn
+8NBy1+bwRwN6yrqHfW3dWqNrQJL7w1SinhKR9ziS50tkRv0m4HTaD6CRf9bBU+f9
+kOieU6vGOaYK75Z6TbbWfmr0xBocFLTL7PPQ7BvTAuJPKOAT6QBBtOUz3QTBlyWp
+onfSuW3/HAM5BZUXKVz+PxOM6iuASAuw4ulWJqBfuqmH+DTfuU22o1ilNc1YVsOv
+EZiCa+9SFNTXC5jimIqRBi0suyk1JjUdMpD7SbDuA3/S1b4ZYGJHipctEbxbORsW
+2ulnjO+6SEb16GWJPs3EEb2Fzpsh2oty5xL8L2S6vh4uLpfGzKj2Bv7Og20xmYs9
+KSECggEBAKi6ccRd9c439uxW4+QRijrRl9nSMmHWR640EEwC6AgqaFgmQgxKf4e9
+2Hz84KVYFAipPDYAgFM6kY7j/S0rmbPrYGATyXmV+ugwfkH7ecc9BIWCjdvVWyb4
+fY6+qSRw5wtvcf2D9QsmsS15L4HTMn+GlnYN31Zda5Fg7TLIruADJniZeFYdI10F
+RCCTi1YcQ4fsB+b+hsS7hgPHJ/ovQ8+6/Tt882cW4zCYIRSNPpxlaohH46rFiSkL
+VQdslQAtvbuzCJ9CgHFPNLTlquSJ+DbXCq6AKFEiik73kw74VGHj34E8ZWa02GuD
+470vqgm1JXKXNFHU9dkUZd/51e1fzso=
+-----END PRIVATE KEY-----
+*/
+
+static const uint8_t n_4096[] = { /* key component n, 512 bytes */
+  0xae, 0x5b, 0xe8, 0x48, 0xde, 0xf7, 0xd6, 0x06, 0x59, 0xbf, 0x0a, 0x2c,
+  0x06, 0x95, 0x02, 0xcb, 0x1b, 0xfe, 0x96, 0x08, 0x00, 0x79, 0x78, 0xd5,
+  0x9f, 0x81, 0x6a, 0x63, 0xc4, 0x14, 0xca, 0x70, 0x61, 0xbe, 0x9c, 0xa9,
+  0xe2, 0x01, 0x8a, 0xcb, 0xb6, 0xc9, 0x06, 0xe1, 0xfb, 0xb4, 0xcc, 0x99,
+  0x79, 0xcd, 0xfd, 0x47, 0xbc, 0x68, 0x49, 0x5d, 0x6e, 0xb9, 0xea, 0x27,
+  0x77, 0x95, 0xc1, 0x38, 0x74, 0x29, 0xad, 0x20, 0x37, 0x22, 0x79, 0xb2,
+  0xde, 0xc6, 0xf9, 0x15, 0x70, 0x71, 0xa3, 0xfb, 0x77, 0x6c, 0x87, 0x48,
+  0xbf, 0x45, 0x9d, 0xa1, 0x7c, 0xd2, 0x50, 0x25, 0xaf, 0x41, 0xa7, 0x36,
+  0x77, 0x0e, 0xdb, 0x2e, 0x0c, 0xae, 0x1f, 0xe5, 0x39, 0x23, 0xd4, 0x1e,
+  0x43, 0x49, 0xc0, 0xc4, 0x55, 0xf2, 0x27, 0x48, 0x70, 0xc0, 0x53, 0x6a,
+  0xc3, 0xc6, 0xe0, 0xd7, 0x04, 0xc9, 0xd5, 0x5d, 0xdd, 0x3c, 0x08, 0x34,
+  0xcb, 0x52, 0x23, 0x54, 0xfc, 0x11, 0x50, 0xcf, 0x45, 0xc4, 0x64, 0x96,
+  0x74, 0x63, 0x80, 0x5e, 0x0a, 0x64, 0xe6, 0xd1, 0xc1, 0x84, 0x57, 0x72,
+  0xe1, 0x6a, 0x13, 0x60, 0x16, 0x1f, 0xb5, 0x2e, 0x98, 0xb8, 0x70, 0x1c,
+  0x12, 0xb7, 0xe1, 0x28, 0x15, 0x85, 0xa2, 0xb0, 0xfa, 0xfd, 0x29, 0x78,
+  0xc0, 0x6c, 0x75, 0x42, 0x01, 0x85, 0x07, 0x7e, 0xf5, 0xef, 0x13, 0x5c,
+  0x17, 0xaa, 0x5d, 0x18, 0x7b, 0x13, 0x53, 0x44, 0x71, 0x1f, 0x11, 0x01,
+  0xb6, 0xe0, 0x47, 0x84, 0x76, 0x3d, 0x97, 0x47, 0xbd, 0x8c, 0xb3, 0x7e,
+  0xb1, 0xac, 0x78, 0x72, 0x90, 0x8b, 0x12, 0xc6, 0xe3, 0x23, 0xa1, 0xdb,
+  0x09, 0x96, 0xa1, 0xbf, 0x24, 0xef, 0xd2, 0x01, 0xd7, 0x8b, 0x32, 0x3e,
+  0x23, 0xeb, 0xc4, 0x83, 0xdb, 0xc1, 0x75, 0x7c, 0x89, 0xd6, 0xd9, 0x2c,
+  0xe2, 0xd6, 0xd7, 0x97, 0x18, 0x36, 0x01, 0x68, 0xcc, 0x93, 0xd0, 0x6c,
+  0x39, 0x91, 0x0e, 0x13, 0x16, 0x5a, 0xbc, 0x5c, 0x40, 0xf9, 0x84, 0x1e,
+  0x48, 0xf2, 0x93, 0x82, 0xb7, 0x0b, 0xa8, 0x42, 0x5c, 0x3b, 0xbd, 0x58,
+  0xe9, 0xd6, 0xdf, 0x74, 0x58, 0xbf, 0xdb, 0x6c, 0x0e, 0xd8, 0x73, 0x0b,
+  0xfd, 0x23, 0x85, 0x77, 0xac, 0xe0, 0xa4, 0x3a, 0x49, 0x02, 0x25, 0xef,
+  0xe6, 0x54, 0x1f, 0x59, 0xd1, 0x79, 0x98, 0xec, 0x29, 0xc3, 0x61, 0x45,
+  0xe6, 0xdb, 0x5d, 0x7e, 0xa0, 0x87, 0x09, 0xcb, 0x34, 0xe7, 0x93, 0x48,
+  0x8b, 0x57, 0x57, 0x11, 0x89, 0x30, 0x0c, 0x10, 0x4c, 0x4a, 0x4b, 0xbc,
+  0x06, 0x27, 0x56, 0x40, 0x87, 0x80, 0x8c, 0x4e, 0x99, 0x36, 0x14, 0x1c,
+  0x74, 0xb4, 0x66, 0xfd, 0xe3, 0xc0, 0x67, 0xcb, 0xe8, 0x31, 0x8c, 0x62,
+  0xec, 0x62, 0x03, 0x58, 0x51, 0xba, 0x7d, 0x1a, 0x43, 0x83, 0xf2, 0xd6,
+  0x31, 0xa3, 0xbe, 0xe4, 0xe1, 0x68, 0xe3, 0xed, 0x88, 0x14, 0x4c, 0x0d,
+  0x80, 0xe3, 0x5c, 0xf1, 0x03, 0x42, 0xc7, 0xfd, 0xaa, 0x5f, 0x1d, 0x1a,
+  0x3c, 0x6d, 0x29, 0xc8, 0x90, 0xb6, 0x30, 0xd8, 0xdc, 0xb3, 0x67, 0xe3,
+  0x8e, 0x19, 0xae, 0xed, 0x5b, 0x7a, 0x19, 0xdb, 0xbc, 0x8c, 0x95, 0x69,
+  0xd0, 0x18, 0x41, 0x2b, 0x1f, 0xa1, 0x1c, 0x28, 0xdb, 0xc1, 0xd9, 0xde,
+  0x20, 0x52, 0xc9, 0x56, 0x12, 0x33, 0xa7, 0xf5, 0x7c, 0xea, 0x16, 0x75,
+  0xd1, 0x0f, 0x64, 0x54, 0x3d, 0xf0, 0xcf, 0x7a, 0xc3, 0x09, 0xe1, 0x79,
+  0x65, 0x97, 0x6a, 0xfb, 0xc3, 0x88, 0x4c, 0x07, 0xdf, 0xd5, 0x36, 0x43,
+  0xed, 0x79, 0xb1, 0x3e, 0xae, 0x1e, 0x4d, 0x07, 0xe7, 0x16, 0x92, 0xfc,
+  0x2b, 0x65, 0x6a, 0xa5, 0xc1, 0x73, 0x02, 0x1b, 0xfe, 0xa8, 0xdd, 0xae,
+  0x43, 0x75, 0xe9, 0xff, 0x6f, 0x9d, 0xfc, 0xed
+};
+
+static const uint8_t e_4096[] = { /* key component e, 4 bytes */
+  0x00, 0x01, 0x00, 0x01
+};
+
+static const uint8_t d_4096[] = { /* key component d, 512 bytes */
+  0x09, 0x4f, 0xc7, 0x3b, 0xfd, 0x0c, 0x67, 0x55, 0xb7, 0x7d, 0x48, 0x61,
+  0xc9, 0x88, 0x33, 0xb9, 0xfd, 0x28, 0xbf, 0x82, 0x75, 0xe4, 0x06, 0xdc,
+  0x01, 0xc4, 0xbb, 0x95, 0xd0, 0x66, 0xfb, 0xd8, 0xbc, 0x9f, 0x9d, 0x66,
+  0x45, 0x37, 0xa7, 0xdd, 0xf1, 0x49, 0x13, 0x21, 0x06, 0x7c, 0x45, 0x60,
+  0xfc, 0xec, 0x4f, 0x56, 0x81, 0x6d, 0x60, 0x5d, 0xa9, 0x08, 0x2c, 0xc5,
+  0x26, 0xd1, 0xcc, 0x9b, 0xe3, 0x38, 0x46, 0x92, 0xad, 0xdf, 0x1d, 0x78,
+  0xbc, 0x05, 0x0c, 0x50, 0x64, 0xcc, 0xec, 0xe1, 0x05, 0x23, 0xba, 0xa5,
+  0xdb, 0xf1, 0x2f, 0xd5, 0xec, 0x00, 0x9f, 0x5f, 0x23, 0xd8, 0xf1, 0xc1,
+  0x2a, 0xe2, 0x94, 0x3a, 0x05, 0x5b, 0x57, 0x40, 0xba, 0xa8, 0x7b, 0x2f,
+  0x92, 0x90, 0x61, 0xc7, 0x1a, 0x7f, 0xf0, 0x31, 0x22, 0x34, 0x63, 0x40,
+  0x14, 0x6c, 0x8e, 0x9d, 0x6d, 0x18, 0x0a, 0x59, 0x14, 0xf3, 0x9b, 0xcc,
+  0x95, 0xff, 0x30, 0xfb, 0xdc, 0xea, 0x5f, 0xd2, 0x71, 0xfb, 0x67, 0x13,
+  0xd1, 0xeb, 0x6e, 0x73, 0x97, 0x42, 0x84, 0x41, 0x37, 0x80, 0x85, 0xdb,
+  0x10, 0xc6, 0xc5, 0x7a, 0x20, 0x34, 0x59, 0x4c, 0xbf, 0xc3, 0x39, 0xd9,
+  0x85, 0xf6, 0x64, 0x03, 0xec, 0x02, 0x53, 0x09, 0xf8, 0x9d, 0x84, 0x95,
+  0x7a, 0x51, 0x50, 0x81, 0xd1, 0xea, 0xf4, 0xd7, 0x86, 0xf2, 0xd9, 0xa9,
+  0xd5, 0x69, 0xb7, 0xc7, 0x12, 0xeb, 0x99, 0x4a, 0xd2, 0x6f, 0xc2, 0x4c,
+  0xc1, 0x23, 0x81, 0x2e, 0x45, 0xd2, 0x4c, 0x3d, 0xfc, 0x95, 0x83, 0x10,
+  0x85, 0x14, 0x9c, 0xea, 0x21, 0x66, 0x0b, 0xfe, 0xab, 0x2a, 0xbf, 0xfe,
+  0x1e, 0xa8, 0xf8, 0xc2, 0x68, 0x8a, 0x96, 0x40, 0x9a, 0xee, 0x48, 0x24,
+  0xa1, 0x6e, 0x79, 0xf4, 0x40, 0xcc, 0x38, 0x26, 0x0a, 0x86, 0x7a, 0xda,
+  0xb6, 0xd2, 0x9a, 0x78, 0xd4, 0x9b, 0x73, 0x76, 0x0d, 0xc7, 0x87, 0x68,
+  0x00, 0x30, 0xef, 0xc6, 0x5f, 0xf5, 0x17, 0x53, 0xd3, 0x0d, 0x3c, 0x7e,
+  0x9f, 0xe1, 0x5d, 0x53, 0xb7, 0xf4, 0x73, 0x27, 0x30, 0x4e, 0x6c, 0x15,
+  0x01, 0xa7, 0x94, 0x9b, 0x1b, 0x36, 0xfe, 0xf8, 0xa9, 0xf0, 0x48, 0x1f,
+  0xaf, 0xbc, 0x7c, 0x35, 0x3b, 0xea, 0xb5, 0x96, 0x0a, 0xae, 0xbb, 0x13,
+  0x48, 0x10, 0x90, 0x09, 0xee, 0x61, 0x77, 0x33, 0x15, 0x23, 0x8f, 0xc1,
+  0x92, 0x67, 0xf0, 0x4e, 0x0d, 0x71, 0xee, 0xbb, 0x51, 0xec, 0x90, 0xab,
+  0xa0, 0x90, 0x12, 0xe0, 0xb5, 0x5d, 0x3a, 0xd6, 0xdf, 0x86, 0x41, 0x50,
+  0x7c, 0xb9, 0xa6, 0xe6, 0xbd, 0x52, 0xe1, 0x72, 0x98, 0x66, 0x12, 0x35,
+  0x10, 0x4e, 0x50, 0x2d, 0xe4, 0xba, 0xb4, 0xd8, 0x66, 0x68, 0x69, 0x70,
+  0x0b, 0x3d, 0x8f, 0xcb, 0x55, 0x61, 0x26, 0xfa, 0xda, 0xf3, 0x43, 0x65,
+  0xbb, 0xe4, 0x61, 0x74, 0x72, 0x3e, 0x3a, 0x6f, 0x45, 0x38, 0x69, 0xb6,
+  0xd0, 0xa8, 0x6b, 0xa0, 0xec, 0xdd, 0xf8, 0x8c, 0x7e, 0xc3, 0x7f, 0x01,
+  0xba, 0x50, 0xaa, 0x24, 0x83, 0xc5, 0x1d, 0x8c, 0x5f, 0x4a, 0x24, 0x84,
+  0x79, 0x6b, 0x6a, 0xbd, 0xae, 0x71, 0xb3, 0x4c, 0x26, 0x8c, 0x47, 0x7f,
+  0x98, 0x94, 0xa3, 0x43, 0xe3, 0xf4, 0xb2, 0x11, 0xb6, 0x6c, 0x88, 0x2b,
+  0xf8, 0x61, 0xd6, 0xe0, 0x08, 0x78, 0xe9, 0x2c, 0xf0, 0xce, 0xb7, 0xc0,
+  0x09, 0xa2, 0xba, 0xe1, 0xde, 0x0e, 0x45, 0xc0, 0x32, 0x3b, 0x93, 0xde,
+  0x3e, 0x7d, 0x69, 0x2d, 0x63, 0x45, 0x2b, 0x89, 0x2d, 0x99, 0xb1, 0x82,
+  0x7a, 0xad, 0xb4, 0xd6, 0xde, 0x60, 0xfa, 0xab, 0xef, 0x87, 0xa9, 0x32,
+  0xc1, 0x63, 0x7b, 0xb8, 0x32, 0xd0, 0x05, 0xe1, 0xe5, 0x04, 0xb7, 0x06,
+  0x29, 0xf1, 0x1f, 0xbb, 0x38, 0x28, 0xe3, 0x51
+};
+
+static const uint8_t p_4096[] = { /* key component p, 256 bytes */
+  0xc0, 0x3d, 0xe4, 0x29, 0xfa, 0x44, 0xac, 0x61, 0x54, 0x74, 0x4a, 0xe8,
+  0x9a, 0x48, 0x29, 0xfe, 0x3b, 0xef, 0x72, 0xb4, 0xf5, 0x1e, 0xbd, 0x58,
+  0xed, 0xfd, 0x67, 0x25, 0x9f, 0x1f, 0x57, 0x35, 0x37, 0x9a, 0xa2, 0x3d,
+  0xab, 0x07, 0x09, 0x6a, 0xb9, 0xae, 0x74, 0xc7, 0x50, 0x4f, 0x55, 0x77,
+  0xce, 0x21, 0x7a, 0xd0, 0x2f, 0x60, 0x15, 0xd3, 0x16, 0x3e, 0xed, 0xa2,
+  0xe6, 0x85, 0x50, 0x50, 0x27, 0xe1, 0x5f, 0x03, 0x98, 0x4c, 0x16, 0x8d,
+  0x2c, 0xea, 0x1f, 0x85, 0x11, 0xe2, 0x5d, 0x8c, 0x14, 0xb5, 0xc1, 0xdd,
+  0xee, 0x1f, 0x8d, 0x0e, 0x50, 0xa6, 0xec, 0x21, 0xea, 0x67, 0x77, 0xbc,
+  0xf1, 0x8d, 0xb5, 0xe0, 0x27, 0x39, 0x82, 0x86, 0x66, 0xa2, 0x55, 0x15,
+  0x31, 0xc2, 0xa8, 0xb5, 0x9a, 0xa5, 0xa1, 0x30, 0x68, 0x2b, 0xbe, 0xde,
+  0x36, 0xcf, 0x03, 0x19, 0x50, 0x09, 0x17, 0x5d, 0xbb, 0x32, 0x93, 0x52,
+  0x77, 0x8f, 0xe9, 0xa5, 0xc2, 0xcc, 0x8b, 0x37, 0xcf, 0x3b, 0x7c, 0x78,
+  0xd6, 0xf2, 0xd6, 0x4f, 0x36, 0xbd, 0x9f, 0xd2, 0xe5, 0x6c, 0xf1, 0xcb,
+  0x66, 0xbd, 0x21, 0x08, 0x94, 0x39, 0x8c, 0xb1, 0xa2, 0x2d, 0xbb, 0x70,
+  0xc1, 0x37, 0xf2, 0x73, 0xe9, 0xe3, 0x8b, 0xe9, 0x80, 0x4e, 0xd5, 0x81,
+  0xa2, 0x8a, 0x74, 0x07, 0x66, 0x4d, 0x1a, 0x11, 0xb3, 0x9d, 0xd2, 0xe2,
+  0x76, 0xef, 0x8c, 0x26, 0x43, 0x6e, 0x29, 0x02, 0x6a, 0xe1, 0x1f, 0x66,
+  0xed, 0xbe, 0xe4, 0x34, 0xe7, 0xf7, 0x7e, 0x69, 0x2b, 0x2c, 0x25, 0x00,
+  0x73, 0xa1, 0x2a, 0x99, 0xdc, 0x8f, 0x35, 0x9d, 0x29, 0x59, 0x02, 0x30,
+  0xa2, 0x82, 0x2e, 0xac, 0xca, 0x3f, 0x19, 0xf4, 0xef, 0x74, 0x77, 0x6c,
+  0xdd, 0x2d, 0x0c, 0x78, 0x23, 0xac, 0x38, 0xe9, 0x1a, 0xda, 0xb7, 0xf6,
+  0x37, 0x99, 0x68, 0xab
+};
+
+static const uint8_t q_4096[] = { /* key component q, 256 bytes */
+  0xe8, 0x2f, 0xb2, 0xa3, 0xaa, 0xfd, 0x22, 0x52, 0x4f, 0xd5, 0x15, 0xb8,
+  0xb1, 0xa6, 0xf5, 0x30, 0x7f, 0x41, 0xb0, 0x94, 0x99, 0xc0, 0xbb, 0x2a,
+  0xdc, 0xa5, 0x49, 0x54, 0xa8, 0xce, 0x41, 0x06, 0x4f, 0xe3, 0x6c, 0xb4,
+  0xca, 0x3d, 0x7c, 0xe4, 0x4d, 0x32, 0x08, 0xcd, 0x9b, 0xd8, 0xdf, 0x6a,
+  0xa6, 0x48, 0xda, 0x5d, 0x7f, 0xf9, 0xff, 0x94, 0xd4, 0x7b, 0x96, 0x2d,
+  0x3b, 0x74, 0x9b, 0x5d, 0xf5, 0x1b, 0xdf, 0x5c, 0x30, 0x05, 0x91, 0xfd,
+  0x06, 0xc7, 0x08, 0x51, 0x34, 0xe0, 0x27, 0xf8, 0xa4, 0x96, 0x36, 0xa4,
+  0xd0, 0x2b, 0xb0, 0xbc, 0xc3, 0x61, 0xc6, 0xad, 0xda, 0xa4, 0x65, 0x11,
+  0x77, 0x67, 0x14, 0x0e, 0x58, 0xc6, 0xd6, 0x67, 0x5a, 0x2f, 0x4a, 0xa7,
+  0x17, 0xc3, 0x1d, 0xf2, 0x14, 0x24, 0xa6, 0xfe, 0xae, 0x84, 0x74, 0x64,
+  0xa9, 0x5d, 0xd8, 0x80, 0xf4, 0xc9, 0xae, 0x0c, 0x8e, 0x47, 0x3b, 0xe5,
+  0x3b, 0xb7, 0xde, 0x15, 0x79, 0x3c, 0x20, 0xda, 0xc9, 0x68, 0xf3, 0xf9,
+  0x29, 0x2c, 0xbb, 0x60, 0x17, 0xc3, 0x97, 0x3a, 0x5e, 0xb9, 0xac, 0xee,
+  0x65, 0x3e, 0xe3, 0xd1, 0xaf, 0x46, 0xf6, 0x81, 0x5b, 0xfc, 0x07, 0xe2,
+  0xea, 0x77, 0xdc, 0x14, 0x4e, 0x18, 0x10, 0x88, 0x34, 0x8f, 0x80, 0xb0,
+  0x46, 0x55, 0xb4, 0x3e, 0x18, 0x41, 0x11, 0x18, 0xbe, 0xc9, 0x7f, 0x3c,
+  0xf1, 0x81, 0x6d, 0x98, 0x13, 0x79, 0x8b, 0xd2, 0xad, 0x12, 0xba, 0xca,
+  0x22, 0xd6, 0x10, 0xd5, 0x82, 0x70, 0x70, 0xf9, 0x3c, 0x33, 0x1f, 0xbe,
+  0x21, 0xc8, 0x34, 0x91, 0x54, 0xb0, 0xdb, 0x30, 0x8d, 0xb2, 0x20, 0x87,
+  0xcf, 0xef, 0xb7, 0x98, 0xaf, 0x28, 0x2b, 0x51, 0xf1, 0x76, 0xdd, 0xe3,
+  0x46, 0x8f, 0xa2, 0xfe, 0xa2, 0x09, 0x83, 0x7f, 0xbf, 0xa0, 0x0b, 0xfa,
+  0x03, 0x58, 0xe0, 0xc7
+};
+
+static const uint8_t dP_4096[] = { /* key component dP, 256 bytes */
+  0x1b, 0x7f, 0xff, 0x06, 0x9e, 0x3d, 0x7a, 0xa7, 0x45, 0xac, 0x89, 0x16,
+  0xb3, 0x13, 0x45, 0xa6, 0x8f, 0xae, 0x56, 0x2b, 0x5a, 0xb1, 0x36, 0x06,
+  0xe5, 0xac, 0x8d, 0x37, 0xcd, 0x86, 0x6f, 0x34, 0x36, 0xab, 0x11, 0x30,
+  0x5f, 0x29, 0xd7, 0x88, 0x03, 0xdd, 0xd7, 0xe8, 0xb7, 0x2d, 0x52, 0x1d,
+  0x9c, 0x48, 0x1f, 0xc8, 0x6e, 0x2e, 0x81, 0x90, 0xbb, 0xaa, 0xee, 0xd5,
+  0x91, 0xc2, 0x5a, 0x55, 0xcd, 0x0e, 0xa9, 0x47, 0xdb, 0x5e, 0x6f, 0x0f,
+  0x6c, 0xf0, 0x64, 0xe7, 0xe5, 0x42, 0x0b, 0x7d, 0xc1, 0x6c, 0xaa, 0xb9,
+  0xf3, 0x99, 0x61, 0xd5, 0x3d, 0x66, 0x53, 0x7b, 0x1a, 0x8c, 0x08, 0x8d,
+  0xe7, 0xc4, 0x0c, 0xd3, 0x6e, 0xe9, 0x04, 0x29, 0xf3, 0xbe, 0x9f, 0x0b,
+  0x34, 0x1e, 0x13, 0x82, 0x3f, 0x08, 0x18, 0x81, 0xd3, 0x35, 0x06, 0xcd,
+  0xc4, 0xeb, 0x62, 0x17, 0x19, 0xe2, 0xe3, 0x0b, 0xce, 0x7e, 0x92, 0xa2,
+  0x86, 0x65, 0xf8, 0xd7, 0x74, 0x81, 0x4c, 0x1d, 0x04, 0xb1, 0x0e, 0xc2,
+  0x3e, 0x85, 0x68, 0x70, 0xd6, 0x74, 0xd3, 0xcb, 0x18, 0x74, 0xb8, 0x36,
+  0x0f, 0x91, 0x58, 0x8b, 0x60, 0xa0, 0xc6, 0xe6, 0x96, 0x3b, 0x92, 0x87,
+  0xb3, 0xac, 0x2c, 0x2b, 0xb6, 0xb6, 0x8d, 0x4a, 0x2e, 0xc7, 0x98, 0x35,
+  0x3e, 0x2a, 0x2e, 0x24, 0xec, 0xd6, 0x74, 0xb7, 0x39, 0x89, 0x87, 0x24,
+  0x4c, 0x3d, 0x42, 0x40, 0x2a, 0xff, 0x34, 0x30, 0x9b, 0x57, 0x6e, 0xe5,
+  0x8b, 0x76, 0xf6, 0x30, 0x37, 0x4a, 0xa9, 0x33, 0xa4, 0x30, 0x61, 0x6e,
+  0xaa, 0x1b, 0xd0, 0xfb, 0x47, 0x98, 0xd8, 0xe3, 0x8d, 0x89, 0xa5, 0x0d,
+  0x8e, 0x01, 0xaf, 0x69, 0x9a, 0x58, 0xe2, 0x7e, 0xae, 0x4e, 0x6b, 0xd3,
+  0x0f, 0xe4, 0xa4, 0xd6, 0xfe, 0xcb, 0x61, 0x2c, 0xbf, 0x61, 0xb0, 0x55,
+  0x31, 0x68, 0xe9, 0x97
+};
+
+static const uint8_t dQ_4096[] = { /* key component dQ, 256 bytes */
+  0x88, 0x36, 0xf3, 0x66, 0x71, 0x79, 0xf0, 0x18, 0xba, 0x1d, 0x18, 0x91,
+  0x32, 0x27, 0xf0, 0xd0, 0x72, 0xd7, 0xe6, 0xf0, 0x47, 0x03, 0x7a, 0xca,
+  0xba, 0x87, 0x7d, 0x6d, 0xdd, 0x5a, 0xa3, 0x6b, 0x40, 0x92, 0xfb, 0xc3,
+  0x54, 0xa2, 0x9e, 0x12, 0x91, 0xf7, 0x38, 0x92, 0xe7, 0x4b, 0x64, 0x46,
+  0xfd, 0x26, 0xe0, 0x74, 0xda, 0x0f, 0xa0, 0x91, 0x7f, 0xd6, 0xc1, 0x53,
+  0xe7, 0xfd, 0x90, 0xe8, 0x9e, 0x53, 0xab, 0xc6, 0x39, 0xa6, 0x0a, 0xef,
+  0x96, 0x7a, 0x4d, 0xb6, 0xd6, 0x7e, 0x6a, 0xf4, 0xc4, 0x1a, 0x1c, 0x14,
+  0xb4, 0xcb, 0xec, 0xf3, 0xd0, 0xec, 0x1b, 0xd3, 0x02, 0xe2, 0x4f, 0x28,
+  0xe0, 0x13, 0xe9, 0x00, 0x41, 0xb4, 0xe5, 0x33, 0xdd, 0x04, 0xc1, 0x97,
+  0x25, 0xa9, 0xa2, 0x77, 0xd2, 0xb9, 0x6d, 0xff, 0x1c, 0x03, 0x39, 0x05,
+  0x95, 0x17, 0x29, 0x5c, 0xfe, 0x3f, 0x13, 0x8c, 0xea, 0x2b, 0x80, 0x48,
+  0x0b, 0xb0, 0xe2, 0xe9, 0x56, 0x26, 0xa0, 0x5f, 0xba, 0xa9, 0x87, 0xf8,
+  0x34, 0xdf, 0xb9, 0x4d, 0xb6, 0xa3, 0x58, 0xa5, 0x35, 0xcd, 0x58, 0x56,
+  0xc3, 0xaf, 0x11, 0x98, 0x82, 0x6b, 0xef, 0x52, 0x14, 0xd4, 0xd7, 0x0b,
+  0x98, 0xe2, 0x98, 0x8a, 0x91, 0x06, 0x2d, 0x2c, 0xbb, 0x29, 0x35, 0x26,
+  0x35, 0x1d, 0x32, 0x90, 0xfb, 0x49, 0xb0, 0xee, 0x03, 0x7f, 0xd2, 0xd5,
+  0xbe, 0x19, 0x60, 0x62, 0x47, 0x8a, 0x97, 0x2d, 0x11, 0xbc, 0x5b, 0x39,
+  0x1b, 0x16, 0xda, 0xe9, 0x67, 0x8c, 0xef, 0xba, 0x48, 0x46, 0xf5, 0xe8,
+  0x65, 0x89, 0x3e, 0xcd, 0xc4, 0x11, 0xbd, 0x85, 0xce, 0x9b, 0x21, 0xda,
+  0x8b, 0x72, 0xe7, 0x12, 0xfc, 0x2f, 0x64, 0xba, 0xbe, 0x1e, 0x2e, 0x2e,
+  0x97, 0xc6, 0xcc, 0xa8, 0xf6, 0x06, 0xfe, 0xce, 0x83, 0x6d, 0x31, 0x99,
+  0x8b, 0x3d, 0x29, 0x21
+};
+
+static const uint8_t u_4096[] = { /* key component u, 256 bytes */
+  0xa8, 0xba, 0x71, 0xc4, 0x5d, 0xf5, 0xce, 0x37, 0xf6, 0xec, 0x56, 0xe3,
+  0xe4, 0x11, 0x8a, 0x3a, 0xd1, 0x97, 0xd9, 0xd2, 0x32, 0x61, 0xd6, 0x47,
+  0xae, 0x34, 0x10, 0x4c, 0x02, 0xe8, 0x08, 0x2a, 0x68, 0x58, 0x26, 0x42,
+  0x0c, 0x4a, 0x7f, 0x87, 0xbd, 0xd8, 0x7c, 0xfc, 0xe0, 0xa5, 0x58, 0x14,
+  0x08, 0xa9, 0x3c, 0x36, 0x00, 0x80, 0x53, 0x3a, 0x91, 0x8e, 0xe3, 0xfd,
+  0x2d, 0x2b, 0x99, 0xb3, 0xeb, 0x60, 0x60, 0x13, 0xc9, 0x79, 0x95, 0xfa,
+  0xe8, 0x30, 0x7e, 0x41, 0xfb, 0x79, 0xc7, 0x3d, 0x04, 0x85, 0x82, 0x8d,
+  0xdb, 0xd5, 0x5b, 0x26, 0xf8, 0x7d, 0x8e, 0xbe, 0xa9, 0x24, 0x70, 0xe7,
+  0x0b, 0x6f, 0x71, 0xfd, 0x83, 0xf5, 0x0b, 0x26, 0xb1, 0x2d, 0x79, 0x2f,
+  0x81, 0xd3, 0x32, 0x7f, 0x86, 0x96, 0x76, 0x0d, 0xdf, 0x56, 0x5d, 0x6b,
+  0x91, 0x60, 0xed, 0x32, 0xc8, 0xae, 0xe0, 0x03, 0x26, 0x78, 0x99, 0x78,
+  0x56, 0x1d, 0x23, 0x5d, 0x05, 0x44, 0x20, 0x93, 0x8b, 0x56, 0x1c, 0x43,
+  0x87, 0xec, 0x07, 0xe6, 0xfe, 0x86, 0xc4, 0xbb, 0x86, 0x03, 0xc7, 0x27,
+  0xfa, 0x2f, 0x43, 0xcf, 0xba, 0xfd, 0x3b, 0x7c, 0xf3, 0x67, 0x16, 0xe3,
+  0x30, 0x98, 0x21, 0x14, 0x8d, 0x3e, 0x9c, 0x65, 0x6a, 0x88, 0x47, 0xe3,
+  0xaa, 0xc5, 0x89, 0x29, 0x0b, 0x55, 0x07, 0x6c, 0x95, 0x00, 0x2d, 0xbd,
+  0xbb, 0xb3, 0x08, 0x9f, 0x42, 0x80, 0x71, 0x4f, 0x34, 0xb4, 0xe5, 0xaa,
+  0xe4, 0x89, 0xf8, 0x36, 0xd7, 0x0a, 0xae, 0x80, 0x28, 0x51, 0x22, 0x8a,
+  0x4e, 0xf7, 0x93, 0x0e, 0xf8, 0x54, 0x61, 0xe3, 0xdf, 0x81, 0x3c, 0x65,
+  0x66, 0xb4, 0xd8, 0x6b, 0x83, 0xe3, 0xbd, 0x2f, 0xaa, 0x09, 0xb5, 0x25,
+  0x72, 0x97, 0x34, 0x51, 0xd4, 0xf5, 0xd9, 0x14, 0x65, 0xdf, 0xf9, 0xd5,
+  0xed, 0x5f, 0xce, 0xca
+};
+
+static const uint8_t m_4096[] = { /* message to be signed, 512 bytes */
+  0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+  0xff, 0xff, 0xff, 0xff, 0x00, 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
+  0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20,
+  0x8e, 0x36, 0xfc, 0x9a, 0xa3, 0x17, 0x24, 0xc3, 0x24, 0x16, 0x26, 0x3c,
+  0x03, 0x66, 0xa1, 0x75, 0xfa, 0xbb, 0xb9, 0x2b, 0x74, 0x1c, 0xa6, 0x49,
+  0x61, 0x07, 0x07, 0x4d, 0x03, 0x43, 0xb5, 0x97
+};
+
+static const uint8_t s_4096[] = { /* signed message, 512 bytes */
+  0xad, 0x46, 0xb3, 0x86, 0xb3, 0x3d, 0x13, 0xb7, 0x56, 0x0c, 0xbf, 0xd8,
+  0xfe, 0xf4, 0xf2, 0x0d, 0x2d, 0x5a, 0x28, 0xad, 0xb5, 0x43, 0x7b, 0x88,
+  0x5f, 0x01, 0xa4, 0x01, 0xd6, 0x28, 0x3b, 0x10, 0x0e, 0x22, 0x89, 0x11,
+  0xc4, 0x3e, 0xcf, 0xbb, 0xaf, 0xd6, 0x82, 0xd9, 0x51, 0xb1, 0x93, 0xd6,
+  0xc8, 0x7b, 0x89, 0xd4, 0x7a, 0xd1, 0xd0, 0x08, 0x39, 0x6b, 0x13, 0xb5,
+  0x55, 0x75, 0x61, 0xf3, 0xce, 0x47, 0x77, 0x01, 0x29, 0xee, 0x07, 0x5e,
+  0x4d, 0xdf, 0x83, 0x80, 0x18, 0x6d, 0xb8, 0x57, 0x14, 0x45, 0x81, 0x27,
+  0x1e, 0xe3, 0x2f, 0xdf, 0x0a, 0xba, 0x3b, 0x0f, 0x12, 0x07, 0xff, 0x7f,
+  0x35, 0x44, 0x75, 0xe3, 0xa8, 0x39, 0x25, 0x88, 0x3c, 0x32, 0x9e, 0x8a,
+  0xd6, 0xfa, 0x3f, 0x89, 0xa4, 0x6d, 0x8a, 0x9d, 0x3d, 0x75, 0x2c, 0x6f,
+  0x2a, 0x85, 0xd8, 0x96, 0x47, 0x4b, 0xde, 0x2a, 0x6b, 0x5e, 0xe1, 0x88,
+  0xcd, 0x37, 0xfb, 0x17, 0xe2, 0x84, 0x81, 0xe7, 0xa8, 0x7c, 0x47, 0x8e,
+  0x69, 0x69, 0x91, 0x37, 0x71, 0x97, 0x3f, 0xd1, 0x1a, 0x3e, 0x34, 0x84,
+  0x52, 0xe0, 0x08, 0x2c, 0x4c, 0xdc, 0x02, 0x11, 0x08, 0x30, 0xc9, 0xf5,
+  0x85, 0xc6, 0x6b, 0xba, 0x59, 0xc1, 0xf2, 0xc6, 0x7f, 0x8c, 0x4a, 0x57,
+  0xe5, 0x29, 0xa5, 0x0d, 0x60, 0x1a, 0x0e, 0xda, 0xd1, 0xac, 0xcc, 0x21,
+  0x20, 0x5c, 0xa0, 0x62, 0xf6, 0xc6, 0x4a, 0x92, 0xb2, 0x35, 0x9f, 0x62,
+  0x51, 0x4d, 0xcb, 0xd0, 0x35, 0x4e, 0xb2, 0xa3, 0x1b, 0xec, 0xd6, 0x18,
+  0xb4, 0x67, 0xb9, 0xf8, 0x5c, 0x80, 0xfc, 0x20, 0x05, 0x85, 0x8a, 0x5a,
+  0x35, 0x9a, 0xde, 0x2c, 0xd9, 0xde, 0x21, 0xfe, 0x9f, 0x92, 0x9f, 0xcb,
+  0xb8, 0xea, 0x56, 0xf9, 0xb7, 0x4f, 0x61, 0xf9, 0x20, 0x09, 0xfe, 0x78,
+  0x4b, 0x92, 0x90, 0x7a, 0xf9, 0xd0, 0x28, 0x95, 0x34, 0xc6, 0x5a, 0x9a,
+  0x2a, 0x2a, 0xb8, 0xab, 0x6a, 0x1a, 0xc1, 0xd7, 0x7d, 0x5c, 0xde, 0xd1,
+  0xaf, 0xe2, 0x20, 0x8d, 0x62, 0x56, 0x2c, 0x71, 0x78, 0x5b, 0x29, 0x20,
+  0x4b, 0xf0, 0xe9, 0xa4, 0xe2, 0x3f, 0xab, 0xa2, 0x77, 0xac, 0xdf, 0x6e,
+  0x2e, 0xc3, 0xa1, 0x4f, 0xe0, 0x30, 0xa7, 0xb7, 0x3a, 0x05, 0x13, 0x43,
+  0xc1, 0x64, 0xdd, 0xff, 0x96, 0x65, 0x4c, 0x40, 0x62, 0x4a, 0xff, 0xa3,
+  0xf0, 0x81, 0x26, 0x5d, 0x5f, 0x55, 0x73, 0xdb, 0x7d, 0xf8, 0x1f, 0x9c,
+  0x0a, 0x64, 0x93, 0x74, 0xf3, 0xeb, 0x3d, 0x6f, 0x68, 0xec, 0x85, 0x5a,
+  0xaa, 0x91, 0xb8, 0x5a, 0x36, 0x64, 0x89, 0x66, 0xb1, 0x53, 0xc5, 0xb8,
+  0x5d, 0x33, 0xf7, 0x60, 0xc2, 0x89, 0x36, 0xef, 0x0d, 0xc5, 0x58, 0x08,
+  0x75, 0x40, 0xae, 0x04, 0x87, 0x74, 0x1f, 0x11, 0x65, 0x1c, 0x84, 0xb6,
+  0x60, 0xa0, 0xae, 0xe2, 0x2e, 0x70, 0xbe, 0x6a, 0x5d, 0x76, 0x60, 0xaa,
+  0x41, 0xc5, 0x35, 0x09, 0xd3, 0x25, 0x5e, 0xd4, 0x7f, 0x22, 0x2b, 0xd7,
+  0x09, 0x38, 0xae, 0x59, 0xde, 0x55, 0x88, 0x52, 0xae, 0x30, 0xfc, 0xb8,
+  0x61, 0xdd, 0x7e, 0xc7, 0x1b, 0x37, 0xd5, 0x83, 0x28, 0x2a, 0x6e, 0x38,
+  0x01, 0xb5, 0xd4, 0x3f, 0x34, 0xb6, 0x37, 0xd5, 0xbf, 0x59, 0x6e, 0xb7,
+  0x16, 0x07, 0x96, 0x76, 0xe7, 0x84, 0x1b, 0x24, 0x59, 0x0b, 0x0a, 0x5c,
+  0x5b, 0xef, 0xae, 0xc7, 0x7d, 0x18, 0x7e, 0x7c, 0x1a, 0xd5, 0x24, 0x2e,
+  0xe9, 0x7f, 0x92, 0x3f, 0x4d, 0xd2, 0x0e, 0x44, 0xd1, 0x60, 0x73, 0xef,
+  0x9b, 0xb6, 0x43, 0x87, 0xdd, 0x43, 0x1c, 0xa2, 0x67, 0x3e, 0x80, 0x5f,
+  0x50, 0x6d, 0x5c, 0xb6, 0x90, 0xd5, 0x14, 0xce, 0xad, 0xbc, 0x2e, 0x39,
+  0x62, 0x96, 0xc3, 0x25, 0xec, 0xa4, 0xd8, 0xf2
+};
+
+typedef struct { const uint8_t *val; size_t len; } rsa_tc_bn_t;
+typedef struct { size_t size; rsa_tc_bn_t n, e, d, p, q, dP, dQ, u, m, s; } rsa_tc_t;
+
+static const rsa_tc_t rsa_tc[] = {
+  { 1024,
+    { n_1024, sizeof(n_1024) },
+    { e_1024, sizeof(e_1024) },
+    { d_1024, sizeof(d_1024) },
+    { p_1024, sizeof(p_1024) },
+    { q_1024, sizeof(q_1024) },
+    { dP_1024, sizeof(dP_1024) },
+    { dQ_1024, sizeof(dQ_1024) },
+    { u_1024, sizeof(u_1024) },
+    { m_1024, sizeof(m_1024) },
+    { s_1024, sizeof(s_1024) }
+  },
+  { 2048,
+    { n_2048, sizeof(n_2048) },
+    { e_2048, sizeof(e_2048) },
+    { d_2048, sizeof(d_2048) },
+    { p_2048, sizeof(p_2048) },
+    { q_2048, sizeof(q_2048) },
+    { dP_2048, sizeof(dP_2048) },
+    { dQ_2048, sizeof(dQ_2048) },
+    { u_2048, sizeof(u_2048) },
+    { m_2048, sizeof(m_2048) },
+    { s_2048, sizeof(s_2048) }
+  },
+  { 4096,
+    { n_4096, sizeof(n_4096) },
+    { e_4096, sizeof(e_4096) },
+    { d_4096, sizeof(d_4096) },
+    { p_4096, sizeof(p_4096) },
+    { q_4096, sizeof(q_4096) },
+    { dP_4096, sizeof(dP_4096) },
+    { dQ_4096, sizeof(dQ_4096) },
+    { u_4096, sizeof(u_4096) },
+    { m_4096, sizeof(m_4096) },
+    { s_4096, sizeof(s_4096) }
+  }
+};