anchor.diff:  
   (defun elgamal-encryption-test (name p g x y input k output)
     ;; Redefine elgamal-generate-k to use a defined K for the test instead of a random one
  -  (defun ironclad::elgamal-generate-k (p)
  -    (declare (ignore p))
  -    k)
  +  (setf (symbol-function 'ironclad::elgamal-generate-k)
  +        (lambda (p)
  +          (declare (ignore p))
  +          k))
   
     (let* ((pk (ironclad:make-public-key :elgamal :p p :g g :y y))
            (sk (ironclad:make-private-key :elgamal :p p :g g :x x :y y))
  
positive.code: 
  (defun rsa-oaep-encryption-test (name n e d input seed output)
    ;; Redefine oaep-encode to use a defined seed for the test instead of a random one
    (defun ironclad:oaep-encode (digest-name message num-bytes &optional label)
      (let ((digest-len (ironclad:digest-length digest-name)))
        (assert (<= (length message) (- num-bytes (* 2 digest-len) 2)))
        (let* ((digest (ironclad:make-digest digest-name))
               (label (or label (coerce #() '(vector (unsigned-byte 8)))))
               (padding-len (- num-bytes (length message) (* 2 digest-len) 2))
               (padding (make-array padding-len :element-type '(unsigned-byte 8) :initial-element 0))
               (l-hash (ironclad:digest-sequence digest label))
               (db (concatenate '(vector (unsigned-byte 8)) l-hash padding #(1) message))
               (db-mask (ironclad::mgf digest-name seed (- num-bytes digest-len 1)))
               (masked-db (map '(vector (unsigned-byte 8)) #'logxor db db-mask))
               (seed-mask (ironclad::mgf digest-name masked-db digest-len))
               (masked-seed (map '(vector (unsigned-byte 8)) #'logxor seed seed-mask)))
          (concatenate '(vector (unsigned-byte 8)) #(0) masked-seed masked-db))))
  
    (let* ((pk (ironclad:make-public-key :rsa :n n :e e))
           (sk (ironclad:make-private-key :rsa :n n :d d))
  
negative.code: 
  (defun rsa-pss-signature-test (name n e d input salt signature)
    ;; Redefine pss-encode to use a defined salt for the test instead of a random one
    (setf (symbol-function 'ironclad:pss-encode)
          (lambda (digest-name message num-bytes)
            (let ((digest-len (ironclad:digest-length digest-name)))
              (assert (>= num-bytes (+ (* 2 digest-len) 2)))
              (let* ((m-hash (ironclad:digest-sequence digest-name message))
                     (m1 (concatenate '(vector (unsigned-byte 8)) #(0 0 0 0 0 0 0 0) m-hash salt))
                     (h (ironclad:digest-sequence digest-name m1))
                     (ps (make-array (- num-bytes (* 2 digest-len) 2)
                                     :element-type '(unsigned-byte 8)
                                     :initial-element 0))
                     (db (concatenate '(vector (unsigned-byte 8)) ps #(1) salt))
                     (db-mask (ironclad::mgf digest-name h (- num-bytes digest-len 1)))
                     (masked-db (map '(vector (unsigned-byte 8)) #'logxor db db-mask)))
                (setf (ldb (byte 1 7) (elt masked-db 0)) 0)
                (concatenate '(vector (unsigned-byte 8)) masked-db h #(188))))))
  
    (let* ((pk (ironclad:make-public-key :rsa :n n :e e))
           (sk (ironclad:make-private-key :rsa :n n :d d))
  