trisia / gotlcp Goto Github PK

Go语言实现的传输层密码协议(TLCP GMSSL)，TLCP协议遵循 GB/T 38636-2020 Information security technology Transport Layer Cryptography Protocol (TLCP)

Home Page: https://trisia.github.io/gotlcp/

License: MIT License

Go 100.00%

gotlcp's People

Contributors

Stargazers

Watchers

Forkers

emmansun husjdodoanthing zmoli775 twangjie tobysunx zfg88287508 iamnotsofun 2035go nyx2022 macdowlod bravohaha braveloveeric fzzf678 xiaoxiaoxioayu

gotlcp's Issues

ConfirmResponder和RepondKeyExchange返回的切片内容为签名，如果选择不生成签名，则为nil

gotlcp/tlcp/key_schedule.go

Line 60 in 06c153c

return s.ke.ConfirmResponder(responseTmpPubKey, nil)

gotlcp/tlcp/key_schedule.go

Line 69 in 06c153c

return s.ke.RepondKeyExchange(s.rd, sponsorTmpPubKey)

shared key需要调用GetSharedKey()方法获取。

RequireAndVerifyClientCert error

Greetings!

I'm trying to configure TLCP to work like standard TLS, with just one key and one certificate for each side. It happens that I get an error message referring to cipher suites: "server: handshake failed: tlcp: no cipher suite supported by both client and server".

Can anyone point me out what's wrong with my code please?

package main

import (
	"bufio"
	"bytes"
	"crypto/rand"
	"encoding/pem"
	"errors"
	"flag"
	"fmt"
	"log"
	"net"
	"os"

	"gitee.com/Trisia/gotlcp/tlcp"
	"github.com/emmansun/gmsm/smx509"
)
var (
	cert      = flag.String("cert", "Certificate.pem", "Certificate path.")
	tcpip     = flag.String("tcp", "", "Encrypted TCP Transfer Protocol. [server|client]")
	key       = flag.String("key", "", "`Private key.")
	iport     = flag.String("ipport", "", "Local Port/remote's side Public IP:Port.")
)

func handleConnection(c net.Conn) {
	log.Printf("Client(TLS) %v connected via secure channel.", c.RemoteAddr())
}

func main() {
	flag.Parse()
	if (*tcpip == "server" || *tcpip == "client") {
		var certPEM []byte 
		var privPEM []byte

		file, err := os.Open(*key)
		if err != nil {
			log.Fatal(err)
		}
		info, err := file.Stat()
		if err != nil {
			log.Fatal(err)
		}
		buf := make([]byte, info.Size())
		file.Read(buf)

		var block *pem.Block
		block, _ = pem.Decode(buf)

		if block == nil {
			errors.New("no valid private key found")
		}

		privPEM = buf

		file, err = os.Open(*cert)
		if err != nil {
			log.Fatal(err)
		}
		info, err = file.Stat()
		if err != nil {
			log.Fatal(err)
		}
		buf = make([]byte, info.Size())
		file.Read(buf)
		certPEM = buf

		if *tcpip == "server" {
			var cert tlcp.Certificate
 			cert, err = tlcp.X509KeyPair(certPEM, privPEM)
			cfg := tlcp.Config{Certificates: []tlcp.Certificate{cert, cert}, CipherSuites: []uint16{tlcp.ECC_SM4_GCM_SM3}, ClientAuth: tlcp.RequireAndVerifyClientCert}
			cfg.Rand = rand.Reader

			port := "8081"
			if *iport != "" {
				port = *iport
			}

			ln, err := tlcp.Listen("tcp", ":"+port, &cfg)
			if err != nil {
				log.Fatal(err)
			}

			fmt.Fprintln(os.Stderr, "Server(TLCP) up and listening on port "+port)

			conn, err := ln.Accept()
			if err != nil {
				log.Fatal(err)
			}
			defer ln.Close()

			tlcpcon := conn.(*tlcp.Conn)
			err = tlcpcon.Handshake()
			if err != nil {
				log.Fatalf("server: handshake failed: %s", err)
			} else {
				log.Print("server: conn: Handshake completed")
			}

			state := tlcpcon.ConnectionState()
		
			for _, v := range state.PeerCertificates {
				derBytes, err := smx509.MarshalPKIXPublicKey(v.PublicKey)
				if err != nil {
					log.Fatal(err)
				}
				pubPEM := pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: derBytes})
				fmt.Printf("%s\n", pubPEM)
			}

			go handleConnection(conn)
			fmt.Println("Connection accepted")

			for {
				message, err := bufio.NewReader(conn).ReadString('\n')
				if err != nil {
					fmt.Println(err)
					os.Exit(3)
				}
				fmt.Print("Client response: " + string(message))

				reader := bufio.NewReader(os.Stdin)
				fmt.Print("Text to be sent: ")
				text, err := reader.ReadString('\n')
				if err != nil {
					fmt.Println(err)
					os.Exit(3)
				}
				fmt.Fprintf(conn, text+"\n")
			}
		}

		if *tcpip == "client" {
			var cert tlcp.Certificate
			cert, err = tlcp.X509KeyPair(certPEM, privPEM)
			cfg := tlcp.Config{Certificates: []tlcp.Certificate{cert}, InsecureSkipVerify: true, CipherSuites: []uint16{tlcp.ECC_SM4_GCM_SM3}}

			ipport := "127.0.0.1:8081"
			if *iport != "" {
				ipport = *iport
			}

			conn, err := tlcp.Dial("tcp", ipport, &cfg)
			if err != nil {
				log.Fatal(err)
			}
			certs := conn.ConnectionState().PeerCertificates
			for _, cert := range certs {
				fmt.Printf("Issuer: \n\t%s\n", cert.Issuer)
				fmt.Printf("Subject: \n\t%s\n", cert.Subject)
				fmt.Printf("Expiry: %s \n", cert.NotAfter.Format("Monday, 02-Jan-06 15:04:05 MST"))
			}
			if err != nil {
				log.Fatal(err)
			}
			defer conn.Close()

			var b bytes.Buffer
			for _, cert := range conn.ConnectionState().PeerCertificates {
				err := pem.Encode(&b, &pem.Block{
					Type: "CERTIFICATE",
					Bytes: cert.Raw,
			        })
				if err != nil {
					log.Fatal(err)
				}
			}
			fmt.Println(b.String())

			for {
				reader := bufio.NewReader(os.Stdin)
				fmt.Print("Text to be sent: ")
				text, err := reader.ReadString('\n')
				if err != nil {
					fmt.Println(err)
					os.Exit(3)
				}
				fmt.Fprintf(conn, text+"\n")

				message, err := bufio.NewReader(conn).ReadString('\n')
				if err != nil {
					fmt.Println(err)
					os.Exit(3)
				}
				fmt.Print("Server response: " + message)
			}
		}
		os.Exit(0)
	}
}

I don't understand what's wrong, if anyone can help me that would be great.

Thanks in advance.

是否可以考虑自适应支持tlcp和标准的tls

是否可以实现github.com/tjfoc/gmsm/gmtls中类似自适应支持tlcp和标准tls的功能

[sync sdk] tls: use certificate cache in client

In verifyServerCertificate parse certificates using the global certificate cache.

This should significantly reduce memory usage in TLS clients which make concurrent connections which reuse certificates (anywhere in the chain) since there will only ever be one copy of the certificate at once.

建议将TLCP_ECC_SM4_GCM_SM3优先于TLCP_ECC_SM4_CBC_SM3

总体来说GCM模式比CBC模式安全。另外从实现性能来讲，GCM模式加解密可以并行，CBC模式只有解密可以并行，当然这取决于SM4_CBC 、 SM4_GCM具体实现。

Doubt about Cipher Suites

Greetings!

I was reading about the cipher suites, which include RSA_SM4_GCM_SM3 and RSA_SM4_GCM_SHA256, but I didn't understand how this happens. I can't use RSA keys to perform the handshake:

handshake failed: tlcp: no cipher suite supported by both client and server

Does the library accept other algorithms or is it restricted to SM2 (the only one that works)?

Thank you in advance.

单向认证时client异常

单向认证时，客户端没有配置证书，如果服务端要求客户端上送证书，会panic

handshake_client.go文件的373行

panic：runtim error: index out of range [0] with length 0

没有处理intermediate CAs，导致服务器证书验证失败

当前实现没有处理intermediate CAs，测试网站：https://sm2test.ovssl.cn/

握手时服务器发来的服务器证书：

最后两个分别是国密SM2服务器根证书V3和国密SM2根证书。除非客户端把国密SM2服务器根证书V3作为root CA，否则证书验证失败。

所属包名 tlcp
方法 parsePrivateKey


// 解析PKCS8(PEM)格式 SM2密钥对
func parsePrivateKey(der []byte) (crypto.PrivateKey, error) {
        // ❌  这里注释了 就不支持 pckcs1 格式的私钥了
	//if key, err := x509.ParsePKCS1PrivateKey(der); err == nil {
	//	return key, nil
	//}
	if key, err := x509.ParsePKCS8PrivateKey(der); err == nil {
		switch key := key.(type) {
		case *rsa.PrivateKey, *ecdsa.PrivateKey, ed25519.PrivateKey, *sm2.PrivateKey:
			return key, nil
		default:
			return nil, errors.New("tlcp: found unknown private key type in PKCS#8 wrapping")
		}
	}
	if key, err := x509.ParseECPrivateKey(der); err == nil {
		return key, nil
	}

	return nil, errors.New("tlcp: failed to parse private key")
}

步骤

生成 RSA 格式的私钥，案例如下
使用如下方式读取 tlcp.LoadX509KeyPair("config/tls/server.crt", "config/tls/server_pkcs1.key")
发现无法读取

server.crt
-----BEGIN CERTIFICATE-----
MIID2zCCAsOgAwIBAgIUM9uFSX7i7/i/7H+CxRFtTVvwufAwDQYJKoZIhvcNAQEL
BQAwSDELMAkGA1UEBhMCQ04xCzAJBgNVBAgMAkJKMQswCQYDVQQHDAJIRDERMA8G
A1UECgwIdGVsZWluZm8xDDAKBgNVBAsMA1ImRDAeFw0yMjA5MjkwOTQ0NTJaFw0z
MjA5MjYwOTQ0NTJaMGAxCzAJBgNVBAYTAkNOMQswCQYDVQQIDAJCSjELMAkGA1UE
BwwCSEQxETAPBgNVBAoMCHRlbGVpbmZvMQwwCgYDVQQLDANSJkQxFjAUBgNVBAMM
DSoudGVsZWluZm8uY24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC7
XEkke47NuT8jm+r1P+dLVibGGBy+fdBQ1GLexAZlhzavhW+y5O1YTOGH6jKqMyjt
Pf4+Tqr8vvtl22MGsNTWR30ViPo2QOAgy9s+7+gSCUrp6CqhefG2Y+iZB7os/3hl
zSvFvqtMIJ9CCTD2rFwA8DqtX6//1QKLqwB3Atf2EbzGe6Cgfzsy6IbjMTVnaY3x
IXatVDW5IAlw/psGirCAR8pjQ46VXxDaFQIzeG4ZtUJybVmgsWohpOKD87iflYg6
Y1yy/h/UHfvUaRErXrL1a3ki45aysZmqhwZOPPy+SJPbJBp1uSB1RUWq4VE24JlL
EEwnaUVItRxi6nuYrIUlAgMBAAGjgaQwgaEwbQYDVR0jBGYwZKFMpEowSDELMAkG
A1UEBhMCQ04xCzAJBgNVBAgMAkJKMQswCQYDVQQHDAJIRDERMA8GA1UECgwIdGVs
ZWluZm8xDDAKBgNVBAsMA1ImRIIUR16lCMx2c/aHNCtd7B9kQs4JMQgwCQYDVR0T
BAIwADALBgNVHQ8EBAMCBPAwGAYDVR0RBBEwD4INKi50ZWxlaW5mby5jbjANBgkq
hkiG9w0BAQsFAAOCAQEAhQu2rfKIxOinjBLJipzmzseN5K6RMKOW4q8dCR+OB+N1
hUPPQodDENJlrNWuA+gvznHv0buRETb3vENIDiaugejMC1mJw1TsYWcdndUx7/IE
Z7Td8uUfKEnaTTU01+WOkI8Gs/fl55npcl4KuuMa4oZGpP+JPAyZ2FybAzBOVBwV
WowJajvS3pQsaYiKe9vGZ2BrjDwkxUsLCQ0eI41Myf49rQ7WZdGFNHwg3qGAr4WJ
hVn5h2/NcY+zjBxAZgLiBIKz3jVPwyzvBbR07gXr2i1oZhlTBBomo1D8cBvl5seQ
iu1nBa0c9Tlm1e3bKCeu5Ax2LRbreL4RNbOueBF5sQ==
-----END CERTIFICATE-----


server_pkcs1.key  （pkcs1 格式的私钥）
-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAu1xJJHuOzbk/I5vq9T/nS1Ymxhgcvn3QUNRi3sQGZYc2r4Vv
suTtWEzhh+oyqjMo7T3+Pk6q/L77ZdtjBrDU1kd9FYj6NkDgIMvbPu/oEglK6egq
oXnxtmPomQe6LP94Zc0rxb6rTCCfQgkw9qxcAPA6rV+v/9UCi6sAdwLX9hG8xnug
oH87MuiG4zE1Z2mN8SF2rVQ1uSAJcP6bBoqwgEfKY0OOlV8Q2hUCM3huGbVCcm1Z
oLFqIaTig/O4n5WIOmNcsv4f1B371GkRK16y9Wt5IuOWsrGZqocGTjz8vkiT2yQa
dbkgdUVFquFRNuCZSxBMJ2lFSLUcYup7mKyFJQIDAQABAoIBAEd+f6qcO3HlLmK4
LIBJUkk9Jq6QpOdLuyIc6V14D7jOT9/KW0U4dhkrvSPQCmVIAGYHMe00t6qadfP4
M2FqOM1Lmj+NdW0edGgPYioyAaxgP2XiYeIcVk/y7971Q+XH1nmCQSHEEDmMeTkJ
qNV4D+OLx9hAmzhUYBRLvHGtdBtBIYq1cZueFOYWmdQOwmYP5Zmfdj0lYoB0u822
38TiqaZbHZAPcQq5QgWSDtPsUaasKg/7eq+KzSngk87E9x4pJlRd2/1MNvIRmPEY
pB0zSpRxDnkgIm5KA9rX//jja2+F2GtZ0Ay35GIVqJxc/H4PNm1xa5smvzgxk30S
K4grjgECgYEA8UN2DiJms7S9HLPOJm+MwpoWpDZZ6tQipYRdman5LbuoT8VE/y/X
BztLMBISZ//8aHHdE4XH4BKltSVomTGr7f9yjR/seXn4YTFHODXcm2RjSYHSwraX
sOqQ0qrlxuLiBM3YwOpBHSkGYD2gLujQyCCRY7xOEkYVy3aESaBRtjkCgYEAxs33
CGikj/eVDwKVxDtRyHVKiXNBYUYKsgakzFZ7vfeDGoXywZNJVxqR7JpSzboXrVPf
7d/kft+FgboCyo4tCXepuS9m8JDDtcxj9t9SL7pZ4t9Ru8Kl7PVmHyfPYt5V71jH
DnaWI3Y8fmI5LnnWSBwqdvLcsKVrRp5g3a1uZk0CgYBao1p9suTcjIEjgFVpUS0T
iuoIpTagpzOg9Rpo+VdYnBB+b4EdUa6508fKdm+dzKjZ4DUK+Y5+muLQLA6gxu1t
izNQ23ZuqKjscqPr9Sg85Lj8S56PciOI3oar7nJGhsQcw+yzhQ4TU29GxsAf/204
UivsyTiXWucjOhI2ytkH2QKBgF8yRTZ7lUFzFqdnX3vlw9WvhI+o5wfDWF/DGqrW
Rs7CdL8AoSvccWQKTxHzG+9zSt8uqK3pZirysaVbAvcneZ1s9ZK9hhdv2qd1RfDz
IxHDtEMVGLhGDtoW8F2+3GnFeXTxF/BvDJnShkkmk6cTpG5HPnZS+SaFL4dTU6MS
5yiJAoGAHlAq/VAsjwXxa8G+sOR+anVmIhT/xWBgUP3p4027cJWDo/zX2Su9LGbP
ECc+LmVnt+QKpgoMjhBNvDpS3zfzuVBc04QSTVh0DRsB12JPMoMYxNyGrtibcXzp
VRirHodw+9HiNLuVXDtdzLqw3L/Qa/nBoFai7ZmOq74TAruycVk=
-----END RSA PRIVATE KEY-----


