Implement first client command
The client can now talk to the old Perl signer implementation. Running socat has been documented in README.md. Commonly used I/O code has been moved to the shared/io.go file.
This commit is contained in:
Jan Dittberner
parent
5aa557c9aa
commit
65855152ce
6 changed files with 287 additions and 84 deletions
264
client/main.go
264
client/main.go
|
|
@ -1,71 +1,132 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"git.cacert.org/cacert-gosigner/datastructures"
|
||||
"git.cacert.org/cacert-gosigner/shared"
|
||||
"log"
|
||||
"io/ioutil"
|
||||
"time"
|
||||
|
||||
"github.com/goburrow/serial"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"gopkg.in/yaml.v2"
|
||||
)
|
||||
|
||||
var (
|
||||
address string
|
||||
baudrate int
|
||||
databits int
|
||||
stopbits int
|
||||
parity string
|
||||
message string
|
||||
)
|
||||
type SerialConfig struct {
|
||||
Address string `yaml:"address"`
|
||||
BaudRate int `yaml:"baudrate"`
|
||||
DataBits int `yaml:"databits"`
|
||||
StopBits int `yaml:"stopbits"`
|
||||
Parity string `yaml:"parity"`
|
||||
}
|
||||
|
||||
type ClientConfig struct {
|
||||
Serial SerialConfig `yaml:"serial_config"`
|
||||
Paranoid bool `yaml:"paranoid"`
|
||||
Debug bool `yaml:"debug"`
|
||||
GNUPGBinary string `yaml:"gnupg_bin"`
|
||||
OpenSSLBinary string `yaml:"openssl_bin"`
|
||||
MySQLDSN string `yaml:"mysql_dsn"`
|
||||
}
|
||||
|
||||
var defaultConfig = ClientConfig{
|
||||
Serial: SerialConfig{
|
||||
Address: "/dev/ttyUSB0",
|
||||
BaudRate: 115200,
|
||||
DataBits: 8,
|
||||
StopBits: 1,
|
||||
Parity: "N",
|
||||
},
|
||||
Paranoid: false,
|
||||
Debug: false,
|
||||
OpenSSLBinary: "/usr/bin/openssl",
|
||||
GNUPGBinary: "/usr/bin/gpg",
|
||||
MySQLDSN: "<username>:<password>@/database?parseTime=true",
|
||||
}
|
||||
|
||||
const HandshakeByte = 0x02
|
||||
const AckByte = 0x10
|
||||
const NackByte = 0x11
|
||||
|
||||
func readConfig(configFile string) (config *ClientConfig, err error) {
|
||||
source, err := ioutil.ReadFile(configFile)
|
||||
if err != nil {
|
||||
log.Errorf("opening configuration file failed: %v", err)
|
||||
if exampleConfig, err := generateExampleConfig(configFile); err != nil {
|
||||
return nil, err
|
||||
} else {
|
||||
log.Info("starting with default config")
|
||||
return exampleConfig, nil
|
||||
}
|
||||
}
|
||||
if err := yaml.Unmarshal(source, &config); err != nil {
|
||||
return nil, fmt.Errorf("loading configuration file failed: %v", err)
|
||||
}
|
||||
|
||||
return config, nil
|
||||
}
|
||||
|
||||
func generateExampleConfig(configFile string) (config *ClientConfig, err error) {
|
||||
config = &defaultConfig
|
||||
configBytes, err := yaml.Marshal(config)
|
||||
if err != nil {
|
||||
log.Errorf("could not generate configuration data")
|
||||
return
|
||||
}
|
||||
|
||||
log.Infof("example data for %s:\n\n---\n%s\n", configFile, configBytes)
|
||||
return
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.StringVar(&address, "a", "/dev/ttyUSB0", "address")
|
||||
flag.IntVar(&baudrate, "b", 115200, "baud rate")
|
||||
flag.IntVar(&databits, "d", 8, "data bits")
|
||||
flag.IntVar(&stopbits, "s", 1, "stop bits")
|
||||
flag.StringVar(&parity, "p", "N", "parity (N/E/O)")
|
||||
flag.StringVar(&message, "m", "serial", "message")
|
||||
var configFile string
|
||||
|
||||
flag.StringVar(&configFile, "c", "client.yaml", "client configuration file in YAML format")
|
||||
flag.Parse()
|
||||
|
||||
config := serial.Config{
|
||||
Address: address,
|
||||
BaudRate: baudrate,
|
||||
DataBits: databits,
|
||||
StopBits: stopbits,
|
||||
Parity: parity,
|
||||
var clientConfig *ClientConfig
|
||||
var serialConfig *serial.Config
|
||||
var err error
|
||||
|
||||
if clientConfig, err = readConfig(configFile); err != nil {
|
||||
log.Panic(err)
|
||||
}
|
||||
serialConfig = &serial.Config{
|
||||
Address: clientConfig.Serial.Address,
|
||||
BaudRate: clientConfig.Serial.BaudRate,
|
||||
DataBits: clientConfig.Serial.DataBits,
|
||||
StopBits: clientConfig.Serial.StopBits,
|
||||
Parity: clientConfig.Serial.Parity,
|
||||
Timeout: 30 * time.Second,
|
||||
}
|
||||
log.Printf("connecting %+v", config)
|
||||
port, err := serial.Open(&config)
|
||||
if clientConfig.Debug {
|
||||
log.SetLevel(log.DebugLevel)
|
||||
}
|
||||
|
||||
log.Debugf("connecting %+v", serialConfig)
|
||||
port, err := serial.Open(serialConfig)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
log.Println("connected")
|
||||
log.Debug("connected")
|
||||
defer func() {
|
||||
err := port.Close()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
log.Println("closed")
|
||||
log.Debug("closed")
|
||||
}()
|
||||
|
||||
if _, err = port.Write([]byte{0x02}); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
resp := make([]byte, 1)
|
||||
if _, err = port.Read(resp); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
request := datastructures.NewNulRequest()
|
||||
timeout := time.After(2700 * time.Millisecond)
|
||||
errorChannel := make(chan error, 1)
|
||||
responseChannel := make(chan *datastructures.SignerResponse, 1)
|
||||
|
||||
go func() {
|
||||
if response, err := SendRequest(&port, request); err != nil {
|
||||
if response, err := SendRequest(port, request); err != nil {
|
||||
errorChannel <- err
|
||||
} else {
|
||||
responseChannel <- response
|
||||
|
|
@ -77,30 +138,133 @@ func main() {
|
|||
log.Fatal("timeout")
|
||||
case err := <-errorChannel:
|
||||
log.Fatal(err)
|
||||
case response := <- responseChannel:
|
||||
case response := <-responseChannel:
|
||||
if err := Process(response); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
requestBytes := request.Serialize()
|
||||
|
||||
if _, err = port.Write(requestBytes); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
if _, err = port.Write([]byte{datastructures.CalculateXorCheckSum([][]byte{requestBytes})}); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
if _, err = port.Write([]byte(shared.MagicTrailer)); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func Process(response *datastructures.SignerResponse) error {
|
||||
log.Debugf("process %v", response)
|
||||
return nil
|
||||
}
|
||||
|
||||
func SendRequest(port *serial.Port, request *datastructures.SignerRequest) (*datastructures.SignerResponse, error) {
|
||||
func sendHandShake(port serial.Port) error {
|
||||
log.Debug("Shaking hands ...")
|
||||
if length, err := port.Write([]byte{HandshakeByte}); err != nil {
|
||||
return fmt.Errorf("could not write handshake byte: %v", err)
|
||||
} else {
|
||||
log.Debugf("wrote %d handshake bytes", length)
|
||||
}
|
||||
handShakeResponse := make([]byte, 1)
|
||||
if length, err := port.Read(handShakeResponse); err != nil {
|
||||
return fmt.Errorf("failed to read handshake response: %v", err)
|
||||
} else {
|
||||
log.Debugf("read %d bytes", length)
|
||||
}
|
||||
if handShakeResponse[0] != AckByte {
|
||||
return fmt.Errorf("invalid handshake response expected 0x10 received %x", handShakeResponse[0])
|
||||
}
|
||||
log.Debug("Handshake successful")
|
||||
return nil
|
||||
}
|
||||
|
||||
func receiveResponse(port *serial.Port, responseChan *chan []byte, errorChan *chan error) {
|
||||
header, err := shared.ReceiveBytes(port, 1, 20)
|
||||
if err != nil {
|
||||
*errorChan <- err
|
||||
return
|
||||
}
|
||||
if header[0] != HandshakeByte {
|
||||
*errorChan <- fmt.Errorf("unexpected byte 0x%x expected 0x%x", header, HandshakeByte)
|
||||
}
|
||||
|
||||
if _, err := (*port).Write([]byte{AckByte}); err != nil {
|
||||
*errorChan <- errors.New("could not write ACK")
|
||||
return
|
||||
}
|
||||
|
||||
lengthBytes, err := shared.ReceiveBytes(port, 3, 2)
|
||||
if err != nil {
|
||||
*errorChan <- err
|
||||
return
|
||||
}
|
||||
blockLength := binary.BigEndian.Uint32([]byte{0x0, lengthBytes[0], lengthBytes[1], lengthBytes[2]})
|
||||
blockData, err := shared.ReceiveBytes(port, int(blockLength), 5)
|
||||
if err != nil {
|
||||
*errorChan <- err
|
||||
return
|
||||
}
|
||||
|
||||
checkSum, err := shared.ReceiveBytes(port, 1, 2)
|
||||
if err != nil {
|
||||
*errorChan <- err
|
||||
return
|
||||
}
|
||||
log.Debugf("block checksum is %d", checkSum)
|
||||
trailer, err := shared.ReceiveBytes(port, len(shared.MagicTrailer), 2)
|
||||
if err != nil {
|
||||
*errorChan <- err
|
||||
return
|
||||
}
|
||||
if string(trailer) != shared.MagicTrailer {
|
||||
*errorChan <- errors.New("expected trailer bytes not found")
|
||||
return
|
||||
}
|
||||
|
||||
if _, err := (*port).Write([]byte{AckByte}); err != nil {
|
||||
*errorChan <- fmt.Errorf("could not write ACK byte: %v", err)
|
||||
}
|
||||
*responseChan <- blockData
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func SendRequest(port serial.Port, request *datastructures.SignerRequest) (response *datastructures.SignerResponse, err error) {
|
||||
log.Debugf("send request %v to serial port %v", request, port)
|
||||
|
||||
if err = sendHandShake(port); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
requestBytes := request.Serialize()
|
||||
if length, err := port.Write(requestBytes); err != nil {
|
||||
log.Fatal(err)
|
||||
} else {
|
||||
log.Debugf("wrote %d request bytes", length)
|
||||
}
|
||||
|
||||
if length, err := port.Write([]byte{datastructures.CalculateXorCheckSum([][]byte{requestBytes})}); err != nil {
|
||||
log.Fatal(err)
|
||||
} else {
|
||||
log.Debugf("wrote %d checksum bytes", length)
|
||||
}
|
||||
|
||||
if length, err := port.Write([]byte(shared.MagicTrailer)); err != nil {
|
||||
log.Fatal(err)
|
||||
} else {
|
||||
log.Debugf("wrote %d trailer bytes", length)
|
||||
}
|
||||
|
||||
header, err := shared.ReceiveBytes(&port, 1, 20)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if header[0] != AckByte {
|
||||
return nil, fmt.Errorf("unexpected byte 0x%x expected 0x%x", header, AckByte)
|
||||
}
|
||||
|
||||
responseChan := make(chan []byte, 1)
|
||||
errChan := make(chan error, 1)
|
||||
go receiveResponse(&port, &responseChan, &errChan)
|
||||
|
||||
select {
|
||||
case responseData := <-responseChan:
|
||||
log.Debugf("response data: %v", responseData)
|
||||
case err := <-errChan:
|
||||
log.Errorf("%v", err)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue