github.com/hxx258456/ccgo@v0.0.5-0.20230213014102-48b35f46f66f/sm4soft/sm4_test.go (about)

     1  // Copyright 2022 s1ren@github.com/hxx258456.
     2  
     3  /*
     4  sm4soft 是sm4的纯软实现，基于tjfoc国密算法库`tjfoc/gmsm`做了少量修改。
     5  对应版权声明: thrid_licenses/github.com/tjfoc/gmsm/版权声明
     6  */
     7  
     8  package sm4soft
     9  
    10  import (
    11  	"fmt"
    12  	"reflect"
    13  	"testing"
    14  )
    15  
    16  func TestSM4(t *testing.T) {
    17  	// 定义密钥，16字节
    18  	key := []byte("abcdef1234567890")
    19  	fmt.Printf("key字节数组 : %v\n", key)
    20  	fmt.Printf("key字符串 : %s\n", key)
    21  
    22  	// 将key写入key.pem
    23  	err := WriteKeyToPemFile("testdata/key.pem", key, nil)
    24  	if err != nil {
    25  		t.Fatalf("WriteKeyToPem error")
    26  	}
    27  	// 读取key.pem
    28  	key, err = ReadKeyFromPemFile("testdata/key.pem", nil)
    29  	fmt.Printf("读取到的key字节数组 : %v\n", key)
    30  	fmt.Printf("读取到的key字符串 : %s\n", key)
    31  	if err != nil {
    32  		t.Fatal(err)
    33  	}
    34  
    35  	// 定义数据
    36  	// data := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}
    37  	data := []byte("天行健君子以自强不息")
    38  	fmt.Printf("data字节数组 : %v\n", data)
    39  	fmt.Printf("data十六进制 : %x\n", data)
    40  	fmt.Printf("data字符串 : %s\n", data)
    41  
    42  	// ECB模式加密
    43  	ecbMsg, err := Sm4Ecb(key, data, true)
    44  	if err != nil {
    45  		t.Errorf("sm4 enc error:%s", err)
    46  		return
    47  	}
    48  	fmt.Printf("ecbMsg 16进制 : %x\n", ecbMsg)
    49  	// ECB模式解密
    50  	ecbDec, err := Sm4Ecb(key, ecbMsg, false)
    51  	if err != nil {
    52  		t.Errorf("sm4 dec error:%s", err)
    53  		return
    54  	}
    55  	fmt.Printf("ecbDec : %s\n", ecbDec)
    56  	if !testCompare(data, ecbDec) {
    57  		t.Errorf("sm4 self enc and dec failed")
    58  	}
    59  
    60  	// 定义初始化向量，16字节
    61  	// iv := []byte("0000000000000000")
    62  	iv := []byte("1234def567890abc")
    63  	// err = SetIVDefault(iv)
    64  	fmt.Printf("err = %v\n", err)
    65  	fmt.Printf("iv字节数组 : %v\n", iv)
    66  	fmt.Printf("iv16进制 : %x\n", iv)
    67  	fmt.Printf("iv字符串 : %s\n", iv)
    68  
    69  	// CBC模式加密
    70  	cbcMsg, err := Sm4Cbc(key, iv, data, true)
    71  	if err != nil {
    72  		t.Errorf("sm4 enc error:%s", err)
    73  	}
    74  	fmt.Printf("cbcMsg 16进制 : %x\n", cbcMsg)
    75  	// CBC模式解密
    76  	cbcDec, err := Sm4Cbc(key, iv, cbcMsg, false)
    77  	if err != nil {
    78  		t.Errorf("sm4 dec error:%s", err)
    79  		return
    80  	}
    81  	fmt.Printf("cbcDec : %s\n", cbcDec)
    82  	if !testCompare(data, cbcDec) {
    83  		t.Errorf("sm4 self enc and dec failed")
    84  	}
    85  
    86  	// CFB模式加密
    87  	cfbMsg, err := Sm4CFB(key, iv, data, true)
    88  	if err != nil {
    89  		t.Errorf("sm4 enc error:%s", err)
    90  	}
    91  	fmt.Printf("cfbMsg 16进制 : %x\n", cfbMsg)
    92  	// CFB模式解密
    93  	cfbDec, err := Sm4CFB(key, iv, cfbMsg, false)
    94  	if err != nil {
    95  		t.Errorf("sm4 dec error:%s", err)
    96  		return
    97  	}
    98  	fmt.Printf("cfbDec : %s\n", cfbDec)
    99  
   100  	// OFB模式加密
   101  	ofbMsg, err := Sm4OFB(key, iv, data, true)
   102  	if err != nil {
   103  		t.Errorf("sm4 enc error:%s", err)
   104  	}
   105  	fmt.Printf("ofbMsg 16进制 : %x\n", ofbMsg)
   106  	// OFB模式解密
   107  	ofbDec, err := Sm4OFB(key, iv, ofbMsg, false)
   108  	if err != nil {
   109  		t.Errorf("sm4 dec error:%s", err)
   110  		return
   111  	}
   112  	fmt.Printf("ofbDec : %s\n", ofbDec)
   113  }
   114  
   115  func TestNewCipher(t *testing.T) {
   116  	key := []byte("1234567890abcdef")
   117  	// 直接用NewCipher只能对16字节的数据加密
   118  	data := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}
   119  	// data := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32}
   120  	c, err := NewCipher(key)
   121  	if err != nil {
   122  		t.Fatal(err)
   123  	}
   124  	d0 := make([]byte, 16)
   125  	c.Encrypt(d0, data)
   126  	d1 := make([]byte, 16)
   127  	c.Decrypt(d1, d0)
   128  }
   129  
   130  func BenchmarkSM4(t *testing.B) {
   131  	t.ReportAllocs()
   132  	key := []byte("1234567890abcdef")
   133  	data := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10}
   134  	err := WriteKeyToPemFile("key.pem", key, nil)
   135  	if err != nil {
   136  		t.Fatalf("WriteKeyToPem error")
   137  	}
   138  	key, err = ReadKeyFromPemFile("key.pem", nil)
   139  	if err != nil {
   140  		t.Fatal(err)
   141  	}
   142  	c, err := NewCipher(key)
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  
   147  	for i := 0; i < t.N; i++ {
   148  		d0 := make([]byte, 16)
   149  		c.Encrypt(d0, data)
   150  		d1 := make([]byte, 16)
   151  		c.Decrypt(d1, d0)
   152  	}
   153  }
   154  
   155  func TestErrKeyLen(t *testing.T) {
   156  	fmt.Printf("\n--------------test key len------------------")
   157  	key := []byte("1234567890abcdefg")
   158  	_, err := NewCipher(key)
   159  	if err != nil {
   160  		fmt.Println("\nError key len !")
   161  	}
   162  	key = []byte("1234")
   163  	_, err = NewCipher(key)
   164  	if err != nil {
   165  		fmt.Println("Error key len !")
   166  	}
   167  	fmt.Println("------------------end----------------------")
   168  }
   169  
   170  func testCompare(key1, key2 []byte) bool {
   171  	if len(key1) != len(key2) {
   172  		return false
   173  	}
   174  	for i, v := range key1 {
   175  		if i == 1 {
   176  			fmt.Println("type of v", reflect.TypeOf(v))
   177  		}
   178  		a := key2[i]
   179  		if a != v {
   180  			return false
   181  		}
   182  	}
   183  	return true
   184  }