This repository has been archived on 2024-03-28. You can view files and clone it, but cannot push or open issues or pull requests.
chunkvalidator/main.go

184 lines
4.4 KiB
Go

package main
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"flag"
"fmt"
"log"
"math/rand"
"net/http"
"os"
"strconv"
"strings"
"time"
)
var chunkSize = 2
var currentChunk string
func init() {
rand.Seed(time.Now().UnixNano())
}
func newChunk() {
bid := make([]byte, 4)
rand.Read(bid)
currentChunk = hex.EncodeToString(bid)[:chunkSize]
}
type uploadChunk struct {
Proof string `json:"proof"`
Login string `json:"login"`
}
func checkChunk(rndb string) bool {
rnd, err := hex.DecodeString(rndb)
if err != nil {
return false
}
sum := sha256.Sum256(append(rnd, currentChunk[0]))
return strings.HasPrefix(hex.EncodeToString(sum[:]), currentChunk[1:])
}
func ServeChunk(w http.ResponseWriter, r *http.Request) {
if addr := r.Header.Get("X-Forwarded-For"); addr != "" {
r.RemoteAddr = addr
}
log.Printf("Handling %s request from %s: %s [%s]\n", r.Method, r.RemoteAddr, r.URL.Path, r.UserAgent())
w.Header().Set("Content-Type", "text/plain")
if r.Method == "POST" {
if r.ContentLength < 0 || r.ContentLength > 6553600 {
http.Error(w, fmt.Sprintf("{errmsg:\"Request too large or request size unknown\"}"), http.StatusRequestEntityTooLarge)
return
}
var body []byte
if r.ContentLength > 0 {
tmp := make([]byte, 1024)
for {
n, err := r.Body.Read(tmp)
for j := 0; j < n; j++ {
body = append(body, tmp[j])
}
if err != nil || n <= 0 {
break
}
}
}
var uc uploadChunk
if err := json.Unmarshal(body, &uc); err != nil {
log.Println(err)
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error()))
} else if checkChunk(uc.Proof) {
newChunk()
if uc.Login == "root" {
uc.Login = "nemunaire"
log.Println("Good chunk from root given to", uc.Login)
} else {
log.Println("Good chunk from", uc.Login)
}
if _, err := DBExec("INSERT INTO chunks (time, username, chunk, proof) VALUES (?, ?, ?, ?)", time.Now(), uc.Login, currentChunk, uc.Proof); err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error()))
} else {
w.WriteHeader(http.StatusOK)
w.Write([]byte("true"))
}
} else {
log.Println("BAD chunk from", uc.Login)
}
} else {
w.WriteHeader(http.StatusOK)
w.Write([]byte(currentChunk))
}
}
type Score struct {
Login string `json:"login"`
NbChunk int `json:"chunks"`
Time time.Time `json:"time"`
}
func ServeScores(w http.ResponseWriter, r *http.Request) {
if addr := r.Header.Get("X-Forwarded-For"); addr != "" {
r.RemoteAddr = addr
}
log.Printf("Handling %s request from %s: %s [%s]\n", r.Method, r.RemoteAddr, r.URL.Path, r.UserAgent())
isJson := false
if strings.HasSuffix(r.URL.Path, "/scores.json") {
w.Header().Set("Content-Type", "application/json")
isJson = true
} else {
w.Header().Set("Content-Type", "text/plain")
}
if rows, err := DBQuery("SELECT username, COUNT(id_chunk) AS nbchunk, MAX(time) AS time FROM chunks GROUP BY username ORDER BY nbchunk DESC"); err != nil {
w.WriteHeader(http.StatusBadRequest)
w.Write([]byte(err.Error()))
} else {
defer rows.Close()
w.WriteHeader(http.StatusOK)
var scores []Score
for rows.Next() {
var score Score
if err := rows.Scan(&score.Login, &score.NbChunk, &score.Time); err == nil {
if isJson {
scores = append(scores, score)
} else {
w.Write([]byte(fmt.Sprintf("%q,%d,%q\n", score.Login, score.NbChunk, score.Time)))
}
}
}
if isJson {
res, _ := json.Marshal(scores)
w.Write(res)
}
}
}
func main() {
if v, exists := os.LookupEnv("CHUNKSIZE"); exists {
if cs, err := strconv.Atoi(v); err == nil {
chunkSize = cs
}
}
var bind = flag.String("bind", "0.0.0.0:8081", "Bind port/socket")
var dsn = flag.String("dsn", DSNGenerator(), "DSN to connect to the MySQL server")
flag.IntVar(&chunkSize, "chunkSize", chunkSize, "Taille du chunk à trouver")
flag.Parse()
newChunk()
// Database connection
log.Println("Opening database...")
if err := DBInit(*dsn); err != nil {
log.Fatal("Cannot open the database: ", err)
}
defer DBClose()
log.Println("Creating database...")
if err := DBCreate(); err != nil {
log.Fatal("Cannot create database: ", err)
}
log.Println("Registering handlers...")
http.HandleFunc("/scores", ServeScores)
http.HandleFunc("/scores.json", ServeScores)
http.HandleFunc("/chunk", ServeChunk)
log.Println(fmt.Sprintf("Ready, listening on %s", *bind))
if err := http.ListenAndServe(*bind, nil); err != nil {
log.Fatal("Unable to listen and serve: ", err)
}
}