server_pkcs8.key  （pkcs8 格式的私钥）
-----BEGIN PRIVATE KEY-----
MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC7XEkke47NuT8j
m+r1P+dLVibGGBy+fdBQ1GLexAZlhzavhW+y5O1YTOGH6jKqMyjtPf4+Tqr8vvtl
22MGsNTWR30ViPo2QOAgy9s+7+gSCUrp6CqhefG2Y+iZB7os/3hlzSvFvqtMIJ9C
CTD2rFwA8DqtX6//1QKLqwB3Atf2EbzGe6Cgfzsy6IbjMTVnaY3xIXatVDW5IAlw
/psGirCAR8pjQ46VXxDaFQIzeG4ZtUJybVmgsWohpOKD87iflYg6Y1yy/h/UHfvU
aRErXrL1a3ki45aysZmqhwZOPPy+SJPbJBp1uSB1RUWq4VE24JlLEEwnaUVItRxi
6nuYrIUlAgMBAAECggEAR35/qpw7ceUuYrgsgElSST0mrpCk50u7IhzpXXgPuM5P
38pbRTh2GSu9I9AKZUgAZgcx7TS3qpp18/gzYWo4zUuaP411bR50aA9iKjIBrGA/
ZeJh4hxWT/Lv3vVD5cfWeYJBIcQQOYx5OQmo1XgP44vH2ECbOFRgFEu8ca10G0Eh
irVxm54U5haZ1A7CZg/lmZ92PSVigHS7zbbfxOKpplsdkA9xCrlCBZIO0+xRpqwq
D/t6r4rNKeCTzsT3HikmVF3b/Uw28hGY8RikHTNKlHEOeSAibkoD2tf/+ONrb4XY
a1nQDLfkYhWonFz8fg82bXFrmya/ODGTfRIriCuOAQKBgQDxQ3YOImaztL0cs84m
b4zCmhakNlnq1CKlhF2Zqfktu6hPxUT/L9cHO0swEhJn//xocd0ThcfgEqW1JWiZ
Mavt/3KNH+x5efhhMUc4NdybZGNJgdLCtpew6pDSquXG4uIEzdjA6kEdKQZgPaAu
6NDIIJFjvE4SRhXLdoRJoFG2OQKBgQDGzfcIaKSP95UPApXEO1HIdUqJc0FhRgqy
BqTMVnu994MahfLBk0lXGpHsmlLNuhetU9/t3+R+34WBugLKji0Jd6m5L2bwkMO1
zGP231Ivulni31G7wqXs9WYfJ89i3lXvWMcOdpYjdjx+YjkuedZIHCp28tywpWtG
nmDdrW5mTQKBgFqjWn2y5NyMgSOAVWlRLROK6gilNqCnM6D1Gmj5V1icEH5vgR1R
rrnTx8p2b53MqNngNQr5jn6a4tAsDqDG7W2LM1Dbdm6oqOxyo+v1KDzkuPxLno9y
I4jehqvuckaGxBzD7LOFDhNTb0bGwB//bThSK+zJOJda5yM6EjbK2QfZAoGAXzJF
NnuVQXMWp2dfe+XD1a+Ej6jnB8NYX8MaqtZGzsJ0vwChK9xxZApPEfMb73NK3y6o
relmKvKxpVsC9yd5nWz1kr2GF2/ap3VF8PMjEcO0QxUYuEYO2hbwXb7cacV5dPEX
8G8MmdKGSSaTpxOkbkc+dlL5JoUvh1NToxLnKIkCgYAeUCr9UCyPBfFrwb6w5H5q
dWYiFP/FYGBQ/enjTbtwlYOj/NfZK70sZs8QJz4uZWe35AqmCgyOEE28OlLfN/O5
UFzThBJNWHQNGwHXYk8ygxjE3Iau2JtxfOlVGKseh3D70eI0u5VcO13MurDcv9Br
+cGgVqLtmY6rvhMCu7JxWQ==
-----END PRIVATE KEY-----

debug模式是否可以支持打印出pri-master-secret(master-secret)?

TLCP的ECDHE实现问题

gotlcp/tlcp/key_agreement.go

Line 265 in 9729b48

 // 由于TLCP标准并未明确提及密钥长度，因此与ECC密钥交换类型保持一致48字节。 

TLCP标准文档相当简约，只说ECDHE实现参考GB/T 35276，但是GB/T 35276是SM2完整密钥协商的输入、输出定义而已。所以：

TLCP交换生成shared secret 或叫预主密钥的过程使用了完整的SM2密钥协商过程。
如果真要使用SM2密钥协商过程来交换生成预主密钥，却不对相关参数给出规定。

这样的话，怎么验证实现的正确性？不同的实现如何能互操作？