RusstopiaLabs
/
xs
mirror of https://gogs.blitter.com/RLabs/xs
1
0
Fork 0
Code Issues Releases Wiki Activity

Start of proto kexsh tool client/server

This commit is contained in:
Russ Magee 2018-01-13 10:01:27 -08:00
parent 78edf1c130
commit 942b8865cf
5 changed files with 69 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
demo/client/client.go
View File

@ -11,10 +11,16 @@ import (
// Demo of a simple client that dials up to a simple test server to
// send data.
// Note this code is identical to standard tcp client code, save for
// declaring a 'hkex' rather than a 'net' Dialer Conn. The KEx and
// encrypt/decrypt is done within the type.
// Compare to 'clientp.go' in this directory to see the equivalence.
//
// While conforming to the basic net.Conn interface HKex.Conn has extra
// capabilities designed to allow apps to define connection options,
// encryption/hmac settings and operations across the encrypted channel.
//
// Initial setup is the same as using plain net.Dial(), but one may
// specify extra extension tags (strings) to set the cipher and hmac
// setting desired; as well as the intended operation mode for the
// connection (app-specific, passed through to the server to use or
// ignore at its discretion).
func main() {
var cAlg string
var hAlg string
@ -30,6 +36,7 @@ func main() {
fmt.Println("Err!")
panic(err)
}
fmt.Fprintf(conn,"e") // tell server just to echo
_, err = io.Copy(conn, os.Stdin)
if err != nil && err.Error() != "EOF" {
fmt.Println(err)

6
demo/dbgclient/client.go
View File

@ -16,16 +16,12 @@ import (
// encrypt/decrypt is done within the type.
// Compare to 'clientp.go' in this directory to see the equivalence.
func main() {
var cAlg string
var hAlg string
var server string
flag.StringVar(&cAlg, "c", "C_AES_256", "cipher [\"C_AES_256\" | \"C_TWOFISH_128\" | \"C_BLOWFISH_64\"]")
flag.StringVar(&hAlg, "h", "H_SHA256", "hmac [\"H_SHA256\"]")
flag.StringVar(&server, "s", "localhost:2000", "server hostname/address[:port]")
flag.Parse()
conn, err := hkex.Dial("tcp", server, cAlg, hAlg)
conn, err := hkex.Dial("tcp", server)
if err != nil {
fmt.Println("Err!")
panic(err)

14
demo/server/server.go
View File

@ -45,6 +45,7 @@ func main() {
ch := make(chan []byte)
chN := 0
eCh := make(chan error)
var connOp *byte = nil
// Start a goroutine to read from our net connection
go func(ch chan []byte, eCh chan error) {
@ -57,12 +58,23 @@ func main() {
eCh <- err
return
}
if connOp == nil {
// Initial xmit - get op byte
// (TODO: determine valid ops
// for now 'e' (echo), 'i' (interactive), 'x' (exec), ... ?)
connOp = new(byte)
*connOp = data[0]
data = data[1:]
chN -= 1
fmt.Printf("[* connOp '%c']\n", *connOp)
}
// send data if we read some.
ch <- data[0:chN]
}
}(ch, eCh)
ticker := time.Tick(time.Second/100)
ticker := time.Tick(time.Second / 100)
Term:
// continuously read from the connection
for {

31
hkexchan.go
View File

@ -1,25 +1,8 @@
/* Herradura - a Key exchange scheme in the style of Diffie-Hellman Key Exchange.
Copyright (C) 2017 Omar Alejandro Herrera Reyna
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
golang implementation by Russ Magee (rmagee_at_gmail.com) */
package herradurakex
/* Support functions to set up encryption once an HKEx Conn has been
established with FA exchange */
established with FA exchange and support channel operations
(echo, file-copy, remote-cmd, ...) */
import (
"crypto/aes"
@ -46,6 +29,16 @@ const (
HmacNoneDisallowed
)
type ChanOp uint8
const (
ChanOpNop = '.'
ChanOpEcho = 'e' // For testing - echo client data to stderr
//ChanOpFileWrite = "w"
//ChanOpFileRead = "r"
//ChanOpRemoteCmd = "x"
)
/*TODO: HMAC derived from HKEx FA.*/
/* Support functionality to set up encryption after a channel has
been negotiated via hkexnet.go

43
hkexnet.go
View File

@ -36,7 +36,8 @@ type Conn struct {
c net.Conn // which also implements io.Reader, io.Writer, ...
h *HerraduraKEx
cipheropts uint32 // post-KEx cipher/hmac options
opts uint32 // post-KEx protocol options
opts uint32 // post-KEx protocol options (caller-defined)
op uint8 // post-KEx 'op' (caller-defined)
r cipher.Stream
w cipher.Stream
}
@ -78,6 +79,26 @@ func (c *Conn) SetOpts(opts uint32) {
c.opts = opts
}
// Op returns the 'op' value, which is sent to the peer
// but is not itself part of the KEx or connection (cipher/hmac) setup.
//
// Consumers of this lib may use this to indicate connection-specific
// operations not part of the KEx or encryption info used by the connection.
func (c *Conn) Op() uint8 {
return c.op
}
// SetOp sets the 'op' value, which is sent to the peer
// but is not itself part of the KEx or connection (cipher/hmac) setup.
//
// Consumers of this lib may use this to indicate connection-specific
// operations not part of the KEx or encryption info used by the connection.
//
// op - a uint8, caller-defined
func (c *Conn) SetOp(op uint8) {
c.op = op
}
func (c *Conn) applyConnExtensions(extensions ...string) {
for _, s := range extensions {
switch s {
@ -120,20 +141,20 @@ func Dial(protocol string, ipport string, extensions ...string) (hc *Conn, err e
if err != nil {
return nil, err
}
hc = &Conn{c: c, h: New(0, 0), cipheropts: 0, opts: 0, r: nil, w: nil}
hc = &Conn{c: c, h: New(0, 0), cipheropts: 0, opts: 0, op:0, r: nil, w: nil}
hc.applyConnExtensions(extensions...)
fmt.Fprintf(c, "0x%s\n%08x:%08x\n", hc.h.d.Text(16),
hc.cipheropts, hc.opts)
fmt.Fprintf(c, "0x%s\n%08x:%08x:%02x\n", hc.h.d.Text(16),
hc.cipheropts, hc.opts, hc.op)
d := big.NewInt(0)
_, err = fmt.Fscanln(c, d)
if err != nil {
return nil, err
}
_, err = fmt.Fscanf(c, "%08x:%08x\n",
&hc.cipheropts, &hc.opts)
_, err = fmt.Fscanf(c, "%08x:%08x:%02x\n",
&hc.cipheropts, &hc.opts, &hc.op)
if err != nil {
return nil, err
}
@ -197,15 +218,15 @@ func (hl *HKExListener) Accept() (hc Conn, err error) {
}
fmt.Println("[Accepted]")
hc = Conn{c: c, h: New(0, 0), cipheropts: 0, opts: 0, r: nil, w: nil}
hc = Conn{c: c, h: New(0, 0), cipheropts: 0, opts: 0, op:0, r: nil, w: nil}
d := big.NewInt(0)
_, err = fmt.Fscanln(c, d)
if err != nil {
return hc, err
}
_, err = fmt.Fscanf(c, "%08x:%08x\n",
&hc.cipheropts, &hc.opts)
_, err = fmt.Fscanf(c, "%08x:%08x:%02x\n",
&hc.cipheropts, &hc.opts, &hc.op)
if err != nil {
return hc, err
}
@ -215,8 +236,8 @@ func (hl *HKExListener) Accept() (hc Conn, err error) {
hc.h.FA()
fmt.Printf("**(s)** FA:%s\n", hc.h.fa)
fmt.Fprintf(c, "0x%s\n%08x:%08x\n", hc.h.d.Text(16),
hc.cipheropts, hc.opts)
fmt.Fprintf(c, "0x%s\n%08x:%08x:%02x\n", hc.h.d.Text(16),
hc.cipheropts, hc.opts, hc.op)
hc.r = hc.getStream(hc.h.fa)
hc.w = hc.getStream(hc.h.fa)