From ff8f3a412ebf3b83b2d67fdafcc3311800fd39ee Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Mon, 12 Feb 2018 23:48:09 +0100 Subject: Use relative imports --- cookie.go | 2 +- device.go | 2 +- internal/ratelimiter/ratelimiter.go | 149 ----------------------- internal/ratelimiter/ratelimiter_test.go | 98 ---------------- internal/tai64n/tai64n.go | 26 ----- internal/tai64n/tai64n_test.go | 21 ---- internal/xchacha20poly1305/xchacha20.go | 169 --------------------------- internal/xchacha20poly1305/xchacha20_test.go | 96 --------------- noise-protocol.go | 2 +- ratelimiter/ratelimiter.go | 149 +++++++++++++++++++++++ ratelimiter/ratelimiter_test.go | 98 ++++++++++++++++ tai64n/tai64n.go | 26 +++++ tai64n/tai64n_test.go | 21 ++++ xchacha20poly1305/xchacha20.go | 169 +++++++++++++++++++++++++++ xchacha20poly1305/xchacha20_test.go | 96 +++++++++++++++ 15 files changed, 562 insertions(+), 562 deletions(-) delete mode 100644 internal/ratelimiter/ratelimiter.go delete mode 100644 internal/ratelimiter/ratelimiter_test.go delete mode 100644 internal/tai64n/tai64n.go delete mode 100644 internal/tai64n/tai64n_test.go delete mode 100644 internal/xchacha20poly1305/xchacha20.go delete mode 100644 internal/xchacha20poly1305/xchacha20_test.go create mode 100644 ratelimiter/ratelimiter.go create mode 100644 ratelimiter/ratelimiter_test.go create mode 100644 tai64n/tai64n.go create mode 100644 tai64n/tai64n_test.go create mode 100644 xchacha20poly1305/xchacha20.go create mode 100644 xchacha20poly1305/xchacha20_test.go diff --git a/cookie.go b/cookie.go index 72455a4..813ddab 100644 --- a/cookie.go +++ b/cookie.go @@ -1,9 +1,9 @@ package main import ( + "./xchacha20poly1305" "crypto/hmac" "crypto/rand" - "git.zx2c4.com/wireguard-go/internal/xchacha20poly1305" "golang.org/x/crypto/blake2s" "golang.org/x/crypto/chacha20poly1305" "sync" diff --git a/device.go b/device.go index 9f93f21..79ec0b8 100644 --- a/device.go +++ b/device.go @@ -1,7 +1,7 @@ package main import ( - "git.zx2c4.com/wireguard-go/internal/ratelimiter" + "./ratelimiter" "runtime" "sync" "sync/atomic" diff --git a/internal/ratelimiter/ratelimiter.go b/internal/ratelimiter/ratelimiter.go deleted file mode 100644 index 006900a..0000000 --- a/internal/ratelimiter/ratelimiter.go +++ /dev/null @@ -1,149 +0,0 @@ -package ratelimiter - -/* Copyright (C) 2015-2017 Jason A. Donenfeld . All Rights Reserved. */ - -/* This file contains a port of the rate-limiter from the linux kernel version */ - -import ( - "net" - "sync" - "time" -) - -const ( - packetsPerSecond = 20 - packetsBurstable = 5 - garbageCollectTime = time.Second - packetCost = 1000000000 / packetsPerSecond - maxTokens = packetCost * packetsBurstable -) - -type RatelimiterEntry struct { - mutex sync.Mutex - lastTime time.Time - tokens int64 -} - -type Ratelimiter struct { - mutex sync.RWMutex - stop chan struct{} - tableIPv4 map[[net.IPv4len]byte]*RatelimiterEntry - tableIPv6 map[[net.IPv6len]byte]*RatelimiterEntry -} - -func (rate *Ratelimiter) Close() { - rate.mutex.Lock() - defer rate.mutex.Unlock() - - if rate.stop != nil { - close(rate.stop) - } -} - -func (rate *Ratelimiter) Init() { - rate.mutex.Lock() - defer rate.mutex.Unlock() - - // stop any ongoing garbage collection routine - - if rate.stop != nil { - close(rate.stop) - } - - rate.stop = make(chan struct{}) - rate.tableIPv4 = make(map[[net.IPv4len]byte]*RatelimiterEntry) - rate.tableIPv6 = make(map[[net.IPv6len]byte]*RatelimiterEntry) - - // start garbage collection routine - - go func() { - timer := time.NewTimer(time.Second) - for { - select { - case <-rate.stop: - return - case <-timer.C: - func() { - rate.mutex.Lock() - defer rate.mutex.Unlock() - - for key, entry := range rate.tableIPv4 { - entry.mutex.Lock() - if time.Now().Sub(entry.lastTime) > garbageCollectTime { - delete(rate.tableIPv4, key) - } - entry.mutex.Unlock() - } - - for key, entry := range rate.tableIPv6 { - entry.mutex.Lock() - if time.Now().Sub(entry.lastTime) > garbageCollectTime { - delete(rate.tableIPv6, key) - } - entry.mutex.Unlock() - } - }() - timer.Reset(time.Second) - } - } - }() -} - -func (rate *Ratelimiter) Allow(ip net.IP) bool { - var entry *RatelimiterEntry - var KeyIPv4 [net.IPv4len]byte - var KeyIPv6 [net.IPv6len]byte - - // lookup entry - - IPv4 := ip.To4() - IPv6 := ip.To16() - - rate.mutex.RLock() - - if IPv4 != nil { - copy(KeyIPv4[:], IPv4) - entry = rate.tableIPv4[KeyIPv4] - } else { - copy(KeyIPv6[:], IPv6) - entry = rate.tableIPv6[KeyIPv6] - } - - rate.mutex.RUnlock() - - // make new entry if not found - - if entry == nil { - rate.mutex.Lock() - entry = new(RatelimiterEntry) - entry.tokens = maxTokens - packetCost - entry.lastTime = time.Now() - if IPv4 != nil { - rate.tableIPv4[KeyIPv4] = entry - } else { - rate.tableIPv6[KeyIPv6] = entry - } - rate.mutex.Unlock() - return true - } - - // add tokens to entry - - entry.mutex.Lock() - now := time.Now() - entry.tokens += now.Sub(entry.lastTime).Nanoseconds() - entry.lastTime = now - if entry.tokens > maxTokens { - entry.tokens = maxTokens - } - - // subtract cost of packet - - if entry.tokens > packetCost { - entry.tokens -= packetCost - entry.mutex.Unlock() - return true - } - entry.mutex.Unlock() - return false -} diff --git a/internal/ratelimiter/ratelimiter_test.go b/internal/ratelimiter/ratelimiter_test.go deleted file mode 100644 index 37339ee..0000000 --- a/internal/ratelimiter/ratelimiter_test.go +++ /dev/null @@ -1,98 +0,0 @@ -package ratelimiter - -import ( - "net" - "testing" - "time" -) - -type RatelimiterResult struct { - allowed bool - text string - wait time.Duration -} - -func TestRatelimiter(t *testing.T) { - - var ratelimiter Ratelimiter - var expectedResults []RatelimiterResult - - Nano := func(nano int64) time.Duration { - return time.Nanosecond * time.Duration(nano) - } - - Add := func(res RatelimiterResult) { - expectedResults = append( - expectedResults, - res, - ) - } - - for i := 0; i < packetsBurstable; i++ { - Add(RatelimiterResult{ - allowed: true, - text: "inital burst", - }) - } - - Add(RatelimiterResult{ - allowed: false, - text: "after burst", - }) - - Add(RatelimiterResult{ - allowed: true, - wait: Nano(time.Second.Nanoseconds() / packetsPerSecond), - text: "filling tokens for single packet", - }) - - Add(RatelimiterResult{ - allowed: false, - text: "not having refilled enough", - }) - - Add(RatelimiterResult{ - allowed: true, - wait: 2 * (Nano(time.Second.Nanoseconds() / packetsPerSecond)), - text: "filling tokens for two packet burst", - }) - - Add(RatelimiterResult{ - allowed: true, - text: "second packet in 2 packet burst", - }) - - Add(RatelimiterResult{ - allowed: false, - text: "packet following 2 packet burst", - }) - - ips := []net.IP{ - net.ParseIP("127.0.0.1"), - net.ParseIP("192.168.1.1"), - net.ParseIP("172.167.2.3"), - net.ParseIP("97.231.252.215"), - net.ParseIP("248.97.91.167"), - net.ParseIP("188.208.233.47"), - net.ParseIP("104.2.183.179"), - net.ParseIP("72.129.46.120"), - net.ParseIP("2001:0db8:0a0b:12f0:0000:0000:0000:0001"), - net.ParseIP("f5c2:818f:c052:655a:9860:b136:6894:25f0"), - net.ParseIP("b2d7:15ab:48a7:b07c:a541:f144:a9fe:54fc"), - net.ParseIP("a47b:786e:1671:a22b:d6f9:4ab0:abc7:c918"), - net.ParseIP("ea1e:d155:7f7a:98fb:2bf5:9483:80f6:5445"), - net.ParseIP("3f0e:54a2:f5b4:cd19:a21d:58e1:3746:84c4"), - } - - ratelimiter.Init() - - for i, res := range expectedResults { - time.Sleep(res.wait) - for _, ip := range ips { - allowed := ratelimiter.Allow(ip) - if allowed != res.allowed { - t.Fatal("Test failed for", ip.String(), ", on:", i, "(", res.text, ")", "expected:", res.allowed, "got:", allowed) - } - } - } -} diff --git a/internal/tai64n/tai64n.go b/internal/tai64n/tai64n.go deleted file mode 100644 index da5257c..0000000 --- a/internal/tai64n/tai64n.go +++ /dev/null @@ -1,26 +0,0 @@ -package tai64n - -import ( - "bytes" - "encoding/binary" - "time" -) - -const TimestampSize = 12 -const base = uint64(4611686018427387914) - -type Timestamp [TimestampSize]byte - -func Now() Timestamp { - var tai64n Timestamp - now := time.Now() - secs := base + uint64(now.Unix()) - nano := uint32(now.UnixNano()) - binary.BigEndian.PutUint64(tai64n[:], secs) - binary.BigEndian.PutUint32(tai64n[8:], nano) - return tai64n -} - -func (t1 Timestamp) After(t2 Timestamp) bool { - return bytes.Compare(t1[:], t2[:]) > 0 -} diff --git a/internal/tai64n/tai64n_test.go b/internal/tai64n/tai64n_test.go deleted file mode 100644 index 389b65c..0000000 --- a/internal/tai64n/tai64n_test.go +++ /dev/null @@ -1,21 +0,0 @@ -package tai64n - -import ( - "testing" - "time" -) - -/* Testing the essential property of the timestamp - * as used by WireGuard. - */ -func TestMonotonic(t *testing.T) { - old := Now() - for i := 0; i < 10000; i++ { - time.Sleep(time.Nanosecond) - next := Now() - if !next.After(old) { - t.Error("TAI64N, not monotonically increasing on nano-second scale") - } - old = next - } -} diff --git a/internal/xchacha20poly1305/xchacha20.go b/internal/xchacha20poly1305/xchacha20.go deleted file mode 100644 index a6e59f0..0000000 --- a/internal/xchacha20poly1305/xchacha20.go +++ /dev/null @@ -1,169 +0,0 @@ -// Copyright (c) 2016 Andreas Auernhammer. All rights reserved. -// Use of this source code is governed by a license that can be -// found in the LICENSE file. - -package xchacha20poly1305 - -import ( - "encoding/binary" - "golang.org/x/crypto/chacha20poly1305" -) - -func hChaCha20(out *[32]byte, nonce []byte, key *[32]byte) { - - v00 := uint32(0x61707865) - v01 := uint32(0x3320646e) - v02 := uint32(0x79622d32) - v03 := uint32(0x6b206574) - - v04 := binary.LittleEndian.Uint32(key[0:]) - v05 := binary.LittleEndian.Uint32(key[4:]) - v06 := binary.LittleEndian.Uint32(key[8:]) - v07 := binary.LittleEndian.Uint32(key[12:]) - v08 := binary.LittleEndian.Uint32(key[16:]) - v09 := binary.LittleEndian.Uint32(key[20:]) - v10 := binary.LittleEndian.Uint32(key[24:]) - v11 := binary.LittleEndian.Uint32(key[28:]) - v12 := binary.LittleEndian.Uint32(nonce[0:]) - v13 := binary.LittleEndian.Uint32(nonce[4:]) - v14 := binary.LittleEndian.Uint32(nonce[8:]) - v15 := binary.LittleEndian.Uint32(nonce[12:]) - - for i := 0; i < 20; i += 2 { - v00 += v04 - v12 ^= v00 - v12 = (v12 << 16) | (v12 >> 16) - v08 += v12 - v04 ^= v08 - v04 = (v04 << 12) | (v04 >> 20) - v00 += v04 - v12 ^= v00 - v12 = (v12 << 8) | (v12 >> 24) - v08 += v12 - v04 ^= v08 - v04 = (v04 << 7) | (v04 >> 25) - v01 += v05 - v13 ^= v01 - v13 = (v13 << 16) | (v13 >> 16) - v09 += v13 - v05 ^= v09 - v05 = (v05 << 12) | (v05 >> 20) - v01 += v05 - v13 ^= v01 - v13 = (v13 << 8) | (v13 >> 24) - v09 += v13 - v05 ^= v09 - v05 = (v05 << 7) | (v05 >> 25) - v02 += v06 - v14 ^= v02 - v14 = (v14 << 16) | (v14 >> 16) - v10 += v14 - v06 ^= v10 - v06 = (v06 << 12) | (v06 >> 20) - v02 += v06 - v14 ^= v02 - v14 = (v14 << 8) | (v14 >> 24) - v10 += v14 - v06 ^= v10 - v06 = (v06 << 7) | (v06 >> 25) - v03 += v07 - v15 ^= v03 - v15 = (v15 << 16) | (v15 >> 16) - v11 += v15 - v07 ^= v11 - v07 = (v07 << 12) | (v07 >> 20) - v03 += v07 - v15 ^= v03 - v15 = (v15 << 8) | (v15 >> 24) - v11 += v15 - v07 ^= v11 - v07 = (v07 << 7) | (v07 >> 25) - v00 += v05 - v15 ^= v00 - v15 = (v15 << 16) | (v15 >> 16) - v10 += v15 - v05 ^= v10 - v05 = (v05 << 12) | (v05 >> 20) - v00 += v05 - v15 ^= v00 - v15 = (v15 << 8) | (v15 >> 24) - v10 += v15 - v05 ^= v10 - v05 = (v05 << 7) | (v05 >> 25) - v01 += v06 - v12 ^= v01 - v12 = (v12 << 16) | (v12 >> 16) - v11 += v12 - v06 ^= v11 - v06 = (v06 << 12) | (v06 >> 20) - v01 += v06 - v12 ^= v01 - v12 = (v12 << 8) | (v12 >> 24) - v11 += v12 - v06 ^= v11 - v06 = (v06 << 7) | (v06 >> 25) - v02 += v07 - v13 ^= v02 - v13 = (v13 << 16) | (v13 >> 16) - v08 += v13 - v07 ^= v08 - v07 = (v07 << 12) | (v07 >> 20) - v02 += v07 - v13 ^= v02 - v13 = (v13 << 8) | (v13 >> 24) - v08 += v13 - v07 ^= v08 - v07 = (v07 << 7) | (v07 >> 25) - v03 += v04 - v14 ^= v03 - v14 = (v14 << 16) | (v14 >> 16) - v09 += v14 - v04 ^= v09 - v04 = (v04 << 12) | (v04 >> 20) - v03 += v04 - v14 ^= v03 - v14 = (v14 << 8) | (v14 >> 24) - v09 += v14 - v04 ^= v09 - v04 = (v04 << 7) | (v04 >> 25) - } - - binary.LittleEndian.PutUint32(out[0:], v00) - binary.LittleEndian.PutUint32(out[4:], v01) - binary.LittleEndian.PutUint32(out[8:], v02) - binary.LittleEndian.PutUint32(out[12:], v03) - binary.LittleEndian.PutUint32(out[16:], v12) - binary.LittleEndian.PutUint32(out[20:], v13) - binary.LittleEndian.PutUint32(out[24:], v14) - binary.LittleEndian.PutUint32(out[28:], v15) -} - -func Encrypt( - dst []byte, - nonceFull *[24]byte, - plaintext []byte, - additionalData []byte, - key *[chacha20poly1305.KeySize]byte, -) []byte { - var nonce [chacha20poly1305.NonceSize]byte - var derivedKey [chacha20poly1305.KeySize]byte - hChaCha20(&derivedKey, nonceFull[:16], key) - aead, _ := chacha20poly1305.New(derivedKey[:]) - copy(nonce[4:], nonceFull[16:]) - return aead.Seal(dst, nonce[:], plaintext, additionalData) -} - -func Decrypt( - dst []byte, - nonceFull *[24]byte, - plaintext []byte, - additionalData []byte, - key *[chacha20poly1305.KeySize]byte, -) ([]byte, error) { - var nonce [chacha20poly1305.NonceSize]byte - var derivedKey [chacha20poly1305.KeySize]byte - hChaCha20(&derivedKey, nonceFull[:16], key) - aead, _ := chacha20poly1305.New(derivedKey[:]) - copy(nonce[4:], nonceFull[16:]) - return aead.Open(dst, nonce[:], plaintext, additionalData) -} diff --git a/internal/xchacha20poly1305/xchacha20_test.go b/internal/xchacha20poly1305/xchacha20_test.go deleted file mode 100644 index 5d5b78f..0000000 --- a/internal/xchacha20poly1305/xchacha20_test.go +++ /dev/null @@ -1,96 +0,0 @@ -package xchacha20poly1305 - -import ( - "encoding/hex" - "testing" -) - -type XChaCha20Test struct { - Nonce string - Key string - PT string - CT string -} - -func TestXChaCha20(t *testing.T) { - - tests := []XChaCha20Test{ - { - Nonce: "000000000000000000000000000000000000000000000000", - Key: "0000000000000000000000000000000000000000000000000000000000000000", - PT: "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - CT: "789e9689e5208d7fd9e1f3c5b5341f48ef18a13e418998addadd97a3693a987f8e82ecd5c1433bfed1af49750c0f1ff29c4174a05b119aa3a9e8333812e0c0feb1299c5949d895ee01dbf50f8395dd84", - }, - { - Nonce: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", - Key: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", - PT: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", - CT: "e1a046aa7f71e2af8b80b6408b2fd8d3a350278cde79c94d9efaa475e1339b3dd490127b", - }, - { - Nonce: "d9a8213e8a697508805c2c171ad54487ead9e3e02d82d5bc", - Key: "979196dbd78526f2f584f7534db3f5824d8ccfa858ca7e09bdd3656ecd36033c", - PT: "43cc6d624e451bbed952c3e071dc6c03392ce11eb14316a94b2fdc98b22fedea", - CT: "53c1e8bef2dbb8f2505ec010a7afe21d5a8e6dd8f987e4ea1a2ed5dfbc844ea400db34496fd2153526c6e87c36694200", - }, - } - - for _, test := range tests { - - nonce, err := hex.DecodeString(test.Nonce) - if err != nil { - panic(err) - } - - key, err := hex.DecodeString(test.Key) - if err != nil { - panic(err) - } - - pt, err := hex.DecodeString(test.PT) - if err != nil { - panic(err) - } - - func() { - var nonceArray [24]byte - var keyArray [32]byte - copy(nonceArray[:], nonce) - copy(keyArray[:], key) - - // test encryption - - ct := Encrypt( - nil, - &nonceArray, - pt, - nil, - &keyArray, - ) - ctHex := hex.EncodeToString(ct) - if ctHex != test.CT { - t.Fatal("encryption failed, expected:", test.CT, "got", ctHex) - } - - // test decryption - - ptp, err := Decrypt( - nil, - &nonceArray, - ct, - nil, - &keyArray, - ) - if err != nil { - t.Fatal(err) - } - - ptHex := hex.EncodeToString(ptp) - if ptHex != test.PT { - t.Fatal("decryption failed, expected:", test.PT, "got", ptHex) - } - }() - - } - -} diff --git a/noise-protocol.go b/noise-protocol.go index df08a0a..6440c97 100644 --- a/noise-protocol.go +++ b/noise-protocol.go @@ -1,8 +1,8 @@ package main import ( + "./tai64n" "errors" - "git.zx2c4.com/wireguard-go/internal/tai64n" "golang.org/x/crypto/blake2s" "golang.org/x/crypto/chacha20poly1305" "golang.org/x/crypto/poly1305" diff --git a/ratelimiter/ratelimiter.go b/ratelimiter/ratelimiter.go new file mode 100644 index 0000000..006900a --- /dev/null +++ b/ratelimiter/ratelimiter.go @@ -0,0 +1,149 @@ +package ratelimiter + +/* Copyright (C) 2015-2017 Jason A. Donenfeld . All Rights Reserved. */ + +/* This file contains a port of the rate-limiter from the linux kernel version */ + +import ( + "net" + "sync" + "time" +) + +const ( + packetsPerSecond = 20 + packetsBurstable = 5 + garbageCollectTime = time.Second + packetCost = 1000000000 / packetsPerSecond + maxTokens = packetCost * packetsBurstable +) + +type RatelimiterEntry struct { + mutex sync.Mutex + lastTime time.Time + tokens int64 +} + +type Ratelimiter struct { + mutex sync.RWMutex + stop chan struct{} + tableIPv4 map[[net.IPv4len]byte]*RatelimiterEntry + tableIPv6 map[[net.IPv6len]byte]*RatelimiterEntry +} + +func (rate *Ratelimiter) Close() { + rate.mutex.Lock() + defer rate.mutex.Unlock() + + if rate.stop != nil { + close(rate.stop) + } +} + +func (rate *Ratelimiter) Init() { + rate.mutex.Lock() + defer rate.mutex.Unlock() + + // stop any ongoing garbage collection routine + + if rate.stop != nil { + close(rate.stop) + } + + rate.stop = make(chan struct{}) + rate.tableIPv4 = make(map[[net.IPv4len]byte]*RatelimiterEntry) + rate.tableIPv6 = make(map[[net.IPv6len]byte]*RatelimiterEntry) + + // start garbage collection routine + + go func() { + timer := time.NewTimer(time.Second) + for { + select { + case <-rate.stop: + return + case <-timer.C: + func() { + rate.mutex.Lock() + defer rate.mutex.Unlock() + + for key, entry := range rate.tableIPv4 { + entry.mutex.Lock() + if time.Now().Sub(entry.lastTime) > garbageCollectTime { + delete(rate.tableIPv4, key) + } + entry.mutex.Unlock() + } + + for key, entry := range rate.tableIPv6 { + entry.mutex.Lock() + if time.Now().Sub(entry.lastTime) > garbageCollectTime { + delete(rate.tableIPv6, key) + } + entry.mutex.Unlock() + } + }() + timer.Reset(time.Second) + } + } + }() +} + +func (rate *Ratelimiter) Allow(ip net.IP) bool { + var entry *RatelimiterEntry + var KeyIPv4 [net.IPv4len]byte + var KeyIPv6 [net.IPv6len]byte + + // lookup entry + + IPv4 := ip.To4() + IPv6 := ip.To16() + + rate.mutex.RLock() + + if IPv4 != nil { + copy(KeyIPv4[:], IPv4) + entry = rate.tableIPv4[KeyIPv4] + } else { + copy(KeyIPv6[:], IPv6) + entry = rate.tableIPv6[KeyIPv6] + } + + rate.mutex.RUnlock() + + // make new entry if not found + + if entry == nil { + rate.mutex.Lock() + entry = new(RatelimiterEntry) + entry.tokens = maxTokens - packetCost + entry.lastTime = time.Now() + if IPv4 != nil { + rate.tableIPv4[KeyIPv4] = entry + } else { + rate.tableIPv6[KeyIPv6] = entry + } + rate.mutex.Unlock() + return true + } + + // add tokens to entry + + entry.mutex.Lock() + now := time.Now() + entry.tokens += now.Sub(entry.lastTime).Nanoseconds() + entry.lastTime = now + if entry.tokens > maxTokens { + entry.tokens = maxTokens + } + + // subtract cost of packet + + if entry.tokens > packetCost { + entry.tokens -= packetCost + entry.mutex.Unlock() + return true + } + entry.mutex.Unlock() + return false +} diff --git a/ratelimiter/ratelimiter_test.go b/ratelimiter/ratelimiter_test.go new file mode 100644 index 0000000..37339ee --- /dev/null +++ b/ratelimiter/ratelimiter_test.go @@ -0,0 +1,98 @@ +package ratelimiter + +import ( + "net" + "testing" + "time" +) + +type RatelimiterResult struct { + allowed bool + text string + wait time.Duration +} + +func TestRatelimiter(t *testing.T) { + + var ratelimiter Ratelimiter + var expectedResults []RatelimiterResult + + Nano := func(nano int64) time.Duration { + return time.Nanosecond * time.Duration(nano) + } + + Add := func(res RatelimiterResult) { + expectedResults = append( + expectedResults, + res, + ) + } + + for i := 0; i < packetsBurstable; i++ { + Add(RatelimiterResult{ + allowed: true, + text: "inital burst", + }) + } + + Add(RatelimiterResult{ + allowed: false, + text: "after burst", + }) + + Add(RatelimiterResult{ + allowed: true, + wait: Nano(time.Second.Nanoseconds() / packetsPerSecond), + text: "filling tokens for single packet", + }) + + Add(RatelimiterResult{ + allowed: false, + text: "not having refilled enough", + }) + + Add(RatelimiterResult{ + allowed: true, + wait: 2 * (Nano(time.Second.Nanoseconds() / packetsPerSecond)), + text: "filling tokens for two packet burst", + }) + + Add(RatelimiterResult{ + allowed: true, + text: "second packet in 2 packet burst", + }) + + Add(RatelimiterResult{ + allowed: false, + text: "packet following 2 packet burst", + }) + + ips := []net.IP{ + net.ParseIP("127.0.0.1"), + net.ParseIP("192.168.1.1"), + net.ParseIP("172.167.2.3"), + net.ParseIP("97.231.252.215"), + net.ParseIP("248.97.91.167"), + net.ParseIP("188.208.233.47"), + net.ParseIP("104.2.183.179"), + net.ParseIP("72.129.46.120"), + net.ParseIP("2001:0db8:0a0b:12f0:0000:0000:0000:0001"), + net.ParseIP("f5c2:818f:c052:655a:9860:b136:6894:25f0"), + net.ParseIP("b2d7:15ab:48a7:b07c:a541:f144:a9fe:54fc"), + net.ParseIP("a47b:786e:1671:a22b:d6f9:4ab0:abc7:c918"), + net.ParseIP("ea1e:d155:7f7a:98fb:2bf5:9483:80f6:5445"), + net.ParseIP("3f0e:54a2:f5b4:cd19:a21d:58e1:3746:84c4"), + } + + ratelimiter.Init() + + for i, res := range expectedResults { + time.Sleep(res.wait) + for _, ip := range ips { + allowed := ratelimiter.Allow(ip) + if allowed != res.allowed { + t.Fatal("Test failed for", ip.String(), ", on:", i, "(", res.text, ")", "expected:", res.allowed, "got:", allowed) + } + } + } +} diff --git a/tai64n/tai64n.go b/tai64n/tai64n.go new file mode 100644 index 0000000..da5257c --- /dev/null +++ b/tai64n/tai64n.go @@ -0,0 +1,26 @@ +package tai64n + +import ( + "bytes" + "encoding/binary" + "time" +) + +const TimestampSize = 12 +const base = uint64(4611686018427387914) + +type Timestamp [TimestampSize]byte + +func Now() Timestamp { + var tai64n Timestamp + now := time.Now() + secs := base + uint64(now.Unix()) + nano := uint32(now.UnixNano()) + binary.BigEndian.PutUint64(tai64n[:], secs) + binary.BigEndian.PutUint32(tai64n[8:], nano) + return tai64n +} + +func (t1 Timestamp) After(t2 Timestamp) bool { + return bytes.Compare(t1[:], t2[:]) > 0 +} diff --git a/tai64n/tai64n_test.go b/tai64n/tai64n_test.go new file mode 100644 index 0000000..389b65c --- /dev/null +++ b/tai64n/tai64n_test.go @@ -0,0 +1,21 @@ +package tai64n + +import ( + "testing" + "time" +) + +/* Testing the essential property of the timestamp + * as used by WireGuard. + */ +func TestMonotonic(t *testing.T) { + old := Now() + for i := 0; i < 10000; i++ { + time.Sleep(time.Nanosecond) + next := Now() + if !next.After(old) { + t.Error("TAI64N, not monotonically increasing on nano-second scale") + } + old = next + } +} diff --git a/xchacha20poly1305/xchacha20.go b/xchacha20poly1305/xchacha20.go new file mode 100644 index 0000000..a6e59f0 --- /dev/null +++ b/xchacha20poly1305/xchacha20.go @@ -0,0 +1,169 @@ +// Copyright (c) 2016 Andreas Auernhammer. All rights reserved. +// Use of this source code is governed by a license that can be +// found in the LICENSE file. + +package xchacha20poly1305 + +import ( + "encoding/binary" + "golang.org/x/crypto/chacha20poly1305" +) + +func hChaCha20(out *[32]byte, nonce []byte, key *[32]byte) { + + v00 := uint32(0x61707865) + v01 := uint32(0x3320646e) + v02 := uint32(0x79622d32) + v03 := uint32(0x6b206574) + + v04 := binary.LittleEndian.Uint32(key[0:]) + v05 := binary.LittleEndian.Uint32(key[4:]) + v06 := binary.LittleEndian.Uint32(key[8:]) + v07 := binary.LittleEndian.Uint32(key[12:]) + v08 := binary.LittleEndian.Uint32(key[16:]) + v09 := binary.LittleEndian.Uint32(key[20:]) + v10 := binary.LittleEndian.Uint32(key[24:]) + v11 := binary.LittleEndian.Uint32(key[28:]) + v12 := binary.LittleEndian.Uint32(nonce[0:]) + v13 := binary.LittleEndian.Uint32(nonce[4:]) + v14 := binary.LittleEndian.Uint32(nonce[8:]) + v15 := binary.LittleEndian.Uint32(nonce[12:]) + + for i := 0; i < 20; i += 2 { + v00 += v04 + v12 ^= v00 + v12 = (v12 << 16) | (v12 >> 16) + v08 += v12 + v04 ^= v08 + v04 = (v04 << 12) | (v04 >> 20) + v00 += v04 + v12 ^= v00 + v12 = (v12 << 8) | (v12 >> 24) + v08 += v12 + v04 ^= v08 + v04 = (v04 << 7) | (v04 >> 25) + v01 += v05 + v13 ^= v01 + v13 = (v13 << 16) | (v13 >> 16) + v09 += v13 + v05 ^= v09 + v05 = (v05 << 12) | (v05 >> 20) + v01 += v05 + v13 ^= v01 + v13 = (v13 << 8) | (v13 >> 24) + v09 += v13 + v05 ^= v09 + v05 = (v05 << 7) | (v05 >> 25) + v02 += v06 + v14 ^= v02 + v14 = (v14 << 16) | (v14 >> 16) + v10 += v14 + v06 ^= v10 + v06 = (v06 << 12) | (v06 >> 20) + v02 += v06 + v14 ^= v02 + v14 = (v14 << 8) | (v14 >> 24) + v10 += v14 + v06 ^= v10 + v06 = (v06 << 7) | (v06 >> 25) + v03 += v07 + v15 ^= v03 + v15 = (v15 << 16) | (v15 >> 16) + v11 += v15 + v07 ^= v11 + v07 = (v07 << 12) | (v07 >> 20) + v03 += v07 + v15 ^= v03 + v15 = (v15 << 8) | (v15 >> 24) + v11 += v15 + v07 ^= v11 + v07 = (v07 << 7) | (v07 >> 25) + v00 += v05 + v15 ^= v00 + v15 = (v15 << 16) | (v15 >> 16) + v10 += v15 + v05 ^= v10 + v05 = (v05 << 12) | (v05 >> 20) + v00 += v05 + v15 ^= v00 + v15 = (v15 << 8) | (v15 >> 24) + v10 += v15 + v05 ^= v10 + v05 = (v05 << 7) | (v05 >> 25) + v01 += v06 + v12 ^= v01 + v12 = (v12 << 16) | (v12 >> 16) + v11 += v12 + v06 ^= v11 + v06 = (v06 << 12) | (v06 >> 20) + v01 += v06 + v12 ^= v01 + v12 = (v12 << 8) | (v12 >> 24) + v11 += v12 + v06 ^= v11 + v06 = (v06 << 7) | (v06 >> 25) + v02 += v07 + v13 ^= v02 + v13 = (v13 << 16) | (v13 >> 16) + v08 += v13 + v07 ^= v08 + v07 = (v07 << 12) | (v07 >> 20) + v02 += v07 + v13 ^= v02 + v13 = (v13 << 8) | (v13 >> 24) + v08 += v13 + v07 ^= v08 + v07 = (v07 << 7) | (v07 >> 25) + v03 += v04 + v14 ^= v03 + v14 = (v14 << 16) | (v14 >> 16) + v09 += v14 + v04 ^= v09 + v04 = (v04 << 12) | (v04 >> 20) + v03 += v04 + v14 ^= v03 + v14 = (v14 << 8) | (v14 >> 24) + v09 += v14 + v04 ^= v09 + v04 = (v04 << 7) | (v04 >> 25) + } + + binary.LittleEndian.PutUint32(out[0:], v00) + binary.LittleEndian.PutUint32(out[4:], v01) + binary.LittleEndian.PutUint32(out[8:], v02) + binary.LittleEndian.PutUint32(out[12:], v03) + binary.LittleEndian.PutUint32(out[16:], v12) + binary.LittleEndian.PutUint32(out[20:], v13) + binary.LittleEndian.PutUint32(out[24:], v14) + binary.LittleEndian.PutUint32(out[28:], v15) +} + +func Encrypt( + dst []byte, + nonceFull *[24]byte, + plaintext []byte, + additionalData []byte, + key *[chacha20poly1305.KeySize]byte, +) []byte { + var nonce [chacha20poly1305.NonceSize]byte + var derivedKey [chacha20poly1305.KeySize]byte + hChaCha20(&derivedKey, nonceFull[:16], key) + aead, _ := chacha20poly1305.New(derivedKey[:]) + copy(nonce[4:], nonceFull[16:]) + return aead.Seal(dst, nonce[:], plaintext, additionalData) +} + +func Decrypt( + dst []byte, + nonceFull *[24]byte, + plaintext []byte, + additionalData []byte, + key *[chacha20poly1305.KeySize]byte, +) ([]byte, error) { + var nonce [chacha20poly1305.NonceSize]byte + var derivedKey [chacha20poly1305.KeySize]byte + hChaCha20(&derivedKey, nonceFull[:16], key) + aead, _ := chacha20poly1305.New(derivedKey[:]) + copy(nonce[4:], nonceFull[16:]) + return aead.Open(dst, nonce[:], plaintext, additionalData) +} diff --git a/xchacha20poly1305/xchacha20_test.go b/xchacha20poly1305/xchacha20_test.go new file mode 100644 index 0000000..5d5b78f --- /dev/null +++ b/xchacha20poly1305/xchacha20_test.go @@ -0,0 +1,96 @@ +package xchacha20poly1305 + +import ( + "encoding/hex" + "testing" +) + +type XChaCha20Test struct { + Nonce string + Key string + PT string + CT string +} + +func TestXChaCha20(t *testing.T) { + + tests := []XChaCha20Test{ + { + Nonce: "000000000000000000000000000000000000000000000000", + Key: "0000000000000000000000000000000000000000000000000000000000000000", + PT: "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + CT: "789e9689e5208d7fd9e1f3c5b5341f48ef18a13e418998addadd97a3693a987f8e82ecd5c1433bfed1af49750c0f1ff29c4174a05b119aa3a9e8333812e0c0feb1299c5949d895ee01dbf50f8395dd84", + }, + { + Nonce: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", + Key: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", + PT: "0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f", + CT: "e1a046aa7f71e2af8b80b6408b2fd8d3a350278cde79c94d9efaa475e1339b3dd490127b", + }, + { + Nonce: "d9a8213e8a697508805c2c171ad54487ead9e3e02d82d5bc", + Key: "979196dbd78526f2f584f7534db3f5824d8ccfa858ca7e09bdd3656ecd36033c", + PT: "43cc6d624e451bbed952c3e071dc6c03392ce11eb14316a94b2fdc98b22fedea", + CT: "53c1e8bef2dbb8f2505ec010a7afe21d5a8e6dd8f987e4ea1a2ed5dfbc844ea400db34496fd2153526c6e87c36694200", + }, + } + + for _, test := range tests { + + nonce, err := hex.DecodeString(test.Nonce) + if err != nil { + panic(err) + } + + key, err := hex.DecodeString(test.Key) + if err != nil { + panic(err) + } + + pt, err := hex.DecodeString(test.PT) + if err != nil { + panic(err) + } + + func() { + var nonceArray [24]byte + var keyArray [32]byte + copy(nonceArray[:], nonce) + copy(keyArray[:], key) + + // test encryption + + ct := Encrypt( + nil, + &nonceArray, + pt, + nil, + &keyArray, + ) + ctHex := hex.EncodeToString(ct) + if ctHex != test.CT { + t.Fatal("encryption failed, expected:", test.CT, "got", ctHex) + } + + // test decryption + + ptp, err := Decrypt( + nil, + &nonceArray, + ct, + nil, + &keyArray, + ) + if err != nil { + t.Fatal(err) + } + + ptHex := hex.EncodeToString(ptp) + if ptHex != test.PT { + t.Fatal("decryption failed, expected:", test.PT, "got", ptHex) + } + }() + + } + +} -- cgit v1.2.3