src/devtools/packer/mt2735/test_pkcs1_pss_mytest.py

# -*- coding: utf-8 -*-
#
#  SelfTest/Signature/test_pkcs1_pss.py: Self-test for PKCS#1 PSS signatures
#
# ===================================================================
# The contents of this file are dedicated to the public domain.  To
# the extent that dedication to the public domain is not available,
# everyone is granted a worldwide, perpetual, royalty-free,
# non-exclusive license to exercise all rights associated with the
# contents of this file for any purpose whatsoever.
# No rights are reserved.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# ===================================================================

from __future__ import nested_scopes

__revision__ = "$Id$"

import unittest

from Crypto.PublicKey import RSA
from Crypto import Random
from Crypto.SelfTest.st_common import list_test_cases, a2b_hex, b2a_hex
from Crypto.Hash import *
from Crypto.Signature import PKCS1_PSS as PKCS
from Crypto.Util.py3compat import *

def isStr(s):
        t = ''
        try:
                t += s
        except TypeError:
                return 0
        return 1

def rws(t):
    """Remove white spaces, tabs, and new lines from a string"""
    for c in ['\t', '\n', ' ']:
        t = t.replace(c,'')
    return t

def t2b(t):
    """Convert a text string with bytes in hex form to a byte string"""
    clean = b(rws(t))
    if len(clean)%2 == 1:
        raise ValueError("Even number of characters expected")
    return a2b_hex(clean)

# dump str to bytes
def rsa_dump(data):
	print("-----------pss_mytest dump:----------")
	for i in range(0, len(data)):
		print ("0x%02x,"%ord(data[i])),
		if(((i+1)%16) == 0):
			print("")
	print("-----------pss_mytest dump end-----------")

# Helper class to count how many bytes have been requested
# from the key's private RNG, w/o counting those used for blinding
class MyKey:
    def __init__(self, key):
        self._key = key
        self.n = key.n
        self.asked = 0
    def _randfunc(self, N):
        self.asked += N
        return self._key._randfunc(N)
    def sign(self, m):
        return self._key.sign(m)
    def has_private(self):
        return self._key.has_private()
    def decrypt(self, m):
        return self._key.decrypt(m)
    def verify(self, m, p):
        return self._key.verify(m, p)
    def encrypt(self, m, p):
        return self._key.encrypt(m, p)

class PKCS1_PSS_Tests(unittest.TestCase):

        # List of tuples with test data for PKCS#1 PSS
        # Each tuple is made up by:
        #       Item #0: dictionary with RSA key component, or key to import
        #       Item #1: data to hash and sign
        #       Item #2: signature of the data #1, done with the key #0,
        #                and salt #3 after hashing it with #4
        #       Item #3: salt
        #       Item #4: hash object generator

        _testData = (

                #
                # From in pss-vect.txt to be found in
                # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                #
                (
                # Private key
                {
                'n':'''a2 ba 40 ee 07 e3 b2 bd 2f 02 ce 22 7f 36 a1 95
                02 44 86 e4 9c 19 cb 41 bb bd fb ba 98 b2 2b 0e
                57 7c 2e ea ff a2 0d 88 3a 76 e6 5e 39 4c 69 d4
                b3 c0 5a 1e 8f ad da 27 ed b2 a4 2b c0 00 fe 88
                8b 9b 32 c2 2d 15 ad d0 cd 76 b3 e7 93 6e 19 95
                5b 22 0d d1 7d 4e a9 04 b1 ec 10 2b 2e 4d e7 75
                12 22 aa 99 15 10 24 c7 cb 41 cc 5e a2 1d 00 ee
                b4 1f 7c 80 08 34 d2 c6 e0 6b ce 3b ce 7e a9 a5''',
                'e':'''01 00 01''',
                # In the test vector, only p and q were given...
                # d is computed offline as e^{-1} mod (p-1)(q-1)
                'd':'''50e2c3e38d886110288dfc68a9533e7e12e27d2aa56
                d2cdb3fb6efa990bcff29e1d2987fb711962860e7391b1ce01
                ebadb9e812d2fbdfaf25df4ae26110a6d7a26f0b810f54875e
                17dd5c9fb6d641761245b81e79f8c88f0e55a6dcd5f133abd3
                5f8f4ec80adf1bf86277a582894cb6ebcd2162f1c7534f1f49
                47b129151b71'''
                },

                # Data to sign
                '''85 9e ef 2f d7 8a ca 00 30 8b dc 47 11 93 bf 55
                bf 9d 78 db 8f 8a 67 2b 48 46 34 f3 c9 c2 6e 64
                78 ae 10 26 0f e0 dd 8c 08 2e 53 a5 29 3a f2 17
                3c d5 0c 6d 5d 35 4f eb f7 8b 26 02 1c 25 c0 27
                12 e7 8c d4 69 4c 9f 46 97 77 e4 51 e7 f8 e9 e0
                4c d3 73 9c 6b bf ed ae 48 7f b5 56 44 e9 ca 74
                ff 77 a5 3c b7 29 80 2f 6e d4 a5 ff a8 ba 15 98
                90 fc''',
                # Signature
                '''8d aa 62 7d 3d e7 59 5d 63 05 6c 7e c6 59 e5 44
                06 f1 06 10 12 8b aa e8 21 c8 b2 a0 f3 93 6d 54
                dc 3b dc e4 66 89 f6 b7 95 1b b1 8e 84 05 42 76
                97 18 d5 71 5d 21 0d 85 ef bb 59 61 92 03 2c 42
                be 4c 29 97 2c 85 62 75 eb 6d 5a 45 f0 5f 51 87
                6f c6 74 3d ed dd 28 ca ec 9b b3 0e a9 9e 02 c3
                48 82 69 60 4f e4 97 f7 4c cd 7c 7f ca 16 71 89
                71 23 cb d3 0d ef 5d 54 a2 b5 53 6a d9 0a 74 7e''',
                # Salt
                '''e3 b5 d5 d0 02 c1 bc e5 0c 2b 65 ef 88 a1 88 d8
                3b ce 7e 61''',
                # Hash algorithm
                SHA
                ),

                #
                # Example 1.1 to be found in
                # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                #
                (
                # Private key
                {
                'n':'''a5 6e 4a 0e 70 10 17 58 9a 51 87 dc 7e a8 41 d1
                56 f2 ec 0e 36 ad 52 a4 4d fe b1 e6 1f 7a d9 91
                d8 c5 10 56 ff ed b1 62 b4 c0 f2 83 a1 2a 88 a3
                94 df f5 26 ab 72 91 cb b3 07 ce ab fc e0 b1 df
                d5 cd 95 08 09 6d 5b 2b 8b 6d f5 d6 71 ef 63 77
                c0 92 1c b2 3c 27 0a 70 e2 59 8e 6f f8 9d 19 f1
                05 ac c2 d3 f0 cb 35 f2 92 80 e1 38 6b 6f 64 c4
                ef 22 e1 e1 f2 0d 0c e8 cf fb 22 49 bd 9a 21 37''',
                'e':'''01 00 01''',
                'd':'''33 a5 04 2a 90 b2 7d 4f 54 51 ca 9b bb d0 b4 47
                71 a1 01 af 88 43 40 ae f9 88 5f 2a 4b be 92 e8
                94 a7 24 ac 3c 56 8c 8f 97 85 3a d0 7c 02 66 c8
                c6 a3 ca 09 29 f1 e8 f1 12 31 88 44 29 fc 4d 9a
                e5 5f ee 89 6a 10 ce 70 7c 3e d7 e7 34 e4 47 27
                a3 95 74 50 1a 53 26 83 10 9c 2a ba ca ba 28 3c
                31 b4 bd 2f 53 c3 ee 37 e3 52 ce e3 4f 9e 50 3b
                d8 0c 06 22 ad 79 c6 dc ee 88 35 47 c6 a3 b3 25'''
                },
                # Message
                '''cd c8 7d a2 23 d7 86 df 3b 45 e0 bb bc 72 13 26
                d1 ee 2a f8 06 cc 31 54 75 cc 6f 0d 9c 66 e1 b6
                23 71 d4 5c e2 39 2e 1a c9 28 44 c3 10 10 2f 15
                6a 0d 8d 52 c1 f4 c4 0b a3 aa 65 09 57 86 cb 76
                97 57 a6 56 3b a9 58 fe d0 bc c9 84 e8 b5 17 a3
                d5 f5 15 b2 3b 8a 41 e7 4a a8 67 69 3f 90 df b0
                61 a6 e8 6d fa ae e6 44 72 c0 0e 5f 20 94 57 29
                cb eb e7 7f 06 ce 78 e0 8f 40 98 fb a4 1f 9d 61
                93 c0 31 7e 8b 60 d4 b6 08 4a cb 42 d2 9e 38 08
                a3 bc 37 2d 85 e3 31 17 0f cb f7 cc 72 d0 b7 1c
                29 66 48 b3 a4 d1 0f 41 62 95 d0 80 7a a6 25 ca
                b2 74 4f d9 ea 8f d2 23 c4 25 37 02 98 28 bd 16
                be 02 54 6f 13 0f d2 e3 3b 93 6d 26 76 e0 8a ed
                1b 73 31 8b 75 0a 01 67 d0''',
                # Signature
                '''90 74 30 8f b5 98 e9 70 1b 22 94 38 8e 52 f9 71
                fa ac 2b 60 a5 14 5a f1 85 df 52 87 b5 ed 28 87
                e5 7c e7 fd 44 dc 86 34 e4 07 c8 e0 e4 36 0b c2
                26 f3 ec 22 7f 9d 9e 54 63 8e 8d 31 f5 05 12 15
                df 6e bb 9c 2f 95 79 aa 77 59 8a 38 f9 14 b5 b9
                c1 bd 83 c4 e2 f9 f3 82 a0 d0 aa 35 42 ff ee 65
                98 4a 60 1b c6 9e b2 8d eb 27 dc a1 2c 82 c2 d4
                c3 f6 6c d5 00 f1 ff 2b 99 4d 8a 4e 30 cb b3 3c''',
                # Salt
                '''de e9 59 c7 e0 64 11 36 14 20 ff 80 18 5e d5 7f
                3e 67 76 af''',
                # Hash
                SHA
                ),

                #
                # Example 1.2 to be found in
                # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                #
                (
                # Private key
                {
                'n':'''a5 6e 4a 0e 70 10 17 58 9a 51 87 dc 7e a8 41 d1
                56 f2 ec 0e 36 ad 52 a4 4d fe b1 e6 1f 7a d9 91
                d8 c5 10 56 ff ed b1 62 b4 c0 f2 83 a1 2a 88 a3
                94 df f5 26 ab 72 91 cb b3 07 ce ab fc e0 b1 df
                d5 cd 95 08 09 6d 5b 2b 8b 6d f5 d6 71 ef 63 77
                c0 92 1c b2 3c 27 0a 70 e2 59 8e 6f f8 9d 19 f1
                05 ac c2 d3 f0 cb 35 f2 92 80 e1 38 6b 6f 64 c4
                ef 22 e1 e1 f2 0d 0c e8 cf fb 22 49 bd 9a 21 37''',
                'e':'''01 00 01''',
                'd':'''33 a5 04 2a 90 b2 7d 4f 54 51 ca 9b bb d0 b4 47
                71 a1 01 af 88 43 40 ae f9 88 5f 2a 4b be 92 e8
                94 a7 24 ac 3c 56 8c 8f 97 85 3a d0 7c 02 66 c8
                c6 a3 ca 09 29 f1 e8 f1 12 31 88 44 29 fc 4d 9a
                e5 5f ee 89 6a 10 ce 70 7c 3e d7 e7 34 e4 47 27
                a3 95 74 50 1a 53 26 83 10 9c 2a ba ca ba 28 3c
                31 b4 bd 2f 53 c3 ee 37 e3 52 ce e3 4f 9e 50 3b
                d8 0c 06 22 ad 79 c6 dc ee 88 35 47 c6 a3 b3 25'''
                },
                # Message
                '''85 13 84 cd fe 81 9c 22 ed 6c 4c cb 30 da eb 5c
                f0 59 bc 8e 11 66 b7 e3 53 0c 4c 23 3e 2b 5f 8f
                71 a1 cc a5 82 d4 3e cc 72 b1 bc a1 6d fc 70 13
                22 6b 9e''',
                # Signature
                '''3e f7 f4 6e 83 1b f9 2b 32 27 41 42 a5 85 ff ce
                fb dc a7 b3 2a e9 0d 10 fb 0f 0c 72 99 84 f0 4e
                f2 9a 9d f0 78 07 75 ce 43 73 9b 97 83 83 90 db
                0a 55 05 e6 3d e9 27 02 8d 9d 29 b2 19 ca 2c 45
                17 83 25 58 a5 5d 69 4a 6d 25 b9 da b6 60 03 c4
                cc cd 90 78 02 19 3b e5 17 0d 26 14 7d 37 b9 35
                90 24 1b e5 1c 25 05 5f 47 ef 62 75 2c fb e2 14
                18 fa fe 98 c2 2c 4d 4d 47 72 4f db 56 69 e8 43''',
                # Salt
                '''ef 28 69 fa 40 c3 46 cb 18 3d ab 3d 7b ff c9 8f
                d5 6d f4 2d''',
                # Hash
                SHA
                ),

                #
                # Example 2.1 to be found in
                # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                #
                (
                # Private key
                {
                'n':'''01 d4 0c 1b cf 97 a6 8a e7 cd bd 8a 7b f3 e3 4f
                a1 9d cc a4 ef 75 a4 74 54 37 5f 94 51 4d 88 fe
                d0 06 fb 82 9f 84 19 ff 87 d6 31 5d a6 8a 1f f3
                a0 93 8e 9a bb 34 64 01 1c 30 3a d9 91 99 cf 0c
                7c 7a 8b 47 7d ce 82 9e 88 44 f6 25 b1 15 e5 e9
                c4 a5 9c f8 f8 11 3b 68 34 33 6a 2f d2 68 9b 47
                2c bb 5e 5c ab e6 74 35 0c 59 b6 c1 7e 17 68 74
                fb 42 f8 fc 3d 17 6a 01 7e dc 61 fd 32 6c 4b 33
                c9''',
                'e':'''01 00 01''',
                'd':'''02 7d 14 7e 46 73 05 73 77 fd 1e a2 01 56 57 72
                17 6a 7d c3 83 58 d3 76 04 56 85 a2 e7 87 c2 3c
                15 57 6b c1 6b 9f 44 44 02 d6 bf c5 d9 8a 3e 88
                ea 13 ef 67 c3 53 ec a0 c0 dd ba 92 55 bd 7b 8b
                b5 0a 64 4a fd fd 1d d5 16 95 b2 52 d2 2e 73 18
                d1 b6 68 7a 1c 10 ff 75 54 5f 3d b0 fe 60 2d 5f
                2b 7f 29 4e 36 01 ea b7 b9 d1 ce cd 76 7f 64 69
                2e 3e 53 6c a2 84 6c b0 c2 dd 48 6a 39 fa 75 b1'''
                },
                # Message
                '''da ba 03 20 66 26 3f ae db 65 98 48 11 52 78 a5
                2c 44 fa a3 a7 6f 37 51 5e d3 36 32 10 72 c4 0a
                9d 9b 53 bc 05 01 40 78 ad f5 20 87 51 46 aa e7
                0f f0 60 22 6d cb 7b 1f 1f c2 7e 93 60''',
                # Signature
                '''01 4c 5b a5 33 83 28 cc c6 e7 a9 0b f1 c0 ab 3f
                d6 06 ff 47 96 d3 c1 2e 4b 63 9e d9 13 6a 5f ec
                6c 16 d8 88 4b dd 99 cf dc 52 14 56 b0 74 2b 73
                68 68 cf 90 de 09 9a db 8d 5f fd 1d ef f3 9b a4
                00 7a b7 46 ce fd b2 2d 7d f0 e2 25 f5 46 27 dc
                65 46 61 31 72 1b 90 af 44 53 63 a8 35 8b 9f 60
                76 42 f7 8f ab 0a b0 f4 3b 71 68 d6 4b ae 70 d8
                82 78 48 d8 ef 1e 42 1c 57 54 dd f4 2c 25 89 b5
                b3''',
                # Salt
                '''57 bf 16 0b cb 02 bb 1d c7 28 0c f0 45 85 30 b7
                d2 83 2f f7''',
                SHA
                ),

                #
                # Example 8.1 to be found in
                # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                #
                (
                # Private key
                {
                'n':'''49 53 70 a1 fb 18 54 3c 16 d3 63 1e 31 63 25 5d
                f6 2b e6 ee e8 90 d5 f2 55 09 e4 f7 78 a8 ea 6f
                bb bc df 85 df f6 4e 0d 97 20 03 ab 36 81 fb ba
                6d d4 1f d5 41 82 9b 2e 58 2d e9 f2 a4 a4 e0 a2
                d0 90 0b ef 47 53 db 3c ee 0e e0 6c 7d fa e8 b1
                d5 3b 59 53 21 8f 9c ce ea 69 5b 08 66 8e de aa
                dc ed 94 63 b1 d7 90 d5 eb f2 7e 91 15 b4 6c ad
                4d 9a 2b 8e fa b0 56 1b 08 10 34 47 39 ad a0 73
                3f''',
                'e':'''01 00 01''',
                'd':'''6c 66 ff e9 89 80 c3 8f cd ea b5 15 98 98 83 61
                65 f4 b4 b8 17 c4 f6 a8 d4 86 ee 4e a9 13 0f e9
                b9 09 2b d1 36 d1 84 f9 5f 50 4a 60 7e ac 56 58
                46 d2 fd d6 59 7a 89 67 c7 39 6e f9 5a 6e ee bb
                45 78 a6 43 96 6d ca 4d 8e e3 de 84 2d e6 32 79
                c6 18 15 9c 1a b5 4a 89 43 7b 6a 61 20 e4 93 0a
                fb 52 a4 ba 6c ed 8a 49 47 ac 64 b3 0a 34 97 cb
                e7 01 c2 d6 26 6d 51 72 19 ad 0e c6 d3 47 db e9'''
                },
                # Message
                '''81 33 2f 4b e6 29 48 41 5e a1 d8 99 79 2e ea cf
                6c 6e 1d b1 da 8b e1 3b 5c ea 41 db 2f ed 46 70
                92 e1 ff 39 89 14 c7 14 25 97 75 f5 95 f8 54 7f
                73 56 92 a5 75 e6 92 3a f7 8f 22 c6 99 7d db 90
                fb 6f 72 d7 bb 0d d5 74 4a 31 de cd 3d c3 68 58
                49 83 6e d3 4a ec 59 63 04 ad 11 84 3c 4f 88 48
                9f 20 97 35 f5 fb 7f da f7 ce c8 ad dc 58 18 16
                8f 88 0a cb f4 90 d5 10 05 b7 a8 e8 4e 43 e5 42
                87 97 75 71 dd 99 ee a4 b1 61 eb 2d f1 f5 10 8f
                12 a4 14 2a 83 32 2e db 05 a7 54 87 a3 43 5c 9a
                78 ce 53 ed 93 bc 55 08 57 d7 a9 fb''',
                # Signature
                '''02 62 ac 25 4b fa 77 f3 c1 ac a2 2c 51 79 f8 f0
                40 42 2b 3c 5b af d4 0a 8f 21 cf 0f a5 a6 67 cc
                d5 99 3d 42 db af b4 09 c5 20 e2 5f ce 2b 1e e1
                e7 16 57 7f 1e fa 17 f3 da 28 05 2f 40 f0 41 9b
                23 10 6d 78 45 aa f0 11 25 b6 98 e7 a4 df e9 2d
                39 67 bb 00 c4 d0 d3 5b a3 55 2a b9 a8 b3 ee f0
                7c 7f ec db c5 42 4a c4 db 1e 20 cb 37 d0 b2 74
                47 69 94 0e a9 07 e1 7f bb ca 67 3b 20 52 23 80
                c5''',
                # Salt
                '''1d 65 49 1d 79 c8 64 b3 73 00 9b e6 f6 f2 46 7b
                ac 4c 78 fa''',
                SHA
                )
        )

        def testSign1(self):
                for i in range(len(self._testData)):
                        # Build the key
                        comps = [ long(rws(self._testData[i][0][x]),16) for x in ('n','e','d') ]
                        key = MyKey(RSA.construct(comps))
                        # Hash function
                        h = self._testData[i][4].new()
                        # Data to sign
                        h.update(t2b(self._testData[i][1]))
                        # Salt
                        test_salt = t2b(self._testData[i][3])
                        key._randfunc = lambda N: test_salt
                        # The real test
                        signer = PKCS.new(key)
                        self.failUnless(signer.can_sign())
                        s = signer.sign(h)
                        self.assertEqual(s, t2b(self._testData[i][2]))

        def testVerify1(self):
               for i in range(len(self._testData)):
                        # Build the key
                        comps = [ long(rws(self._testData[i][0][x]),16) for x in ('n','e') ]
                        key = MyKey(RSA.construct(comps))
                        # Hash function
                        h = self._testData[i][4].new()
                        # Data to sign
                        h.update(t2b(self._testData[i][1]))
                        # Salt
                        test_salt = t2b(self._testData[i][3])
                        # The real test
                        key._randfunc = lambda N: test_salt
                        verifier = PKCS.new(key)
                        self.failIf(verifier.can_sign())
                        result = verifier.verify(h, t2b(self._testData[i][2]))
                        self.failUnless(result)

        def testSignVerify(self):
                        h = SHA.new()
                        h.update(b('blah blah blah'))

                        rng = Random.new().read
                        key = MyKey(RSA.generate(1024,rng))
                         
                        # Helper function to monitor what's request from MGF
                        global mgfcalls
                        def newMGF(seed,maskLen):
                            global mgfcalls
                            mgfcalls += 1
                            return bchr(0x00)*maskLen

                        # Verify that PSS is friendly to all ciphers
                        for hashmod in (MD2,MD5,SHA,SHA224,SHA256,SHA384,RIPEMD):
                            h = hashmod.new()
                            h.update(b('blah blah blah'))

                            # Verify that sign() asks for as many random bytes
                            # as the hash output size
                            key.asked = 0
                            signer = PKCS.new(key)
                            s = signer.sign(h)
                            self.failUnless(signer.verify(h, s))
                            self.assertEqual(key.asked, h.digest_size)

                        h = SHA.new()
                        h.update(b('blah blah blah'))

                        # Verify that sign() uses a different salt length
                        for sLen in (0,3,21):
                            key.asked = 0
                            signer = PKCS.new(key, saltLen=sLen)
                            s = signer.sign(h)
                            self.assertEqual(key.asked, sLen)
                            self.failUnless(signer.verify(h, s))

                        # Verify that sign() uses the custom MGF
                        mgfcalls = 0
                        signer = PKCS.new(key, newMGF)
                        s = signer.sign(h)
                        self.assertEqual(mgfcalls, 1)
                        self.failUnless(signer.verify(h, s))

                        # Verify that sign() does not call the RNG
                        # when salt length is 0, even when a new MGF is provided
                        key.asked = 0
                        mgfcalls = 0
                        signer = PKCS.new(key, newMGF, 0)
                        s = signer.sign(h)
                        self.assertEqual(key.asked,0)
                        self.assertEqual(mgfcalls, 1)
                        self.failUnless(signer.verify(h, s))


