aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/revoke-zonekey/main.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/cmd/revoke-zonekey/main.go')
-rw-r--r--src/cmd/revoke-zonekey/main.go202
1 files changed, 0 insertions, 202 deletions
diff --git a/src/cmd/revoke-zonekey/main.go b/src/cmd/revoke-zonekey/main.go
deleted file mode 100644
index 7deeda6..0000000
--- a/src/cmd/revoke-zonekey/main.go
+++ /dev/null
@@ -1,202 +0,0 @@
1// This file is part of gnunet-go, a GNUnet-implementation in Golang.
2// Copyright (C) 2019, 2020 Bernd Fix >Y<
3//
4// gnunet-go is free software: you can redistribute it and/or modify it
5// under the terms of the GNU Affero General Public License as published
6// by the Free Software Foundation, either version 3 of the License,
7// or (at your option) any later version.
8//
9// gnunet-go is distributed in the hope that it will be useful, but
10// WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12// Affero General Public License for more details.
13//
14// You should have received a copy of the GNU Affero General Public License
15// along with this program. If not, see <http://www.gnu.org/licenses/>.
16//
17// SPDX-License-Identifier: AGPL3.0-or-later
18
19package main
20
21import (
22 "context"
23 "encoding/hex"
24 "flag"
25 "log"
26 "os"
27 "os/signal"
28 "sync"
29 "syscall"
30
31 "gnunet/service/revocation"
32 "gnunet/util"
33
34 "github.com/bfix/gospel/data"
35)
36
37func main() {
38 log.Println("*** Compute revocation data for a zone key")
39 log.Println("*** Copyright (c) 2020, Bernd Fix >Y<")
40 log.Println("*** This is free software distributed under the Affero GPL v3.")
41
42 // handle command line arguments
43 var (
44 verbose bool // be verbose with messages
45 bits int // number of leading zero-bit requested
46 zonekey string // zonekey to be revoked
47 filename string // name of file for persistance
48 )
49 flag.IntVar(&bits, "b", 25, "Number of leading zero bits")
50 flag.BoolVar(&verbose, "v", false, "verbose output")
51 flag.StringVar(&zonekey, "z", "", "Zone key to be revoked")
52 flag.StringVar(&filename, "f", "", "Name of file to store revocation")
53 flag.Parse()
54
55 if len(filename) == 0 {
56 log.Fatal("Missing '-f' argument (filename fot revocation data)")
57 }
58
59 // define layout of persistant data
60 var revData struct {
61 Rd *revocation.RevDataCalc // Revocation data
62 T util.RelativeTime // time spend in calculations
63 Last uint64 // last value used for PoW test
64 Numbits uint8 // number of leading zero-bits
65 }
66 dataBuf := make([]byte, 450)
67
68 // read revocation object from file
69 file, err := os.Open(filename)
70 cont := true
71 if err != nil {
72 if len(zonekey) != 52 {
73 log.Fatal("Missing or invalid zonekey and no file specified -- aborting")
74 }
75 keyData, err := util.DecodeStringToBinary(zonekey, 32)
76 if err != nil {
77 log.Fatal("Invalid zonekey: " + err.Error())
78 }
79 revData.Rd = revocation.NewRevDataCalc(keyData)
80 revData.Numbits = uint8(bits)
81 revData.T = util.NewRelativeTime(0)
82 cont = false
83 } else {
84 n, err := file.Read(dataBuf)
85 if err != nil {
86 log.Fatal("Error reading file: " + err.Error())
87 }
88 if n != len(dataBuf) {
89 log.Fatal("File corrupted -- aborting")
90 }
91 if err = data.Unmarshal(&revData, dataBuf); err != nil {
92 log.Fatal("File corrupted: " + err.Error())
93 }
94 bits = int(revData.Numbits)
95 if err = file.Close(); err != nil {
96 log.Fatal("Error closing file: " + err.Error())
97 }
98 }
99
100 if cont {
101 log.Printf("Revocation calculation started at %s\n", revData.Rd.Timestamp.String())
102 log.Printf("Time spent on calculation: %s\n", revData.T.String())
103 log.Printf("Last tested PoW value: %d\n", revData.Last)
104 log.Println("Continuing...")
105 } else {
106 log.Println("Starting new revocation calculation...")
107 }
108 log.Println("Press ^C to abort...")
109
110 // pre-set difficulty
111 log.Printf("Difficulty: %d\n", bits)
112 if bits < 25 {
113 log.Println("WARNING: difficulty is less than 25!")
114 }
115
116 // Start or continue calculation
117 ctx, cancelFcn := context.WithCancel(context.Background())
118 wg := new(sync.WaitGroup)
119 wg.Add(1)
120 go func() {
121 defer wg.Done()
122 cb := func(average float64, last uint64) {
123 log.Printf("Improved PoW: %f average zero bits, %d steps\n", average, last)
124 }
125
126 startTime := util.AbsoluteTimeNow()
127 average, last := revData.Rd.Compute(ctx, bits, revData.Last, cb)
128 if average < float64(bits) {
129 log.Printf("Incomplete revocation: Only %f zero bits on average!\n", average)
130 } else {
131 log.Println("Revocation data object:")
132 log.Println(" 0x" + hex.EncodeToString(revData.Rd.Blob()))
133 log.Println("Status:")
134 rc := revData.Rd.Verify(false)
135 switch {
136 case rc == -1:
137 log.Println(" Missing/invalid signature")
138 case rc == -2:
139 log.Println(" Expired revocation")
140 case rc == -3:
141 log.Println(" Wrong PoW sequence order")
142 case rc < 25:
143 log.Println(" Difficulty to small")
144 default:
145 log.Printf(" Difficulty: %d\n", rc)
146 }
147 }
148 if !cont || last != revData.Last {
149 revData.Last = last
150 revData.T = util.AbsoluteTimeNow().Diff(startTime)
151
152 log.Println("Writing revocation data to file...")
153 file, err := os.Create(filename)
154 if err != nil {
155 log.Fatal("Can't write to output file: " + err.Error())
156 }
157 buf, err := data.Marshal(&revData)
158 if err != nil {
159 log.Fatal("Internal error: " + err.Error())
160 }
161 if len(buf) != len(dataBuf) {
162 log.Fatalf("Internal error: Buffer mismatch %d != %d", len(buf), len(dataBuf))
163 }
164 n, err := file.Write(buf)
165 if err != nil {
166 log.Fatal("Can't write to output file: " + err.Error())
167 }
168 if n != len(dataBuf) {
169 log.Fatal("Can't write data to output file!")
170 }
171 if err = file.Close(); err != nil {
172 log.Fatal("Error closing file: " + err.Error())
173 }
174 }
175 }()
176
177 go func() {
178 // handle OS signals
179 sigCh := make(chan os.Signal, 5)
180 signal.Notify(sigCh)
181 loop:
182 for {
183 select {
184 // handle OS signals
185 case sig := <-sigCh:
186 switch sig {
187 case syscall.SIGKILL, syscall.SIGINT, syscall.SIGTERM:
188 log.Printf("Terminating (on signal '%s')\n", sig)
189 cancelFcn()
190 break loop
191 case syscall.SIGHUP:
192 log.Println("SIGHUP")
193 case syscall.SIGURG:
194 // TODO: https://github.com/golang/go/issues/37942
195 default:
196 log.Println("Unhandled signal: " + sig.String())
197 }
198 }
199 }
200 }()
201 wg.Wait()
202}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 16:56:41 +0000