github.com/PandaGoAdmin/utils@v0.0.0-20211208134815-d5461603a00f/encrypt_test.go (about)

     1  package kgo
     2  
     3  import (
     4  	"github.com/stretchr/testify/assert"
     5  	"io/ioutil"
     6  	"testing"
     7  )
     8  
     9  func TestEncrypt_Base64Encode(t *testing.T) {
    10  	var res []byte
    11  
    12  	res = KEncr.Base64Encode(bytEmp)
    13  	assert.Nil(t, res)
    14  
    15  	res = KEncr.Base64Encode(bytsHello)
    16  	assert.Contains(t, string(res), "=")
    17  }
    18  
    19  func BenchmarkEncrypt_Base64Encode(b *testing.B) {
    20  	b.ResetTimer()
    21  	for i := 0; i < b.N; i++ {
    22  		KEncr.Base64Encode(bytsHello)
    23  	}
    24  }
    25  
    26  func TestEncrypt_Base64Decode(t *testing.T) {
    27  	var res []byte
    28  	var err error
    29  
    30  	res, err = KEncr.Base64Decode(bytEmp)
    31  	assert.Nil(t, res)
    32  	assert.Nil(t, err)
    33  
    34  	res, err = KEncr.Base64Decode([]byte(b64Hello))
    35  	assert.Equal(t, strHello, string(res))
    36  
    37  	//不合法
    38  	_, err = KEncr.Base64Decode([]byte("#iu3498r"))
    39  	assert.NotNil(t, err)
    40  }
    41  
    42  func BenchmarkEncrypt_Base64Decode(b *testing.B) {
    43  	b.ResetTimer()
    44  	bs := []byte(b64Hello)
    45  	for i := 0; i < b.N; i++ {
    46  		_, _ = KEncr.Base64Decode(bs)
    47  	}
    48  }
    49  
    50  func TestEncrypt_Base64UrlEncode(t *testing.T) {
    51  	var res []byte
    52  
    53  	res = KEncr.Base64UrlEncode(bytEmp)
    54  	assert.Nil(t, res)
    55  
    56  	res = KEncr.Base64UrlEncode([]byte(str2Code))
    57  	assert.Equal(t, b64UrlCode, string(res))
    58  }
    59  
    60  func BenchmarkEncrypt_Base64UrlEncode(b *testing.B) {
    61  	b.ResetTimer()
    62  	bs := []byte(str2Code)
    63  	for i := 0; i < b.N; i++ {
    64  		KEncr.Base64UrlEncode(bs)
    65  	}
    66  }
    67  
    68  func TestEncrypt_Base64UrlDecode(t *testing.T) {
    69  	var res []byte
    70  	var err error
    71  
    72  	res, err = KEncr.Base64UrlDecode(bytEmp)
    73  	assert.Nil(t, res)
    74  	assert.Nil(t, err)
    75  
    76  	res, err = KEncr.Base64UrlDecode([]byte(b64UrlCode))
    77  	assert.Equal(t, str2Code, string(res))
    78  
    79  	//不合法
    80  	_, err = KEncr.Base64UrlDecode([]byte("#iu3498r"))
    81  	assert.NotNil(t, err)
    82  }
    83  
    84  func BenchmarkEncrypt_Base64UrlDecode(b *testing.B) {
    85  	b.ResetTimer()
    86  	bs := []byte(b64UrlCode)
    87  	for i := 0; i < b.N; i++ {
    88  		_, _ = KEncr.Base64UrlDecode(bs)
    89  	}
    90  }
    91  
    92  func TestEncrypt_AuthCode(t *testing.T) {
    93  	var res, res2 []byte
    94  	var exp int64
    95  
    96  	res, exp = KEncr.AuthCode(bytsHello, bytSpeedLight, true, 0)
    97  	assert.NotNil(t, res)
    98  
    99  	res2, exp = KEncr.AuthCode(res, bytSpeedLight, false, 0)
   100  	assert.Equal(t, string(bytsHello), string(res2))
   101  
   102  	//过期
   103  	res, exp = KEncr.AuthCode(bytsHello, bytSpeedLight, true, -3600)
   104  	res2, exp = KEncr.AuthCode(res, bytSpeedLight, false, 0)
   105  	assert.Empty(t, res2)
   106  	assert.Greater(t, exp, int64(0))
   107  
   108  	//空串
   109  	res, exp = KEncr.AuthCode(bytEmp, bytSpeedLight, true, 0)
   110  	assert.Empty(t, res)
   111  
   112  	//空密钥
   113  	res, exp = KEncr.AuthCode(bytsHello, bytEmp, true, 0)
   114  	assert.NotEmpty(t, res)
   115  
   116  	//不合法
   117  	KEncr.AuthCode([]byte("7caeNfPt/N1zHdj5k/7i7pol6NHsVs0Cji7c15h4by1RYcrBoo7EEw=="), bytSpeedLight, false, 0)
   118  	KEncr.AuthCode([]byte("7caeNfPt/N1zHdj5k/7i7pol6N"), bytSpeedLight, false, 0)
   119  	KEncr.AuthCode([]byte("123456"), bytEmp, false, 0)
   120  	KEncr.AuthCode([]byte("1234#iu3498r"), bytEmp, false, 0)
   121  }
   122  
   123  func BenchmarkEncrypt_AuthCode_Encode(b *testing.B) {
   124  	b.ResetTimer()
   125  	for i := 0; i < b.N; i++ {
   126  		KEncr.AuthCode(bytsHello, bytSpeedLight, true, 0)
   127  	}
   128  }
   129  
   130  func BenchmarkEncrypt_AuthCode_Decode(b *testing.B) {
   131  	b.ResetTimer()
   132  	bs := []byte("b0140641v309wJW2_-MvoovhaHKtHLBvZ2JFsvirqYQK5144m-wQJlez8XBfHkCohr3clxPR")
   133  	for i := 0; i < b.N; i++ {
   134  		KEncr.AuthCode(bs, bytSpeedLight, false, 0)
   135  	}
   136  }
   137  
   138  func TestEncrypt_PasswordHash(t *testing.T) {
   139  	var res []byte
   140  	var err error
   141  
   142  	//空密码
   143  	res, err = KEncr.PasswordHash(bytEmp)
   144  	assert.NotNil(t, res)
   145  	assert.Nil(t, err)
   146  
   147  	res, err = KEncr.PasswordHash(bytsHello)
   148  	assert.NotEmpty(t, res)
   149  
   150  	//慎用20以上,太耗时
   151  	_, _ = KEncr.PasswordHash(bytsHello, 1)
   152  	_, _ = KEncr.PasswordHash(bytsHello, 33)
   153  }
   154  
   155  func BenchmarkEncrypt_PasswordHash(b *testing.B) {
   156  	b.ResetTimer()
   157  	for i := 0; i < b.N; i++ {
   158  		_, _ = KEncr.PasswordHash(bytsHello)
   159  	}
   160  }
   161  
   162  func TestEncrypt_PasswordVerify(t *testing.T) {
   163  	var res bool
   164  
   165  	res = KEncr.PasswordVerify(bytsHello, bytsPasswd)
   166  	assert.True(t, res)
   167  
   168  	res = KEncr.PasswordVerify(bytSpeedLight, bytsPasswd)
   169  	assert.False(t, res)
   170  }
   171  
   172  func BenchmarkEncrypt_PasswordVerify(b *testing.B) {
   173  	b.ResetTimer()
   174  	for i := 0; i < b.N; i++ {
   175  		KEncr.PasswordVerify(bytsHello, bytsPasswd)
   176  	}
   177  }
   178  
   179  func TestEncrypt_EasyEncryptDecrypt(t *testing.T) {
   180  	var enc, dec []byte
   181  
   182  	enc = KEncr.EasyEncrypt(bytsHello, bytSpeedLight)
   183  	assert.NotEmpty(t, enc)
   184  
   185  	dec = KEncr.EasyDecrypt(enc, bytSpeedLight)
   186  	assert.Equal(t, bytsHello, dec)
   187  
   188  	//空字符串
   189  	enc = KEncr.EasyEncrypt(bytEmp, bytSpeedLight)
   190  	assert.Empty(t, enc)
   191  
   192  	//空密钥
   193  	enc = KEncr.EasyEncrypt(bytsHello, bytEmp)
   194  	assert.NotEmpty(t, enc)
   195  
   196  	//密钥错误
   197  	dec = KEncr.EasyDecrypt(enc, bytSpeedLight)
   198  	assert.Empty(t, dec)
   199  
   200  	//密文错误
   201  	dec = KEncr.EasyDecrypt(bytsHello, bytSpeedLight)
   202  	assert.Empty(t, dec)
   203  	dec = KEncr.EasyDecrypt([]byte("1234#iu3498r"), bytSpeedLight)
   204  	assert.Empty(t, dec)
   205  }
   206  
   207  func BenchmarkEncrypt_EasyEncrypt(b *testing.B) {
   208  	b.ResetTimer()
   209  	for i := 0; i < b.N; i++ {
   210  		KEncr.EasyEncrypt(bytsHello, bytSpeedLight)
   211  	}
   212  }
   213  
   214  func BenchmarkEncrypt_EasyDecrypt(b *testing.B) {
   215  	b.ResetTimer()
   216  	bs := []byte(esyenCode)
   217  	for i := 0; i < b.N; i++ {
   218  		KEncr.EasyDecrypt(bs, bytSpeedLight)
   219  	}
   220  }
   221  
   222  func TestEncrypt_HmacShaX(t *testing.T) {
   223  	defer func() {
   224  		r := recover()
   225  		assert.NotEmpty(t, r)
   226  	}()
   227  
   228  	var res []byte
   229  
   230  	res = KEncr.HmacShaX(bytsHello, bytSpeedLight, 1)
   231  	assert.NotEmpty(t, res)
   232  
   233  	res = KEncr.HmacShaX(bytsHello, bytSpeedLight, 256)
   234  	assert.NotEmpty(t, res)
   235  
   236  	res = KEncr.HmacShaX(bytsHello, bytSpeedLight, 512)
   237  	assert.NotEmpty(t, res)
   238  
   239  	//不合法
   240  	KEncr.HmacShaX(bytsHello, bytSpeedLight, 44)
   241  }
   242  
   243  func BenchmarkEncrypt_HmacShaX(b *testing.B) {
   244  	b.ResetTimer()
   245  	for i := 0; i < b.N; i++ {
   246  		KEncr.HmacShaX(bytsHello, bytSpeedLight, 256)
   247  	}
   248  }
   249  
   250  func TestEncrypt_AesCBCEncryptDecrypt(t *testing.T) {
   251  	var err error
   252  	var enc, des, des2 []byte
   253  
   254  	//加密
   255  	enc, err = KEncr.AesCBCEncrypt(bytsHello, bytCryptKey)
   256  	assert.Nil(t, err)
   257  	assert.NotEmpty(t, enc)
   258  
   259  	//解密
   260  	des, err = KEncr.AesCBCDecrypt(enc, bytCryptKey)
   261  	assert.Equal(t, bytsHello, des)
   262  
   263  	//密钥不合法
   264  	_, err = KEncr.AesCBCEncrypt(bytsHello, bytSpeedLight)
   265  	assert.NotNil(t, err)
   266  
   267  	//错误的密钥
   268  	des2, err = KEncr.AesCBCDecrypt(enc, []byte("1234561234567890"))
   269  	assert.NotEqual(t, bytsHello, des2)
   270  
   271  	//填充方式-PKCS_SEVEN
   272  	enc, _ = KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_SEVEN)
   273  	des, _ = KEncr.AesCBCDecrypt(enc, bytCryptKey, PKCS_SEVEN)
   274  	assert.NotEmpty(t, enc)
   275  	assert.Equal(t, bytsHello, des)
   276  
   277  	//填充方式-PKCS_ZERO
   278  	enc, _ = KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_ZERO)
   279  	des, _ = KEncr.AesCBCDecrypt(enc, bytCryptKey, PKCS_ZERO)
   280  	assert.NotEmpty(t, enc)
   281  	assert.Equal(t, bytsHello, des)
   282  
   283  	//空字符串
   284  	enc, err = KEncr.AesCBCEncrypt(bytEmp, bytCryptKey)
   285  	des, err = KEncr.AesCBCDecrypt(enc, bytCryptKey)
   286  	assert.NotEmpty(t, enc)
   287  	assert.Empty(t, des)
   288  
   289  	//错误的加密串
   290  	enc = []byte{83, 28, 170, 254, 29, 174, 21, 129, 241, 233, 243, 84, 1, 250, 95, 122, 104, 101, 108, 108, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   291  	des, err = KEncr.AesCBCDecrypt(enc, bytCryptKey, PKCS_ZERO)
   292  	assert.NotEqual(t, bytsHello, des)
   293  }
   294  
   295  func BenchmarkEncrypt_AesCBCEncrypt_PKCS_SEVEN(b *testing.B) {
   296  	b.ResetTimer()
   297  	for i := 0; i < b.N; i++ {
   298  		_, _ = KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_SEVEN)
   299  	}
   300  }
   301  
   302  func BenchmarkEncrypt_AesCBCDecrypt_PKCS_SEVEN(b *testing.B) {
   303  	b.ResetTimer()
   304  	bs, _ := KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_SEVEN)
   305  	for i := 0; i < b.N; i++ {
   306  		_, _ = KEncr.AesCBCDecrypt(bs, bytCryptKey, PKCS_SEVEN)
   307  	}
   308  }
   309  
   310  func BenchmarkEncrypt_AesCBCEncrypt_PKCS_ZERO(b *testing.B) {
   311  	b.ResetTimer()
   312  	for i := 0; i < b.N; i++ {
   313  		_, _ = KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_ZERO)
   314  	}
   315  }
   316  
   317  func BenchmarkEncrypt_AesCBCDecrypt_PKCS_ZERO(b *testing.B) {
   318  	b.ResetTimer()
   319  	bs, _ := KEncr.AesCBCEncrypt(bytsHello, bytCryptKey, PKCS_ZERO)
   320  	for i := 0; i < b.N; i++ {
   321  		_, _ = KEncr.AesCBCDecrypt(bs, bytCryptKey, PKCS_ZERO)
   322  	}
   323  }
   324  
   325  func TestEncrypt_AesCFBEncryptDecrypt(t *testing.T) {
   326  	var err error
   327  	var enc, des, des2 []byte
   328  
   329  	//加密
   330  	enc, err = KEncr.AesCFBEncrypt(bytsHello, bytCryptKey)
   331  	assert.Nil(t, err)
   332  	assert.NotEmpty(t, enc)
   333  
   334  	//解密
   335  	des, err = KEncr.AesCFBDecrypt(enc, bytCryptKey)
   336  	assert.Equal(t, bytsHello, des)
   337  
   338  	//密钥不合法
   339  	_, err = KEncr.AesCFBEncrypt(bytsHello, bytSpeedLight)
   340  	assert.NotNil(t, err)
   341  
   342  	//错误的密钥
   343  	des2, err = KEncr.AesCFBDecrypt(enc, []byte("1234561234567890"))
   344  	assert.NotEqual(t, bytsHello, des2)
   345  
   346  	//空字符串
   347  	enc, err = KEncr.AesCFBEncrypt(bytEmp, bytCryptKey)
   348  	des, err = KEncr.AesCFBDecrypt(enc, bytCryptKey)
   349  	assert.NotEmpty(t, enc)
   350  	assert.Empty(t, des)
   351  
   352  	//错误的加密串
   353  	enc = []byte{83, 28, 170, 254, 29, 174, 21, 129, 241, 233, 243, 84, 1, 250, 95, 122, 104, 101, 108, 108, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   354  	des, err = KEncr.AesCFBDecrypt(enc, bytCryptKey)
   355  	assert.NotEqual(t, bytsHello, des)
   356  }
   357  
   358  func BenchmarkEncrypt_AesCFBEncrypt(b *testing.B) {
   359  	b.ResetTimer()
   360  	for i := 0; i < b.N; i++ {
   361  		_, _ = KEncr.AesCFBEncrypt(bytsHello, bytCryptKey)
   362  	}
   363  }
   364  
   365  func BenchmarkEncrypt_AesCFBDecrypt(b *testing.B) {
   366  	b.ResetTimer()
   367  	bs, _ := KEncr.AesCFBEncrypt(bytsHello, bytCryptKey)
   368  	for i := 0; i < b.N; i++ {
   369  		_, _ = KEncr.AesCFBDecrypt(bs, bytCryptKey)
   370  	}
   371  }
   372  
   373  func TestEncrypt_AesCTREncryptDecrypt(t *testing.T) {
   374  	var err error
   375  	var enc, des, des2 []byte
   376  
   377  	//加密
   378  	enc, err = KEncr.AesCTREncrypt(bytsHello, bytCryptKey)
   379  	assert.Nil(t, err)
   380  	assert.NotEmpty(t, enc)
   381  
   382  	//解密
   383  	des, err = KEncr.AesCTRDecrypt(enc, bytCryptKey)
   384  	assert.Equal(t, bytsHello, des)
   385  
   386  	//密钥不合法
   387  	_, err = KEncr.AesCTREncrypt(bytsHello, bytSpeedLight)
   388  	assert.NotNil(t, err)
   389  
   390  	//错误的密钥
   391  	des2, err = KEncr.AesCTRDecrypt(enc, []byte("1234561234567890"))
   392  	assert.NotEqual(t, bytsHello, des2)
   393  
   394  	//空字符串
   395  	enc, err = KEncr.AesCTREncrypt(bytEmp, bytCryptKey)
   396  	des, err = KEncr.AesCTRDecrypt(enc, bytCryptKey)
   397  	assert.NotEmpty(t, enc)
   398  	assert.Empty(t, des)
   399  
   400  	//错误的加密串
   401  	enc = []byte{83, 28, 170, 254, 29, 174, 21, 129, 241, 233, 243, 84, 1, 250, 95, 122, 104, 101, 108, 108, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   402  	des, err = KEncr.AesCTRDecrypt(enc, bytCryptKey)
   403  	assert.NotEqual(t, bytsHello, des)
   404  }
   405  
   406  func BenchmarkEncrypt_AesCTREncrypt(b *testing.B) {
   407  	b.ResetTimer()
   408  	for i := 0; i < b.N; i++ {
   409  		_, _ = KEncr.AesCTREncrypt(bytsHello, bytCryptKey)
   410  	}
   411  }
   412  
   413  func BenchmarkEncrypt_AesCTRDecrypt(b *testing.B) {
   414  	b.ResetTimer()
   415  	bs, _ := KEncr.AesCTREncrypt(bytsHello, bytCryptKey)
   416  	for i := 0; i < b.N; i++ {
   417  		_, _ = KEncr.AesCTRDecrypt(bs, bytCryptKey)
   418  	}
   419  }
   420  
   421  func TestEncrypt_AesOFBEncryptDecrypt(t *testing.T) {
   422  	var err error
   423  	var enc, des, des2 []byte
   424  
   425  	//加密
   426  	enc, err = KEncr.AesOFBEncrypt(bytsHello, bytCryptKey)
   427  	assert.Nil(t, err)
   428  	assert.NotEmpty(t, enc)
   429  
   430  	//解密
   431  	des, err = KEncr.AesOFBDecrypt(enc, bytCryptKey)
   432  	assert.Equal(t, bytsHello, des)
   433  
   434  	//密钥不合法
   435  	_, err = KEncr.AesOFBEncrypt(bytsHello, bytSpeedLight)
   436  	assert.NotNil(t, err)
   437  
   438  	//错误的密钥
   439  	des2, err = KEncr.AesOFBDecrypt(enc, []byte("1234561234567890"))
   440  	assert.NotEqual(t, bytsHello, des2)
   441  
   442  	//空字符串
   443  	enc, err = KEncr.AesOFBEncrypt(bytEmp, bytCryptKey)
   444  	des, err = KEncr.AesOFBDecrypt(enc, bytCryptKey)
   445  	assert.NotEmpty(t, enc)
   446  	assert.Empty(t, des)
   447  
   448  	//错误的加密串
   449  	enc = []byte{83, 28, 170, 254, 29, 174, 21, 129, 241, 233, 243, 84, 1, 250, 95, 122, 104, 101, 108, 108, 111, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   450  	des, err = KEncr.AesOFBDecrypt(enc, bytCryptKey)
   451  	assert.NotEqual(t, bytsHello, des)
   452  }
   453  
   454  func BenchmarkEncrypt_AesOFBEncrypt(b *testing.B) {
   455  	b.ResetTimer()
   456  	for i := 0; i < b.N; i++ {
   457  		_, _ = KEncr.AesOFBEncrypt(bytsHello, bytCryptKey)
   458  	}
   459  }
   460  
   461  func BenchmarkEncrypt_AesOFBDecrypt(b *testing.B) {
   462  	b.ResetTimer()
   463  	bs, _ := KEncr.AesOFBEncrypt(bytsHello, bytCryptKey)
   464  	for i := 0; i < b.N; i++ {
   465  		_, _ = KEncr.AesOFBDecrypt(bs, bytCryptKey)
   466  	}
   467  }
   468  
   469  func TestEncrypt_GenerateRsaKeys(t *testing.T) {
   470  	var private, public []byte
   471  	var err error
   472  
   473  	private, public, err = KEncr.GenerateRsaKeys(1024)
   474  	assert.NotEmpty(t, private)
   475  	assert.NotEmpty(t, public)
   476  	assert.Nil(t, err)
   477  
   478  	private, public, err = KEncr.GenerateRsaKeys(2048)
   479  	assert.NotEmpty(t, private)
   480  	assert.NotEmpty(t, public)
   481  	assert.Nil(t, err)
   482  
   483  	//错误的密钥位数
   484  	private, public, err = KEncr.GenerateRsaKeys(1)
   485  	assert.NotNil(t, err)
   486  }
   487  
   488  func BenchmarkEncrypt_GenerateRsaKeys(b *testing.B) {
   489  	b.ResetTimer()
   490  	for i := 0; i < b.N; i++ {
   491  		_, _, _ = KEncr.GenerateRsaKeys(1024)
   492  	}
   493  }
   494  
   495  func TestEncrypt_RsaPublicEncryptPrivateDecrypt(t *testing.T) {
   496  	var enc, des []byte
   497  	var err error
   498  
   499  	pubFileBs, _ := ioutil.ReadFile(filePubPem)
   500  	priFileBs, _ := ioutil.ReadFile(filePriPem)
   501  
   502  	//公钥加密
   503  	enc, err = KEncr.RsaPublicEncrypt(bytsHello, pubFileBs)
   504  	assert.NotEmpty(t, enc)
   505  	assert.Nil(t, err)
   506  
   507  	//私钥解密
   508  	des, err = KEncr.RsaPrivateDecrypt(enc, priFileBs)
   509  	assert.NotEmpty(t, des)
   510  	assert.Nil(t, err)
   511  	assert.Equal(t, bytsHello, des)
   512  
   513  	//错误的公钥
   514  	_, err = KEncr.RsaPublicEncrypt(bytsHello, bytSpeedLight)
   515  	assert.NotNil(t, err)
   516  
   517  	_, err = KEncr.RsaPublicEncrypt(bytsHello, []byte(rsaPublicErrStr))
   518  	assert.NotNil(t, err)
   519  
   520  	//错误的私钥
   521  	_, err = KEncr.RsaPrivateDecrypt(enc, bytSpeedLight)
   522  	assert.NotNil(t, err)
   523  
   524  	_, err = KEncr.RsaPrivateDecrypt(enc, []byte(rsaPrivateErrStr))
   525  	assert.NotNil(t, err)
   526  }
   527  
   528  func BenchmarkEncrypt_RsaPublicEncrypt(b *testing.B) {
   529  	b.ResetTimer()
   530  	pubFileBs, _ := ioutil.ReadFile(filePubPem)
   531  	for i := 0; i < b.N; i++ {
   532  		_, _ = KEncr.RsaPublicEncrypt(bytsHello, pubFileBs)
   533  	}
   534  }
   535  
   536  func BenchmarkEncrypt_RsaPrivateDecrypt(b *testing.B) {
   537  	b.ResetTimer()
   538  	pubFileBs, _ := ioutil.ReadFile(filePubPem)
   539  	priFileBs, _ := ioutil.ReadFile(filePriPem)
   540  	enc, _ := KEncr.RsaPublicEncrypt(bytsHello, pubFileBs)
   541  	for i := 0; i < b.N; i++ {
   542  		_, _ = KEncr.RsaPrivateDecrypt(enc, priFileBs)
   543  	}
   544  }
   545  
   546  func TestEncrypt_RsaPrivateEncryptPublicDecrypt(t *testing.T) {
   547  	var enc, des []byte
   548  	var err error
   549  
   550  	pubFileBs, _ := ioutil.ReadFile(filePubPem)
   551  	priFileBs, _ := ioutil.ReadFile(filePriPem)
   552  
   553  	//私钥加密
   554  	enc, err = KEncr.RsaPrivateEncrypt(bytsHello, priFileBs)
   555  	assert.NotEmpty(t, enc)
   556  	assert.Nil(t, err)
   557  
   558  	//公钥解密
   559  	des, err = KEncr.RsaPublicDecrypt(enc, pubFileBs)
   560  	assert.NotEmpty(t, des)
   561  	assert.Nil(t, err)
   562  	assert.Equal(t, bytsHello, des)
   563  
   564  	//错误的私钥
   565  	_, err = KEncr.RsaPrivateEncrypt(bytsHello, bytSpeedLight)
   566  	assert.NotNil(t, err)
   567  
   568  	_, err = KEncr.RsaPrivateEncrypt(bytsHello, []byte(rsaPrivateErrStr))
   569  	assert.NotNil(t, err)
   570  
   571  	//错误的公钥
   572  	_, err = KEncr.RsaPublicDecrypt(enc, bytSpeedLight)
   573  	assert.NotNil(t, err)
   574  
   575  	_, err = KEncr.RsaPublicDecrypt(enc, []byte(rsaPublicErrStr))
   576  	assert.NotNil(t, err)
   577  }
   578  
   579  func BenchmarkEncrypt_RsaPrivateEncrypt(b *testing.B) {
   580  	b.ResetTimer()
   581  	priFileBs, _ := ioutil.ReadFile(filePriPem)
   582  	for i := 0; i < b.N; i++ {
   583  		_, _ = KEncr.RsaPrivateEncrypt(bytsHello, priFileBs)
   584  	}
   585  }
   586  
   587  func BenchmarkEncrypt_RsaPublicDecrypt(b *testing.B) {
   588  	b.ResetTimer()
   589  	pubFileBs, _ := ioutil.ReadFile(filePubPem)
   590  	priFileBs, _ := ioutil.ReadFile(filePriPem)
   591  	enc, _ := KEncr.RsaPrivateEncrypt(bytsHello, priFileBs)
   592  	for i := 0; i < b.N; i++ {
   593  		_, _ = KEncr.RsaPublicDecrypt(enc, pubFileBs)
   594  	}
   595  }