class testSign1_mytest():

        # List of tuples with test data for PKCS#1 PSS
        # Each tuple is made up by:
        #       Item #0: dictionary with RSA key component, or key to import
        #       Item #1: data to hash and sign
        #       Item #2: signature of the data #1, done with the key #0,
        #                and salt #3 after hashing it with #4
        #       Item #3: salt
        #       Item #4: hash object generator

        def __init__(self, rsa_parse, msg):
                _testData = (

                        #
                        # From in pss-vect.txt to be found in
                        # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                        #
                        (
                        # Private key
                        {
                        'n':'''a2 ba 40 ee 07 e3 b2 bd 2f 02 ce 22 7f 36 a1 95
                        02 44 86 e4 9c 19 cb 41 bb bd fb ba 98 b2 2b 0e
                        57 7c 2e ea ff a2 0d 88 3a 76 e6 5e 39 4c 69 d4
                        b3 c0 5a 1e 8f ad da 27 ed b2 a4 2b c0 00 fe 88
                        8b 9b 32 c2 2d 15 ad d0 cd 76 b3 e7 93 6e 19 95
                        5b 22 0d d1 7d 4e a9 04 b1 ec 10 2b 2e 4d e7 75
                        12 22 aa 99 15 10 24 c7 cb 41 cc 5e a2 1d 00 ee
                        b4 1f 7c 80 08 34 d2 c6 e0 6b ce 3b ce 7e a9 a5''',
                        'e':'''01 00 01''',
                        # In the test vector, only p and q were given...
                        # d is computed offline as e^{-1} mod (p-1)(q-1)
                        'd':'''50e2c3e38d886110288dfc68a9533e7e12e27d2aa56
                        d2cdb3fb6efa990bcff29e1d2987fb711962860e7391b1ce01
                        ebadb9e812d2fbdfaf25df4ae26110a6d7a26f0b810f54875e
                        17dd5c9fb6d641761245b81e79f8c88f0e55a6dcd5f133abd3
                        5f8f4ec80adf1bf86277a582894cb6ebcd2162f1c7534f1f49
                        47b129151b71'''
                        },

                        # Data to sign
                        '''85 9e ef 2f d7 8a ca 00 30 8b dc 47 11 93 bf 55
                        bf 9d 78 db 8f 8a 67 2b 48 46 34 f3 c9 c2 6e 64
                        78 ae 10 26 0f e0 dd 8c 08 2e 53 a5 29 3a f2 17
                        3c d5 0c 6d 5d 35 4f eb f7 8b 26 02 1c 25 c0 27
                        12 e7 8c d4 69 4c 9f 46 97 77 e4 51 e7 f8 e9 e0
                        4c d3 73 9c 6b bf ed ae 48 7f b5 56 44 e9 ca 74
                        ff 77 a5 3c b7 29 80 2f 6e d4 a5 ff a8 ba 15 98
                        90 fc''',
                        # Signature
                        '''8d aa 62 7d 3d e7 59 5d 63 05 6c 7e c6 59 e5 44
                        06 f1 06 10 12 8b aa e8 21 c8 b2 a0 f3 93 6d 54
                        dc 3b dc e4 66 89 f6 b7 95 1b b1 8e 84 05 42 76
                        97 18 d5 71 5d 21 0d 85 ef bb 59 61 92 03 2c 42
                        be 4c 29 97 2c 85 62 75 eb 6d 5a 45 f0 5f 51 87
                        6f c6 74 3d ed dd 28 ca ec 9b b3 0e a9 9e 02 c3
                        48 82 69 60 4f e4 97 f7 4c cd 7c 7f ca 16 71 89
                        71 23 cb d3 0d ef 5d 54 a2 b5 53 6a d9 0a 74 7e''',
                        # Salt
                        '''e3 b5 d5 d0 02 c1 bc e5 0c 2b 65 ef 88 a1 88 d8
                        3b ce 7e 61''',
                        # Hash algorithm
                        SHA
                        ),

                        #
                        # Example 1.1 to be found in
                        # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
                        #
                        (
                        # Private key
                        {
                        'n':'''a5 6e 4a 0e 70 10 17 58 9a 51 87 dc 7e a8 41 d1
                        56 f2 ec 0e 36 ad 52 a4 4d fe b1 e6 1f 7a d9 91
                        d8 c5 10 56 ff ed b1 62 b4 c0 f2 83 a1 2a 88 a3
                        94 df f5 26 ab 72 91 cb b3 07 ce ab fc e0 b1 df
                        d5 cd 95 08 09 6d 5b 2b 8b 6d f5 d6 71 ef 63 77
                        c0 92 1c b2 3c 27 0a 70 e2 59 8e 6f f8 9d 19 f1
                        05 ac c2 d3 f0 cb 35 f2 92 80 e1 38 6b 6f 64 c4
                        ef 22 e1 e1 f2 0d 0c e8 cf fb 22 49 bd 9a 21 37''',
                        'e':'''01 00 01''',
                        'd':'''33 a5 04 2a 90 b2 7d 4f 54 51 ca 9b bb d0 b4 47
                        71 a1 01 af 88 43 40 ae f9 88 5f 2a 4b be 92 e8
                        94 a7 24 ac 3c 56 8c 8f 97 85 3a d0 7c 02 66 c8
                        c6 a3 ca 09 29 f1 e8 f1 12 31 88 44 29 fc 4d 9a
                        e5 5f ee 89 6a 10 ce 70 7c 3e d7 e7 34 e4 47 27
                        a3 95 74 50 1a 53 26 83 10 9c 2a ba ca ba 28 3c
                        31 b4 bd 2f 53 c3 ee 37 e3 52 ce e3 4f 9e 50 3b
                        d8 0c 06 22 ad 79 c6 dc ee 88 35 47 c6 a3 b3 25'''
                        },
                        # Message
                        '''cd c8 7d a2 23 d7 86 df 3b 45 e0 bb bc 72 13 26
                        d1 ee 2a f8 06 cc 31 54 75 cc 6f 0d 9c 66 e1 b6
                        23 71 d4 5c e2 39 2e 1a c9 28 44 c3 10 10 2f 15
                        6a 0d 8d 52 c1 f4 c4 0b a3 aa 65 09 57 86 cb 76
                        97 57 a6 56 3b a9 58 fe d0 bc c9 84 e8 b5 17 a3
                        d5 f5 15 b2 3b 8a 41 e7 4a a8 67 69 3f 90 df b0
                        61 a6 e8 6d fa ae e6 44 72 c0 0e 5f 20 94 57 29
                        cb eb e7 7f 06 ce 78 e0 8f 40 98 fb a4 1f 9d 61
                        93 c0 31 7e 8b 60 d4 b6 08 4a cb 42 d2 9e 38 08
                        a3 bc 37 2d 85 e3 31 17 0f cb f7 cc 72 d0 b7 1c
                        29 66 48 b3 a4 d1 0f 41 62 95 d0 80 7a a6 25 ca
                        b2 74 4f d9 ea 8f d2 23 c4 25 37 02 98 28 bd 16
                        be 02 54 6f 13 0f d2 e3 3b 93 6d 26 76 e0 8a ed
                        1b 73 31 8b 75 0a 01 67 d0''',
                        # Signature
                        '''90 74 30 8f b5 98 e9 70 1b 22 94 38 8e 52 f9 71
                        fa ac 2b 60 a5 14 5a f1 85 df 52 87 b5 ed 28 87
                        e5 7c e7 fd 44 dc 86 34 e4 07 c8 e0 e4 36 0b c2
                        26 f3 ec 22 7f 9d 9e 54 63 8e 8d 31 f5 05 12 15
                        df 6e bb 9c 2f 95 79 aa 77 59 8a 38 f9 14 b5 b9
                        c1 bd 83 c4 e2 f9 f3 82 a0 d0 aa 35 42 ff ee 65
                        98 4a 60 1b c6 9e b2 8d eb 27 dc a1 2c 82 c2 d4
                        c3 f6 6c d5 00 f1 ff 2b 99 4d 8a 4e 30 cb b3 3c''',
                        # Salt
                        '''de e9 59 c7 e0 64 11 36 14 20 ff 80 18 5e d5 7f
                        3e 67 76 af''',
                        # Hash
                        SHA
                        ),

                        (
                        # Private key
                        """-----BEGIN RSA PRIVATE KEY-----
                        MIICXQIBAAKBgQC1OZn2ExXQ5z/1XhBomiy7j6YGQU7EuBXcvnvizU6fGkdcLWKA
                        MBQJxHOnCJwUSvCecea58P4WSDaAGk/Rbd3y1b1Akr7ilcpW+l0ymfF95pBIMBt1
                        gXDaHtaM1GgR4H0FisR68fHm2LDMNdGdVdGz3vqpUBboVx7fmLyEAxswuQIDAQAB
                        AoGBAKkGWW/mqxFVrhSnL/yv14r0VvA8lz/pRhLF4vxNasgAFZCGj/lpXjch8JBY
                        +mH+51+Qcpb4i7OylIp0f/+gTkGuSAYPYwzwqG3ALwAF4Z5i8qKmklQtEJ+9p7lu
                        POivMzla4Qx7bvBp+Bq4/8lyg5o+D279MN68455wub516+7RAkEAz+InzJO8H8lN
                        OKpysNCPx9WQNkpMLODRlOYxDg6/QiHNBshT+Kd8tU9xT8fqPWCybfrYNKDWEahz
                        C/QVPWR5JQJBAN8r1qZo0KWvOay81ogC6aLoLauJX6UHuhxN1U1cS/AjdSJezWZp
                        L3zmS9iSJbTyojzwGTly6e+2kGHYafLwlwUCQGD+Ujd/jrz9/Yu863pYNV215W2P
                        SO9/jgn9RVIby10dzD2n5pYT/3nRMTtaOY6duWLbMVmM2ZSvlc4z+l0ErgkCQA8F
                        SVY7+ccdCxm4QAw5ffYsAF7qSRi3c2xSRMgHLUlFaa3diZ+Z9stGSNaTx5vtNMQ7
                        OMdoF5y9wewD/+WNEe0CQQCPXCxOab5++0AB25wqwP2Zk/nFiNznd7+Rk/TIS4c+
                        +C8/NPfkYJD7aNcpflFvyeLAWJgtSs+ebVHYpEZpUnY5
                        -----END RSA PRIVATE KEY-----""",
                        # Data to sign
                        "abc",
                        # Signature
                        '''7e a9 02 59 20 eb a1 b1 67 99 56 44 72 88 00 3d
                        11 4a 3d 16 40 d2 77 6b 60 62 06 b6 19 f0 7e de
                        52 93 0d d9 74 25 44 fd b3 4f 5c cf fb b7 98 34
                        ae ad e3 9e 79 93 fc 5f 4b 48 d0 08 95 c4 66 5e
                        d5 17 7a 5b 05 a2 7e fb 21 72 68 12 f7 6d 3b fe
                        97 30 81 c5 75 de e4 26 6c d6 d8 28 0b ae 33 a0
                        f6 9d f0 23 2f f7 12 0b 40 a3 37 7d 25 bf 60 c9
                        84 d4 19 27 61 27 f6 a0 62 8b 52 32 26 9a 0c 77''',
                        # Salt
                        '''25 5a 3c e4 34 ae e1 41 09 a5 96 f6 a6 7e 34 b6
                        8e 56 3f 2d 92 07 41 55 f3 e4 a5 9e 47 98 d2 e4''',
                        # Hash algorithm
                        SHA256
                        ),

                        (
                        # Private key
                        """-----BEGIN RSA PRIVATE KEY-----
                        MIIJKwIBAAKCAgEA3zT2hUJNVJPMixm5F6GJl1oNIVPyV3AlcSmSdHkpPZH9LuRd
                        NEQ1Yv5PuHSFw8PSKmySg+5uMeZudconbCOAoF2pnHgMAw2unm4wc7GJf//E/k7f
                        UwCG6VD/8aO2U0Fkiwo5XpbSe91fmtqXAsyoqBvAsJAdGGGtede7httEa/PhHf2R
                        qzzDdyx5VUnZm4IolN7Q25J730L5mOlkwOzH0uuE7zlnwDnMV6sbsFopwiyI012l
                        Tmj0gIVC2nTCRiJxctRT7Hxiqtq+/PR1rLTzN/80uhN0nHGkHJKHtyJRojjkkwPR
                        1QugU3A5P569i6ZvncOYq7o5gpaPzmaR7el1h7z057oIiHPo+bSfhhnN8Lc1qo0D
                        BNkKhxLuC3W8yd0nndGzNYAKK1VCxL06zYIyyokrx/Q1+RSkKcvmcJcHVQRkSlh9
                        QSyoUTCGdVRcOugP1wXoPkAFFfjep8+xLNnS61Rb58O+P7Jr/0970eMz0ZlM16aq
                        P3jpyBy16vv/EVPsBcQR29W4Xl7ngJzXIXpWG8YKZ2n9zTOVhXQgdEevUhREIE8o
                        fsKA8NnAsKbaKixplR86HXCE3fLiJxICDHHfXDRxsAyDCAav7u1I6P0Z8MVaQWGx
                        XApyljlViaV1xDKgqhfMqKA488Butza5RV9/rJjDtcl/ANK5yza7tlSKYr0CAwEA
                        AQKCAgEAnrz71Smh9VRnU0Wn7LZlM85HKDybTLPk7OWz0kGYosEAXijqYBFiJlTW
                        PUghGWhaPvGYAVu/4p0OUZbDEpTtFR+HUE/Puxwv41xZ+O157B3p6zIMgOsPBz8j
                        xqW3NN58sqVCx5Jbftug8nAilUsXZvbVwru69WwCA3T5WJ73ug5nOvzqa+161XY7
                        k/xBVebrFXSg9IbosY7gE29oyAuc0NPOZpNcxchVGsQFnRWCPSWO6ULgHTNnLz+W
                        m+YNg/Na219FkBml0fxfd2Yjif/mORy2Ut8jP19SZz+OZR9zDvuHE0bUI79w9eYJ
                        0MUD6B0lo/1GxlpaLBUHkLJBdgFiIyJ6kbt0ol0TAL6oHxvK/m/6K8hKmlnsyf2J
                        OJV4ijzWotP9Ogwb2ZoXncRvD8m28MAYXbLOVVJEEWqxaGFti62CR7dDAZ3dNg8t
                        IotGC1OlYJlCuGIUvBQC9SHeaFCrRofEPKBJjpuYSpj1RmwR9LQIJLDg2xeiEMj8
                        3uiSZu81ygClaFaMwHiedV/gASSXYqhcVF9dvzvQ+M7oG8b7TLJ8MhWB+cUjA5we
                        Yq47uOSmW9wS1rid3YuHtsZEZ9wzXaaM8yX2ELlaJ3GiaMGB/ww/T0St8VEwdG9J
                        DKWWlcIFy2p1TlpA69G8nv7oI4Im3kLJlQa10/f44hQ7UaFOh8ECggEBAOb8rD+9
                        P1IGWPwbe1AG7U8PtbJs0g+jldJ/WIxG9T9hIhO5QTVBgQoSmBE6weedbO0EydVf
                        QIE1yJ8aRCukL5j5X1drXKJbbdC4z569aRPZwcRRdgQ3DbZImgK/JUwNaVwB6lMe
                        QLU84CXDPZAufakKKeBQvxXSJ+WqxlFh7adcRePwS70KtJuoLkP0/8AVIhZE79bj
                        pZxYBa7zD4UV9Dvyu0QWYnOVo29cCxgWiA61o8hZn0d5QFpe1fnuayNrzDNEttnb
                        8Mw7WhsbO7dAri7/SkCY16HyhWXXypEM6VcvdHSV5McqO+bo1Bnv1VPyPTLr38W/
                        8PlYB41DcJ8/HeMCggEBAPdgnOfZDRmByz8aKB6HJ6RM0tR837ak4KxVcXJ2RYPY
                        acF9ybS8rpE5LuP/lS2/qtHMT4aPqvNvPPl1gUw+mmrmzYLmhKgCyD0SiYqC1kH4
                        zlfODQTOe1ZdaGFbyIwrf8GhPPQmdiDqAzWsdIDv4WU/pJXlboAb4sTPVxSuGnAH
                        ZOHkWQRDBhjZp0ASMpNc+EgqBZ2MaKijxKuZQP9JX7Pi0Gzy6p2t0y03ZOUpL4QW
                        5RxET7Idr3jYua9Ckb9+Z+A/5xQE6XHv4BIwshW33Kdp147Jp3pUnwU/BWSKRo2a
                        cLFb5APcJxf17rzH17BzJ/wT/f/R5dqKqX0xDkXyXt8CggEBAKW+lRK/hxoid+Of
                        DKLl9Y6PpT88mpaiOTVsL2uo1v39guhIPCQstp01rmxejxjVe32vu+whhzWwFB8m
                        R9hQ3d6UwfcGkNfnZysoEcLEAww9aq6mDVsE7g/olKp34hlqXjmpHi06PhBOeEBg
                        kmJNGdob8uSEzDiqLfq8ycVH0bIPog7nNFGXxvUSfvBAcuuvvl/gY4D8pK9E8f8R
                        ZgeHM1N43ysCLO7nZvjXQRatxD9Z0wZGWOZ+eNDf0AahL7ug9EuteM9m5KiHxiZB
                        Kl5aSSJsCSnFAqWwUkw7xZzDeQQYhyXJEPpgsc8FLnzV/WtZHNTXMCDDk/Q3WGPj
                        CoMaVSUCggEBAO2hnjhNVXsaJo7QZpekx1zZ+3DpH9IIolaJoXgNywszGawoVFnN
                        IngYkUWtn7UZuFLey8n8OoCsa8tKqFEAlj94xRQosmfefFHGe99VfdJT2ouYQQNM
                        AkjdY8aab5TOuGPdqnryc2l8wmaN6kBtrnwfXdAsXDCuGPFsJz+TW4wgXjVssGIa
                        rEG02yf+Ex1iIpLX4xsL5QGSh/s7NafF6SwZBpSR6PRdJU37N223WZCumZnEuTXl
                        tEkHD6Ae93kXSVuupyCg80ti3UE8C+Y2/7zGPK5KYhpuLW/RsTF6bvnZ0MVe+zMG
                        CXvH4HTyF+zFQjSxU76p9/4uU1ASjp58i8sCggEBANdzShhwJnaxKW7e7hiLA5k1
                        G579ubQfDZy/UJOMeDzmrhpcVN5+cH5afFHMHQczzY0GkBkHz4zgN2euOY/Vh/RR
                        F+rwzwBisLKq2Oiwu5oPKLD5aIFxbOahzSI8N8Upk7J/pBGlFYeg/13bJtb1DrMV
                        tslxK8cJa2RFUesi2Jy9kz2bFaKIub8rSBCoXhLbccjZwV2W93oDOU44KnXauFvt
                        UJlFTRbTsf1YII46Zl4dFstWAb+R6DYHNU+xFpJpSVAeOW7R4i4pq7FKl1Xrr0nu
                        X7iTAH08FfZMzQxQ/jazDvc22rgMGbGuGkjHqFntiBsEkFDW9s3lMjrMy8xPcLk=
                        -----END RSA PRIVATE KEY-----""",
                        # Data to sign
                        "abc",
                        # Signature
                        '''70 1b 61 7e 96 cf b5 9e 59 af ed eb c2 b3 55 fd 
                        64 c2 6c b4 c7 ad 62 19 af ed f3 b0 82 fa 1d e7 
                        8f 6f 01 a1 74 67 48 9b a6 c0 ba 7f dc ce 91 49 
                        7c da d3 d0 aa c8 e9 4d be 9f ea 1f 62 0e 11 55 
                        4e 82 03 c3 fb 4a f4 ba d9 ab 08 e4 8f 07 ba f0 
                        ed 5d 6e f7 8b 27 9d 08 dd b4 36 b5 3b 89 b2 e0 
                        f3 43 b2 9b 4a e6 b1 03 b4 87 5d a9 58 3c 2b 6f 
                        fa 22 0c 28 d9 28 7a b6 c4 7f 03 f0 21 55 d0 be 
                        12 0a 8a e9 c5 3c e5 d2 6b e3 9a ce 92 87 e4 10 
                        5f e0 66 db 46 66 e5 72 be b4 3c d1 8e cf 1a ea 
                        ba 69 65 09 e9 a1 04 55 3c b5 92 87 57 97 00 cf 
                        47 20 e8 8a df 93 18 6a cf 2b d3 af 55 8f 55 d5 
                        78 a0 fa 27 e8 f5 f5 a6 3b b5 ec f1 c2 8d b5 f9 
                        68 de ca b4 e2 4a 00 cd f5 19 47 8e 36 f4 0e 4f 
                        5d 34 a3 ec 63 39 08 15 69 b2 83 6d f7 b0 99 3b 
                        b0 bf 2b e6 ae 9a 60 5b 43 e4 18 18 ec be 09 ba 
                        85 8a dc 77 75 cd c6 eb 98 d6 b0 9c de a4 d7 1a 
                        df 2c 3f aa 7c 52 ff 3e 0f 87 20 2b dd 93 92 49 
                        43 f8 b9 d4 8e de c5 3b 37 a5 ee 8c 68 cc 6d ff 
                        c6 98 c6 af 00 b8 f4 bf b7 7f 51 b0 53 a5 68 fb 
                        bf b2 62 57 2e cd 7c c0 0e cc 3e 69 3b a5 a2 bf 
                        3f ad c6 1b 66 39 57 71 e3 b7 c8 20 b6 51 46 58 
                        70 be 64 96 38 c4 e1 51 3b 63 68 3c 38 fb d4 b2 
                        60 ed 0f 2e b5 cf 1e 2c 9c ec 7f b9 19 51 3b 4c 
                        30 0d 74 a0 e6 f6 14 ea ff cd c5 2e 6a cd c2 f5 
                        53 3b f4 64 1a 44 9e 16 64 d6 82 f5 7d 1a 47 00 
                        51 04 90 1b 8e b7 91 d6 73 91 46 74 bd ea 08 86 
                        41 e4 f5 e5 04 61 f8 bd a4 b7 56 6a 0b a2 b3 ee 
                        00 f8 cc 04 28 36 de 99 05 2b e2 eb 92 ff 26 1d 
                        db 29 5a 72 51 a4 b7 f7 ea 5c 27 53 68 0d 89 8c 
                        1f 17 87 85 9c 1d 8d 42 b4 cb 42 49 c7 0c 1e df 
                        e0 8e ee e3 1e 77 5d 16 5f 75 31 1c 5c af 3e 02
                        ''',
                        # Salt
                        '''c8 e6 96 a2 a5 5b ab 2f eb b8 42 89 f8 de 0c 8d
                        8d 82 99 b8 25 b8 f2 35 73 2c 49 d4 d1 f3 04 4d''',
                        # Hash algorithm
                        SHA256
                        ),
                )

                self._testData = _testData
                self.rsa_parse = rsa_parse
                self.msg = msg

        def sign1_mytest(self):
                for i in range(len(self._testData)):
                        print("Test vector[%d]" %i)
                        # Build the key
                        if isStr(self._testData[i][0]):
                                print("pem")
                                key = RSA.importKey(self._testData[i][0])
                        else:
                                comps = [ long(rws(self._testData[i][0][x]),16) for x in ('n','e','d') ]
                                key = MyKey(RSA.construct(comps))
                        # Hash function
                        h = self._testData[i][4].new()
                        # Data to sign
                        try:
                                print("try")
                                h.update(t2b(self._testData[i][1]))
                        except:
                                print("except")
                                h.update(b(self._testData[i][1]))
                        # Salt
                        test_salt = t2b(self._testData[i][3])
                        key._randfunc = lambda N: test_salt
                        # The real test
                        signer = PKCS.new(key)
                        t_flag = signer.can_sign()
                        if t_flag:
                                print("mytest: can sign")
                        else:
                                print("mytest: can't sign")
                        s = signer.sign(h)
                        print("salt:")
                        #rsa_dump(test_salt)
                        rsa_dump(key._randfunc(test_salt))
                        print("signature:")
                        rsa_dump(s)

                        if s == t2b(self._testData[i][2]):
                                print("[Pass] RSA PSS signature compare pass")
                        else:
                                print("[Fail] PSA PSS signature compare fail")

        def sbc_rsa_sign1_json(self):
                row = self.rsa_parse
                # Build the key
                if isStr(row[0]):
                        print("pem")
                        key = RSA.importKey(row[0])
                else:
                        comps = [ long(rws(row[0][x]),16) for x in ('n','e','d') ]
                        key = MyKey(RSA.construct(comps))
                # Hash function
                if(row[4] == "SHA"):
                    h = SHA.new()
                elif(row[4] == "SHA256"):
                    h = SHA256.new()
                elif(row[4] == "SHA384"):
                    h = SHA384.new()
                elif(row[4] == "SHA512"):
                    h = SHA512.new()
                else:
                    h = SHA256.new()
                # Data to sign
                if(row[5] == 1):
                        try:
                                print("try")
                                h.update(t2b(row[1]))
                        except:
                                print("except")
                                h.update(b(row[1]))
                else:
                        h.update(self.msg)
                rsa_dump(h.digest())

                # Salt
                test_salt = t2b(row[3])
                key._randfunc = lambda N: test_salt
                # The real test
                signer = PKCS.new(key)
                t_flag = signer.can_sign()
                if t_flag:
                        print("mytest: can sign")
                else:
                        print("mytest: can't sign")
                s = signer.sign(h)
                print("salt:")
                #rsa_dump(test_salt)
                rsa_dump(key._randfunc(test_salt))
                print("signature:")
                rsa_dump(s)

                if s == t2b(row[2]):
                        print("[Pass] RSA PSS signature compare pass")
                else:
                        print("[Fail] PSA PSS signature compare fail")
                return s

        def verify1_mytest(self):
               for i in range(len(self._testData)):
                        print("Test vector[%d]" %i)
                        row = self._testData[i]
                        # Build the key
                        if isStr(row[0]):
                                key = RSA.importKey(row[0]).publickey()
                        else:
                                comps = [ long(rws(self._testData[i][0][x]),16) for x in ('n','e') ]
                                key = MyKey(RSA.construct(comps))
                        # Hash function
                        h = self._testData[i][4].new()
                        # Data to sign
                        try:
                                h.update(t2b(self._testData[i][1]))
                                # Salt
                                test_salt = t2b(self._testData[i][3])
                        except:
                                h.update(b(self._testData[i][1]))
                                # Salt
                                test_salt = b(self._testData[i][3])
                        # The real test
                        key._randfunc = lambda N: test_salt
                        verifier = PKCS.new(key)
                        t_flag = verifier.can_sign()
                        if t_flag:
                                print("mytest: can't verify")
                        else:
                                print("mytest: can verify")
                        result = verifier.verify(h, t2b(self._testData[i][2]))
                        if result:
                                print("[Pass] RSA PSS verify pass")
                        else:
                                print("[Fail] RSA PSS verify fail")


def get_tests(config={}):
    tests = []
    tests += list_test_cases(PKCS1_PSS_Tests)
    return tests

if __name__ == '__main__':
    suite = lambda: unittest.TestSuite(get_tests())
    unittest.main(defaultTest='suite')

# vim:set ts=4 sw=4 sts=4