func main() {
flag.Parse()
if *verifier == "" {
id := new([govpn.IDSize]byte)
if _, err := rand.Read(id[:]); err != nil {
log.Fatalln(err)
}
pid := govpn.PeerId(*id)
v := govpn.VerifierNew(*mOpt, *tOpt, *pOpt, &pid)
v.PasswordApply(govpn.StringFromFile(*keyPath))
fmt.Println(v.LongForm())
fmt.Println(v.ShortForm())
return
}
v, err := govpn.VerifierFromString(*verifier)
if err != nil {
log.Fatalln("Can not decode verifier", err)
}
if v.Pub == nil {
log.Fatalln("Verifier does not contain public key")
}
pub := *v.Pub
v.PasswordApply(govpn.StringFromFile(*keyPath))
fmt.Println(subtle.ConstantTimeCompare(v.Pub[:], pub[:]) == 1)
}
func main() {
flag.Parse()
id, err := govpn.IDDecode(*IDRaw)
if err != nil {
log.Fatalln(err)
}
pub, _ := govpn.NewVerifier(id, govpn.StringFromFile(*keyPath))
if *verifierPath == "" {
fmt.Println(hex.EncodeToString(pub[:]))
} else {
verifier, err := hex.DecodeString(govpn.StringFromFile(*verifierPath))
if err != nil {
log.Fatalln("Can not decode verifier:", err)
}
fmt.Println(subtle.ConstantTimeCompare(verifier[:], pub[:]) == 1)
}
}
func main() {
flag.Parse()
timeout := *timeoutP
var err error
log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile)
govpn.MTU = *mtu
id, err := govpn.IDDecode(*IDRaw)
if err != nil {
log.Fatalln(err)
}
if *egdPath != "" {
log.Println("Using", *egdPath, "EGD")
govpn.EGDInit(*egdPath)
}
pub, priv := govpn.NewVerifier(id, govpn.StringFromFile(*keyPath))
conf := &govpn.PeerConf{
Id: id,
Timeout: time.Second * time.Duration(timeout),
NoiseEnable: *noisy,
CPR: *cpr,
DSAPub: pub,
DSAPriv: priv,
}
govpn.PeersInitDummy(id, conf)
var conn io.Writer
var sink chan []byte
var ready chan struct{}
switch *proto {
case "udp":
conn, sink, ready = startUDP()
case "tcp":
if *proxyAddr != "" {
conn, sink, ready = proxyTCP()
} else {
conn, sink, ready = startTCP()
}
default:
log.Fatalln("Unknown protocol specified")
}
tap, ethSink, ethReady, _, err := govpn.TAPListen(
*ifaceName,
time.Second*time.Duration(timeout),
*cpr,
)
if err != nil {
log.Fatalln("Can not listen on TAP interface:", err)
}
timeouts := 0
firstUpCall := true
var peer *govpn.Peer
var ethPkt []byte
var pkt []byte
knownPeers := govpn.KnownPeers(map[string]**govpn.Peer{*remoteAddr: &peer})
log.Println(govpn.VersionGet())
log.Println("Connected to", *proto, *remoteAddr)
log.Println("Max MTU on TAP interface:", govpn.TAPMaxMTU())
if *stats != "" {
log.Println("Stats are going to listen on", *stats)
statsPort, err := net.Listen("tcp", *stats)
if err != nil {
log.Fatalln("Can not listen on stats port:", err)
}
go govpn.StatsProcessor(statsPort, &knownPeers)
}
termSignal := make(chan os.Signal, 1)
signal.Notify(termSignal, os.Interrupt, os.Kill)
log.Println("Starting handshake")
handshake := govpn.HandshakeStart(*remoteAddr, conn, conf)
MainCycle:
for {
if peer != nil && (peer.BytesIn+peer.BytesOut) > govpn.MaxBytesPerKey {
peer.Zero()
peer = nil
handshake = govpn.HandshakeStart(*remoteAddr, conn, conf)
log.Println("Rehandshaking")
}
select {
case <-termSignal:
break MainCycle
case ethPkt = <-ethSink:
if peer == nil {
if len(ethPkt) > 0 {
ethReady <- struct{}{}
}
continue
}
peer.EthProcess(ethPkt, ethReady)
case pkt = <-sink:
timeouts++
if timeouts >= timeout {
break MainCycle
}
if pkt == nil {
ready <- struct{}{}
continue
}
if peer == nil {
if govpn.IDsCache.Find(pkt) == nil {
log.Println("Invalid identity in handshake packet")
ready <- struct{}{}
continue
}
if p := handshake.Client(pkt); p != nil {
log.Println("Handshake completed")
if firstUpCall {
go govpn.ScriptCall(*upPath, *ifaceName)
firstUpCall = false
}
peer = p
handshake.Zero()
handshake = nil
}
ready <- struct{}{}
continue
}
if peer == nil {
ready <- struct{}{}
continue
}
if peer.PktProcess(pkt, tap, ready) {
timeouts = 0
}
}
}
govpn.ScriptCall(*downPath, *ifaceName)
}
func main() {
flag.Parse()
timeout = *timeoutP
var err error
log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile)
govpn.MTU = *mtu
if *egdPath != "" {
log.Println("Using", *egdPath, "EGD")
govpn.EGDInit(*egdPath)
}
verifier, err := govpn.VerifierFromString(*verifierRaw)
if err != nil {
log.Fatalln(err)
}
priv := verifier.PasswordApply(govpn.StringFromFile(*keyPath))
conf = &govpn.PeerConf{
Id: verifier.Id,
Timeout: time.Second * time.Duration(timeout),
Noise: *noisy,
CPR: *cpr,
Verifier: verifier,
DSAPriv: priv,
}
idsCache = govpn.NewCipherCache([]govpn.PeerId{*verifier.Id})
log.Println(govpn.VersionGet())
tap, err = govpn.TAPListen(*ifaceName)
if err != nil {
log.Fatalln("Can not listen on TAP interface:", err)
}
log.Println("Max MTU on TAP interface:", govpn.TAPMaxMTU())
if *stats != "" {
log.Println("Stats are going to listen on", *stats)
statsPort, err := net.Listen("tcp", *stats)
if err != nil {
log.Fatalln("Can not listen on stats port:", err)
}
go govpn.StatsProcessor(statsPort, &knownPeers)
}
termSignal := make(chan os.Signal, 1)
signal.Notify(termSignal, os.Interrupt, os.Kill)
MainCycle:
for {
timeouted := make(chan struct{})
rehandshaking := make(chan struct{})
termination := make(chan struct{})
if *proxyAddr != "" {
*proto = "tcp"
}
switch *proto {
case "udp":
go startUDP(timeouted, rehandshaking, termination)
case "tcp":
if *proxyAddr != "" {
go proxyTCP(timeouted, rehandshaking, termination)
} else {
go startTCP(timeouted, rehandshaking, termination)
}
default:
log.Fatalln("Unknown protocol specified")
}
select {
case <-termSignal:
log.Fatalln("Finishing")
termination <- struct{}{}
break MainCycle
case <-timeouted:
break MainCycle
case <-rehandshaking:
}
close(timeouted)
close(rehandshaking)
close(termination)
}
govpn.ScriptCall(*downPath, *ifaceName)
}