mster

LICENSE.md

@@ -1,19 +0,0 @@
-Copyright (c) 2016 Eliot Whalan <ewhal@pantsu.cat>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

cmd/server/main.go

@@ -0,0 +1,596 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"html"
+	"html/template"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"time"
+
+	"git.tuxpa.in/a/nat/lib/store"
+	"git.tuxpa.in/a/nat/lib/store/sqlike"
+	"git.tuxpa.in/a/nat/lib/styler"
+
+	"database/sql"
+
+	"github.com/go-chi/chi/v5"
+
+	"github.com/gorilla/securecookie"
+
+	// bcrypt for password hashing
+	"golang.org/x/crypto/bcrypt"
+)
+
+// Configuration struct,
+type Configuration struct {
+	Address string `json:"address"` // Url to to the pastebin
+
+	ListenAddress  string `json:"listenaddress"`         // Address that pastebin will bind on
+	ListenPort     string `json:"listenport"`            // Port that pastebin will listen on
+	ShortUrlLength int    `json:"shorturllength,string"` // Length of the generated short urls
+}
+
+// This struct is used for generating pages.
+type Page struct {
+	Body            template.HTML
+	Expiry          string
+	GoogleAPIKey    string
+	Lang            string
+	LangsFirst      map[string]string
+	LangsLast       map[string]string
+	PasteTitle      string
+	Style           string
+	SupportedStyles map[string]string
+	Title           string
+	UrlAddress      string
+	UrlClone        string
+	UrlDownload     string
+	UrlHome         string
+	UrlRaw          string
+	WrapperErr      string
+	UserKey         string
+}
+
+// Template pages,
+var templates = template.Must(template.ParseFiles("static/index.html",
+	"static/syntax.html",
+	"static/register.html",
+	"static/pastes.html",
+	"static/login.html"),
+)
+
+// Global variables, *shrug*
+var configuration Configuration
+var dbHandle *sql.DB
+var debug bool
+var debugLogger *log.Logger
+
+type Server struct {
+	store  store.Store
+	styler *styler.Styler
+}
+
+// generate new random cookie keys
+var cookieHandler = securecookie.New(
+	securecookie.GenerateRandomKey(64),
+	securecookie.GenerateRandomKey(32),
+)
+
+//
+// Functions below,
+//
+
+// This struct is used for indata when a request is being made to the pastebin.
+type Request struct {
+	DelKey  string `json:"delkey"`        // The delkey that is used to delete paste
+	Expiry  int64  `json:"expiry,string"` // An expiry date
+	Id      string `json:"id"`            // The id of the paste
+	Lang    string `json:"lang"`          // The language of the paste
+	Paste   string `json:"paste"`         // The actual pase
+	Style   string `json:"style"`         // The style of the paste
+	Title   string `json:"title"`         // The title of the paste
+	UserKey string `json:"key"`           // The title of the paste
+	WebReq  bool   `json:"webreq"`        // If its a webrequest or not
+}
+
+// getSupportedLangs reads supported lexers from the highlighter-wrapper (which
+// in turn gets available lexers from pygments). It then puts them into two
+// maps, depending on if it's a "prioritized" lexers. If it's prioritized or not
+// is determined by if its listed in the assets/prio-lexers.  The description is
+// the key and the actual lexer is the value. The maps are used by the
+// html-template. The function doesn't return anything since the maps are
+// defined globally (shrug).
+
+// printHelp prints a description of the program.
+// Exit code will depend on how the function is called.
+func printHelp(err int) {
+
+	fmt.Printf("\n Description, \n")
+	fmt.Printf("    - pastebin")
+	fmt.Printf(" support for syntax highlightnig (trough python-pygments).\n")
+
+	fmt.Printf(" Usage, \n")
+	fmt.Printf("    - %s [--help] \n\n", os.Args[0])
+
+	fmt.Printf(" Where, \n")
+	fmt.Printf("    - help shows this *incredibly* useful help.\n")
+
+	os.Exit(err)
+}
+
+// checkArgs parses the command line in a very simple manner.
+func checkArgs() {
+
+	if len(os.Args[1:]) >= 1 {
+		for _, arg := range os.Args[1:] {
+			switch arg {
+			case "-h", "--help":
+				printHelp(0)
+			case "-d", "--debug":
+				debug = true
+			default:
+				printHelp(1)
+			}
+		}
+	}
+}
+
+// DelHandler handles the deletion of pastes.
+// If pasteId and DelKey consist the paste will be removed.
+func (s *Server) DelHandler(w http.ResponseWriter, r *http.Request) {
+	var inData Request
+	decoder := json.NewDecoder(r.Body)
+	err := decoder.Decode(&inData)
+
+	inData.Id = chi.URLParam(r, "pasteId")
+
+	// Escape user input,
+	inData.DelKey = html.EscapeString(inData.DelKey)
+	inData.Id = html.EscapeString(inData.Id)
+
+	err = s.store.DelPaste(r.Context(), inData.Id, inData.DelKey)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	b := store.Response{Status: "Deleted paste " + inData.Id}
+	err = json.NewEncoder(w).Encode(b)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// SaveHandler will handle the actual save of each paste.
+// Returns with a store.Response struct.
+func (s *Server) SaveHandler(w http.ResponseWriter, r *http.Request) {
+
+	var inData Request
+
+	decoder := json.NewDecoder(r.Body)
+	err := decoder.Decode(&inData)
+	// Return error if we can't decode the json-data,
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if len(inData.Paste) > 1500000 {
+		http.Error(w, "Paste too long.", 500)
+		return
+	}
+	// Return error if we don't have any data at all
+	if inData.Paste == "" {
+		http.Error(w, "Empty paste.", 500)
+		return
+	}
+
+	if len(inData.Title) > 50 {
+		http.Error(w, "Title to long.", 500)
+		return
+	}
+
+	p, err := s.store.SavePaste(r.Context(), inData.Title, inData.Paste, time.Second*time.Duration(inData.Expiry), inData.UserKey)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(p)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// high calls the highlighter-wrapper and runs the paste through it.
+// Takes the arguments,
+// paste, the actual paste data as a string,
+// lang, the pygments lexer to use as a string,
+// style, the pygments style to use as a string
+// Returns two strings, first is the output from the pygments html-formatter,
+// the second is a custom message
+
+// checkPasteExpiry checks if a paste is overdue.
+// It takes the pasteId as sting and the expiry date as an int64 as arguments.
+// If the paste is overdue it gets deleted and false is returned.
+func (s *Server) checkPasteExpiry(pasteId string, expiretime time.Time) bool {
+	if expiretime.IsZero() {
+	} else {
+		// Current time,
+		now := time.Now()
+		// Human friendly strings for logging,
+		// If expiry is greater than current time, delete paste,
+		if now.After(expiretime) {
+			err := s.store.ForceDelPaste(context.TODO(), pasteId)
+			if err != nil {
+				log.Printf("failed to delete paste: %s, %w\n", pasteId)
+			}
+			return false
+		}
+	}
+
+	return true
+}
+
+func (s *Server) APIHandler(w http.ResponseWriter, r *http.Request) {
+	pasteId := chi.URLParam(r, "pasteId")
+
+	var inData Request
+	decoder := json.NewDecoder(r.Body)
+	err := decoder.Decode(&inData)
+
+	//if err != nil {
+	//   http.Error(w, err.Error(), http.StatusInternalServerError)
+	//  return
+	//}
+
+	// Get the actual paste data,
+	p, err := s.store.GetPaste(r.Context(), pasteId)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if inData.WebReq {
+		// Run it through the highgligther.,
+		p.Paste, p.Extra, p.Lang, p.Style, err = s.styler.Highlight(p.Paste, inData.Lang, inData.Style)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(p)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// pasteHandler generates the html paste pages
+func (s *Server) pasteHandler(w http.ResponseWriter, r *http.Request) {
+
+	pasteId := chi.URLParam(r, "pasteId")
+	lang := chi.URLParam(r, "lang")
+	style := chi.URLParam(r, "style")
+
+	// Get the actual paste data,
+	p, err := s.store.GetPaste(r.Context(), pasteId)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+
+	// Run it through the highgligther.,
+	p.Paste, p.Extra, p.Lang, p.Style, err = s.styler.Highlight(p.Paste, lang, style)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+
+	l := s.styler.Legacy()
+
+	// Construct page struct
+	page := &Page{
+		Body:            template.HTML(p.Paste),
+		Expiry:          p.Expiry,
+		Lang:            p.Lang,
+		LangsFirst:      l[0],
+		LangsLast:       l[1],
+		Style:           p.Style,
+		SupportedStyles: l[2],
+		Title:           p.Title,
+		UrlClone:        configuration.Address + "/clone/" + pasteId,
+		UrlDownload:     configuration.Address + "/download/" + pasteId,
+		UrlHome:         configuration.Address,
+		UrlRaw:          configuration.Address + "/raw/" + pasteId,
+		WrapperErr:      p.Extra,
+	}
+
+	err = templates.ExecuteTemplate(w, "syntax.html", page)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+// CloneHandler handles generating the clone pages
+func (s *Server) CloneHandler(w http.ResponseWriter, r *http.Request) {
+	paste := chi.URLParam(r, "pasteId")
+
+	p, err := s.store.GetPaste(r.Context(), paste)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+
+	}
+	user, _ := s.store.GetUserKey(r.Context(), paste)
+	page := &Page{
+		Body:       template.HTML(p.Paste),
+		PasteTitle: "Copy of " + p.Title,
+		Title:      "Copy of " + p.Title,
+		UserKey:    user,
+	}
+
+	err = templates.ExecuteTemplate(w, "index.html", page)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+// DownloadHandler forces downloads of selected pastes
+func (s *Server) DownloadHandler(w http.ResponseWriter, r *http.Request) {
+	pasteId := chi.URLParam(r, "pasteId")
+
+	p, err := s.store.GetPaste(r.Context(), pasteId)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Set header to an attachment so browser will automatically download it
+	w.Header().Set("Content-Disposition", "attachment; filename="+p.Paste)
+	w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
+	io.WriteString(w, p.Paste)
+}
+
+// RawHandler displays the pastes in text/plain format
+func (s *Server) RawHandler(w http.ResponseWriter, r *http.Request) {
+	pasteId := chi.URLParam(r, "pasteId")
+
+	p, err := s.store.GetPaste(r.Context(), pasteId)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "text/plain; charset=UTF-8; imeanit=yes")
+
+	// Simply write string to browser
+	io.WriteString(w, p.Paste)
+}
+
+// loginHandler
+func (s *Server) loginHandlerGet(w http.ResponseWriter, r *http.Request) {
+	err := templates.ExecuteTemplate(w, "login.html", "")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+func (s *Server) loginHandlerPost(w http.ResponseWriter, r *http.Request) {
+	email := r.FormValue("email")
+	password := r.FormValue("password")
+	email_escaped := html.EscapeString(email)
+
+	hashedPassword, err := s.store.HasAccount(r.Context(), email_escaped)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if len(hashedPassword) == 0 {
+		http.Redirect(w, r, "/register", 302)
+		return
+	}
+	// compare bcrypt hash to userinput password
+	err = bcrypt.CompareHashAndPassword(hashedPassword, []byte(password))
+	if err == nil {
+		// prepare cookie
+		value := map[string]string{
+			"email": email,
+		}
+		// encode variables into cookie
+		if encoded, err := cookieHandler.Encode("session", value); err == nil {
+			cookie := &http.Cookie{
+				Name:  "session",
+				Value: encoded,
+				Path:  "/",
+			}
+			// set user cookie
+			http.SetCookie(w, cookie)
+		}
+		// Redirect to home page
+		http.Redirect(w, r, "/", 302)
+	}
+	// Redirect to login page
+	http.Redirect(w, r, "/login", 302)
+
+}
+
+func (s *Server) pastesHandler(w http.ResponseWriter, r *http.Request) {
+
+	key, err := s.getUserKey(r)
+	b, err := s.store.GetUserPastes(r.Context(), key)
+
+	err = templates.ExecuteTemplate(w, "pastes.html", &b)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+// loggedIn returns true if cookie exists
+func (s *Server) getUserKey(r *http.Request) (string, error) {
+	cookie, err := r.Cookie("session")
+	cookieValue := make(map[string]string)
+	if err != nil {
+		return "", err
+	}
+	err = cookieHandler.Decode("session", cookie.Value, &cookieValue)
+	if err != nil {
+		return "", err
+	}
+	email := cookieValue["email"]
+	// Query database if id exists and if it does call generateName again
+	user_key, err := s.store.GetUserKey(r.Context(), email)
+	switch {
+	case err == sql.ErrNoRows:
+		return "", nil
+	case err != nil:
+		return "", err
+	default:
+	}
+	return user_key, nil
+
+}
+
+// registerHandler
+func (s *Server) registerHandlerGet(w http.ResponseWriter, r *http.Request) {
+	err := templates.ExecuteTemplate(w, "register.html", "")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+func (s *Server) registerHandlerPost(w http.ResponseWriter, r *http.Request) {
+	email := r.FormValue("email")
+	pass := r.FormValue("password")
+	email_escaped := html.EscapeString(email)
+	bts, err := s.store.HasAccount(r.Context(), email_escaped)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	email_taken := true
+	if len(bts) == 0 {
+		email_taken = false
+	}
+	if email_taken {
+		http.Redirect(w, r, "/register", 302)
+		return
+	}
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	err = s.store.RegisterUser(r.Context(), email_escaped, hashedPassword)
+	if err != nil {
+		log.Printf("failed register user %v\n", err)
+	}
+
+	http.Redirect(w, r, "/login", 302)
+
+}
+
+// logoutHandler destroys cookie data and redirects to root
+func (s *Server) logoutHandler(w http.ResponseWriter, r *http.Request) {
+	cookie := &http.Cookie{
+		Name:   "session",
+		Value:  "",
+		Path:   "/",
+		MaxAge: -1,
+	}
+	http.SetCookie(w, cookie)
+	http.Redirect(w, r, "/", 301)
+
+}
+
+// RootHandler handles generating the root page
+func (s *Server) RootHandler(w http.ResponseWriter, r *http.Request) {
+	userkey, err := s.getUserKey(r)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	l := s.styler.Legacy()
+	p := &Page{
+		LangsFirst: l[0],
+		LangsLast:  l[1],
+		Title:      "nat",
+		UrlAddress: configuration.Address,
+		UserKey:    userkey,
+	}
+	err = templates.ExecuteTemplate(w, "index.html", p)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func serveCss(w http.ResponseWriter, r *http.Request) {
+	http.ServeFile(w, r, "static/pastebin.css")
+}
+
+func main() {
+	// Check args,
+	checkArgs()
+
+	// Load config,
+	file, err := os.Open("config.json")
+	if err != nil {
+		os.Exit(1)
+	}
+
+	// Try to parse json,
+	err = json.NewDecoder(file).Decode(&configuration)
+	if err != nil {
+		panic(err)
+	}
+
+	srv := &Server{
+		store:  sqlike.MustNew(),
+		styler: styler.New(),
+	}
+
+	router := chi.NewRouter()
+	router.Get("/", srv.RootHandler)
+	router.Get("/p/{pasteId}", srv.pasteHandler)
+	router.Get("/p/{pasteId}/{lang}", srv.pasteHandler)
+	router.Get("/p/{pasteId}/{lang}/{style}", srv.pasteHandler)
+
+	// Api
+	router.Post("/api", srv.SaveHandler)
+	router.Post("/api/{pasteId}", srv.APIHandler)
+	router.Get("/api/{pasteId}", srv.APIHandler)
+	router.Delete("/api/{pasteId}", srv.DelHandler)
+
+	router.Get("/raw/{pasteId}", srv.RawHandler)
+	router.Get("/clone/{pasteId}", srv.CloneHandler)
+	router.Get("/login", srv.loginHandlerGet)
+	router.Post("/login", srv.loginHandlerPost)
+	router.HandleFunc("/logout", srv.logoutHandler)
+	router.Get("/register", srv.registerHandlerGet)
+	router.Post("/register", srv.registerHandlerPost)
+	router.Get("/pastes", srv.pastesHandler)
+
+	router.Get("/download/{pasteId}", srv.DownloadHandler)
+	router.Get("/assets/pastebin.css", serveCss)
+
+	http_srv := &http.Server{
+		Handler:      router,
+		Addr:         configuration.ListenAddress + ":" + configuration.ListenPort,
+		WriteTimeout: 15 * time.Second,
+		ReadTimeout:  15 * time.Second,
+	}
+
+	log.Println("starting http server on", configuration.ListenAddress, configuration.ListenPort)
+	err = http_srv.ListenAndServe()
+	if err != nil {
+		panic(err)
+	}
+}

config.json

@@ -1,17 +1,15 @@
 {
   "address": "http://localhost:9999",
+  "dbtype": "sql",
   "dbhost": "",
   "dbname": "pastebin.db",
   "dbtable": "pastebin",
   "dbaccountstable": "accounts",
-  "dbtype": "sqlite3",
   "dbport": "",
   "dbuser":"",
   "dbpassword":"",
   "displayname": "MyCompany",
   "listenaddress": "localhost",
   "listenport": "9999",
-  "shorturllength": "5",
+  "shorturllength": "5"
-  "highlighter":"./highlighter-wrapper.py",
-  "googleAPIKey":"insert-if-you-want-goo.gl/addr"
 }

database.sql

@@ -1,17 +0,0 @@
-CREATE TABLE `pastebin` (
-  `id` varchar(30) NOT NULL,
-  `title` varchar(50) default NULL,
-  `hash` char(40) default NULL,
-  `data` longtext,
-  `delkey` char(40) default NULL,
-  `expiry` int,
-  `userid` varchar(255),
-  PRIMARY KEY (`id`)
-);
-
-CREATE TABLE `accounts` (
-  `email` varchar(255) NOT NULL,
-  `password` varchar(255) NOT NULL,
-  `key` varchar(255) NOT NULL,
-  PRIMARY KEY (`key`)
-);

go.mod

@@ -0,0 +1,14 @@
+module git.tuxpa.in/a/nat
+
+go 1.18
+
+require (
+	github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5
+	github.com/go-chi/chi/v5 v5.0.7
+	github.com/go-sql-driver/mysql v1.6.0
+	github.com/gorilla/mux v1.8.0
+	github.com/gorilla/securecookie v1.1.1
+	github.com/lib/pq v1.10.6
+	github.com/mattn/go-sqlite3 v1.14.14
+	golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa
+)

go.sum

@@ -0,0 +1,16 @@
+github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5 h1:RAV05c0xOkJ3dZGS0JFybxFKZ2WMLabgx3uXnd7rpGs=
+github.com/dchest/uniuri v0.0.0-20200228104902-7aecb25e1fe5/go.mod h1:GgB8SF9nRG+GqaDtLcwJZsQFhcogVCJ79j4EdT0c2V4=
+github.com/go-chi/chi/v5 v5.0.7 h1:rDTPXLDHGATaeHvVlLcR4Qe0zftYethFucbjVQ1PxU8=
+github.com/go-chi/chi/v5 v5.0.7/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/securecookie v1.1.1 h1:miw7JPhV+b/lAHSXz4qd/nN9jRiAFV5FwjeKyCS8BvQ=
+github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
+github.com/lib/pq v1.10.6 h1:jbk+ZieJ0D7EVGJYpL9QTz7/YW6UHbmdnZWYyK5cdBs=
+github.com/lib/pq v1.10.6/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-sqlite3 v1.14.14 h1:qZgc/Rwetq+MtyE18WhzjokPD93dNqLGNT3QJuLvBGw=
+github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
+golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa h1:zuSxTR4o9y82ebqCUJYNGJbGPo6sKVl54f/TVDObg1c=
+golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

highlighter-wrapper.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env python
-
-try:
-    import pygments
-except ImportError:
-    print(" Please install python pygments module")
-
-from pygments import highlight
-from pygments.lexers import get_lexer_by_name, guess_lexer
-from pygments.formatters import HtmlFormatter
-import sys
-
-def render(code, lang, theme):
-
-    guess = ""
-    lang_org = lang
-
-    try:
-        lexer = get_lexer_by_name(lang)
-    except:
-        try:
-            guess = 1
-            lexer = guess_lexer(code)
-            lang  = lexer.aliases[0]
-        except:
-            if lang == "autodetect":
-                out = "Could not autodetect language (returning plain text).\n"
-            else:
-                out = "Given language was not found :: '"+lang+"' (returning plain text).\n"
-
-            lexer = get_lexer_by_name("text")
-            html_format = HtmlFormatter(style=theme, noclasses="true", linenos="true", encoding="utf-8")
-            return highlight(code, lexer, html_format),out
-
-    if guess:
-        out = "Lexer guessed :: "+lang
-        if lang != lang_org and lang_org != "autodetect":
-            out += " (although given language was "+lang_org+") "
-    else:
-        out = "Successfully used lexer for given language :: "+lang
-
-    try:
-        html_format = HtmlFormatter(style=theme, noclasses="true", linenos="true", encoding="utf-8")
-    except:
-        html_format = HtmlFormatter(noclasses="true", linenos="true", encoding="utf-8")
-
-    return highlight(code, lexer, html_format),out
-
-
-
-def usage(err=0):
-    print("\n Description, \n")
-    print("    - This is a small wrapper for the pygments html-formatter.")
-    print("      It will read data on stdin and simply print it on stdout")
-
-    print("\n Usage, \n")
-    print("    - %s [lang] [style] < FILE" % sys.argv[0])
-    print("    - %s getlexers" % sys.argv[0])
-    print("    - %s getstyles" % sys.argv[0])
-
-    print("\n Where, \n")
-    print("    - lang is the language of your code")
-    print("    - style is the 'theme' for the formatter")
-    print("    - getlexers will print available lexers (displayname;lexer-name)")
-    print("    - getstyles will print available styles \n")
-
-    sys.exit(err)
-
-def get_styles():
-    item = pygments.styles.get_all_styles()
-    for items in item:
-        print(items)
-    sys.exit(0)
-
-def get_lexers():
-    item = pygments.lexers.get_all_lexers()
-    for items in item:
-        print(items[0]+";"+items[1][0])
-    sys.exit(0)
-
-
-# " Main "
-
-code = ""
-
-if len(sys.argv) >= 2:
-  for arg in sys.argv:
-      if arg == '--help' or arg == '-h':
-          usage()
-      if arg == 'getlexers':
-          get_lexers()
-      if arg == 'getstyles':
-          get_styles()
-
-if len(sys.argv) == 3:
-    lang  = sys.argv[1]
-    theme = sys.argv[2]
-else:
-    usage(1);
-
-if not sys.stdin.isatty():
-    for line in sys.stdin:
-        code += line
-
-    out, stderr = render(code, lang, theme)
-    print(out)
-    sys.stderr.write(stderr)
-else:
-    print("err : No data on stdin.")
-    sys.exit(1)

lib/idgen/idgen.go

@@ -0,0 +1,286 @@
+package idgen
+
+import (
+	randc "crypto/rand"
+	"errors"
+	"fmt"
+	"math"
+	randm "math/rand"
+	"sync"
+	"time"
+)
+
+const DefaultABC = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"
+
+// Abc represents a shuffled alphabet used to generate the Ids and provides methods to
+// encode data.
+type Abc struct {
+	alphabet []rune
+}
+
+// Shortid type represents a short Id generator working with a given alphabet.
+type Shortid struct {
+	abc    Abc
+	worker uint
+	epoch  time.Time  // ids can be generated for 34 years since this date
+	ms     uint       // ms since epoch for the last id
+	count  uint       // request count within the same ms
+	mx     sync.Mutex // locks access to ms and count
+}
+
+var shortid *Shortid
+
+func init() {
+	shortid = MustNew(0, DefaultABC, 1)
+}
+
+func GetDefault() *Shortid {
+	return shortid
+}
+
+// SetDefault overwrites the default generator.
+// should not be used concurrently with generation
+func SetDefault(sid *Shortid) {
+	shortid = sid
+}
+
+// Generate generates an Id using the default generator.
+func Generate() (string, error) {
+	return shortid.Generate()
+}
+
+// MustGenerate acts just like Generate, but panics instead of returning errors.
+func MustGenerate() string {
+	id, err := Generate()
+	if err == nil {
+		return id
+	}
+	panic(err)
+}
+
+// New constructs an instance of the short Id generator for the given worker number [0,31], alphabet
+// (64 unique symbols) and seed value (to shuffle the alphabet). The worker number should be
+// different for multiple or distributed processes generating Ids into the same data space. The
+// seed, on contrary, should be identical.
+func New(worker uint8, alphabet string, seed uint64) (*Shortid, error) {
+	if worker > 31 {
+		return nil, errors.New("expected worker in the range [0,31]")
+	}
+	abc, err := NewAbc(alphabet, seed)
+	if err == nil {
+		sid := &Shortid{
+			abc:    abc,
+			worker: uint(worker),
+			epoch:  time.Date(2016, time.January, 1, 0, 0, 0, 0, time.UTC),
+			ms:     0,
+			count:  0,
+		}
+		return sid, nil
+	}
+	return nil, err
+}
+
+// MustNew acts just like New, but panics instead of returning errors.
+func MustNew(worker uint8, alphabet string, seed uint64) *Shortid {
+	sid, err := New(worker, alphabet, seed)
+	if err == nil {
+		return sid
+	}
+	panic(err)
+}
+
+// Generate generates a new short Id.
+func (sid *Shortid) Generate() (string, error) {
+	return sid.generateInternal(nil, sid.epoch)
+}
+
+// MustGenerate acts just like Generate, but panics instead of returning errors.
+func (sid *Shortid) MustGenerate() string {
+	id, err := sid.Generate()
+	if err == nil {
+		return id
+	}
+	panic(err)
+}
+
+func (sid *Shortid) generateInternal(tm *time.Time, epoch time.Time) (string, error) {
+	ms, count := sid.getMsAndCounter(tm, epoch)
+	idrunes := make([]rune, 9)
+	if tmp, err := sid.abc.Encode(ms, 8, 5); err == nil {
+		copy(idrunes, tmp) // first 8 symbols
+	} else {
+		return "", err
+	}
+	if tmp, err := sid.abc.Encode(sid.worker, 1, 5); err == nil {
+		idrunes[8] = tmp[0]
+	} else {
+		return "", err
+	}
+	if count > 0 {
+		if countrunes, err := sid.abc.Encode(count, 0, 6); err == nil {
+			// only extend if really need it
+			idrunes = append(idrunes, countrunes...)
+		} else {
+			return "", err
+		}
+	}
+	return string(idrunes), nil
+}
+
+func (sid *Shortid) getMsAndCounter(tm *time.Time, epoch time.Time) (uint, uint) {
+	sid.mx.Lock()
+	defer sid.mx.Unlock()
+	var ms uint
+	if tm != nil {
+		ms = uint(tm.Sub(epoch).Nanoseconds() / 1000000)
+	} else {
+		ms = uint(time.Now().Sub(epoch).Nanoseconds() / 1000000)
+	}
+	if ms == sid.ms {
+		sid.count++
+	} else {
+		sid.count = 0
+		sid.ms = ms
+	}
+	return sid.ms, sid.count
+}
+
+// String returns a string representation of the short Id generator.
+func (sid *Shortid) String() string {
+	return fmt.Sprintf("Shortid(worker=%v, epoch=%v, abc=%v)", sid.worker, sid.epoch, sid.abc)
+}
+
+// Abc returns the instance of alphabet used for representing the Ids.
+func (sid *Shortid) Abc() Abc {
+	return sid.abc
+}
+
+// Epoch returns the value of epoch used as the beginning of millisecond counting (normally
+// 2016-01-01 00:00:00 local time)
+func (sid *Shortid) Epoch() time.Time {
+	return sid.epoch
+}
+
+// Worker returns the value of worker for this short Id generator.
+func (sid *Shortid) Worker() uint {
+	return sid.worker
+}
+
+// NewAbc constructs a new instance of shuffled alphabet to be used for Id representation.
+func NewAbc(alphabet string, seed uint64) (Abc, error) {
+	runes := []rune(alphabet)
+	if len(runes) != len(DefaultABC) {
+		return Abc{}, fmt.Errorf("alphabet must contain %v unique characters", len(DefaultABC))
+	}
+	if nonUnique(runes) {
+		return Abc{}, errors.New("alphabet must contain unique characters only")
+	}
+	abc := Abc{alphabet: nil}
+	abc.shuffle(alphabet, seed)
+	return abc, nil
+}
+
+// MustNewAbc acts just like NewAbc, but panics instead of returning errors.
+func MustNewAbc(alphabet string, seed uint64) Abc {
+	res, err := NewAbc(alphabet, seed)
+	if err == nil {
+		return res
+	}
+	panic(err)
+}
+
+func nonUnique(runes []rune) bool {
+	found := make(map[rune]struct{})
+	for _, r := range runes {
+		if _, seen := found[r]; !seen {
+			found[r] = struct{}{}
+		}
+	}
+	return len(found) < len(runes)
+}
+
+func (abc *Abc) shuffle(alphabet string, seed uint64) {
+	source := []rune(alphabet)
+	for len(source) > 1 {
+		seed = (seed*9301 + 49297) % 233280
+		i := int(seed * uint64(len(source)) / 233280)
+
+		abc.alphabet = append(abc.alphabet, source[i])
+		source = append(source[:i], source[i+1:]...)
+	}
+	abc.alphabet = append(abc.alphabet, source[0])
+}
+
+// Encode encodes a given value into a slice of runes of length nsymbols. In case nsymbols==0, the
+// length of the result is automatically computed from data. Even if fewer symbols is required to
+// encode the data than nsymbols, all positions are used encoding 0 where required to guarantee
+// uniqueness in case further data is added to the sequence. The value of digits [4,6] represents
+// represents n in 2^n, which defines how much randomness flows into the algorithm: 4 -- every value
+// can be represented by 4 symbols in the alphabet (permitting at most 16 values), 5 -- every value
+// can be represented by 2 symbols in the alphabet (permitting at most 32 values), 6 -- every value
+// is represented by exactly 1 symbol with no randomness (permitting 64 values).
+func (abc *Abc) Encode(val, nsymbols, digits uint) ([]rune, error) {
+	if digits < 4 || 6 < digits {
+		return nil, fmt.Errorf("allowed digits range [4,6], found %v", digits)
+	}
+
+	var computedSize uint = 1
+	if val >= 1 {
+		computedSize = uint(math.Log2(float64(val)))/digits + 1
+	}
+	if nsymbols == 0 {
+		nsymbols = computedSize
+	} else if nsymbols < computedSize {
+		return nil, fmt.Errorf("cannot accommodate data, need %v digits, got %v", computedSize, nsymbols)
+	}
+
+	mask := 1<<digits - 1
+
+	random := make([]int, int(nsymbols))
+	// no random component if digits == 6
+	if digits < 6 {
+		copy(random, maskedRandomInts(len(random), 0x3f-mask))
+	}
+
+	res := make([]rune, int(nsymbols))
+	for i := range res {
+		shift := digits * uint(i)
+		index := (int(val>>shift) & mask) | random[i]
+		res[i] = abc.alphabet[index]
+	}
+	return res, nil
+}
+
+// MustEncode acts just like Encode, but panics instead of returning errors.
+func (abc *Abc) MustEncode(val, size, digits uint) []rune {
+	res, err := abc.Encode(val, size, digits)
+	if err == nil {
+		return res
+	}
+	panic(err)
+}
+
+func maskedRandomInts(size, mask int) []int {
+	ints := make([]int, size)
+	bytes := make([]byte, size)
+	if _, err := randc.Read(bytes); err == nil {
+		for i, b := range bytes {
+			ints[i] = int(b) & mask
+		}
+	} else {
+		for i := range ints {
+			ints[i] = randm.Intn(0xff) & mask
+		}
+	}
+	return ints
+}
+
+// String returns a string representation of the Abc instance.
+func (abc Abc) String() string {
+	return fmt.Sprintf("Abc{alphabet='%v')", abc.Alphabet())
+}
+
+// Alphabet returns the alphabet used as an immutable string.
+func (abc Abc) Alphabet() string {
+	return string(abc.alphabet)
+}

lib/store/sqlike/sqlike.go

@@ -0,0 +1,328 @@
+package sqlike
+
+import (
+	"context"
+	"crypto/sha1"
+	"database/sql"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"html"
+	"strconv"
+	"time"
+
+	"git.tuxpa.in/a/nat/lib/idgen"
+	"git.tuxpa.in/a/nat/lib/store"
+	"github.com/dchest/uniuri"
+	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/lib/pq"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+type SqlikeConfig struct {
+	DBHost          string    `json:"dbhost"`     // Name of your database host
+	DBName          string    `json:"dbname"`     // Name of your database
+	DBPassword      string    `json:"dbpassword"` // The password for the database user
+	DBPlaceHolder   [7]string // ? / $[i] Depending on db driver.
+	DBPort          string    `json:"dbport"`          // Port of the database
+	DBTable         string    `json:"dbtable"`         // Name of the table in the database
+	DBAccountsTable string    `json:"dbaccountstable"` // Name of the table in the database
+	DBType          string    `json:"dbtype"`          // Type of database
+	DBUser          string    `json:"dbuser"`          // The database user
+	DisplayName     string    `json:"displayname"`     // Name of your pastebin
+}
+
+var _ store.Store = (*Sqlike)(nil)
+
+type Sqlike struct {
+	config SqlikeConfig
+	handle *sql.DB
+}
+
+func MustNew(config ...SqlikeConfig) *Sqlike {
+	o, err := New(config...)
+	if err != nil {
+		panic(err)
+	}
+	return o
+}
+
+func New(config ...SqlikeConfig) (*Sqlike, error) {
+	s := &Sqlike{}
+	// default settings
+	s.config.DBType = "sqlite3"
+	s.config.DBHost = "db.sqlite"
+	s.config.DBName = "pastebin"
+	s.config.DBAccountsTable = "accounts"
+	if len(config) > 0 {
+		s.config = config[0]
+	}
+	if err := s.connect(); err != nil {
+		return nil, err
+	}
+	return s, nil
+}
+
+func (s *Sqlike) connect() error {
+	var dbinfo string
+	for i := 0; i < 7; i++ {
+		s.config.DBPlaceHolder[i] = "?"
+	}
+
+	switch s.config.DBType {
+	case "sqlite3":
+		dbinfo = s.config.DBName
+	case "postgres":
+		dbinfo = fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
+			s.config.DBHost,
+			s.config.DBPort,
+			s.config.DBUser,
+			s.config.DBPassword,
+			s.config.DBName)
+		for i := 0; i < 7; i++ {
+			s.config.DBPlaceHolder[i] = "$" + strconv.Itoa(i+1)
+		}
+	case "mysql":
+		dbinfo = s.config.DBUser + ":" + s.config.DBPassword + "@tcp(" + s.config.DBHost + ":" + s.config.DBPort + ")/" + s.config.DBName
+	case "":
+		return errors.New("   Database error : dbtype not specified in sqlike config")
+
+	default:
+		return errors.New("   Database error : Specified dbtype (" +
+			s.config.DBType + ") not supported.")
+	}
+
+	db, err := sql.Open(s.config.DBType, dbinfo)
+	if err != nil {
+		return err
+	}
+
+	var dummy string
+	err = db.QueryRow("select id from " + s.config.DBTable + " where id='dummyid'").Scan(&dummy)
+
+	switch {
+	case err == sql.ErrNoRows:
+	case err != nil:
+		return err
+	}
+	s.handle = db
+	return nil
+}
+
+func shaPaste(paste string) string {
+	hasher := sha1.New()
+	hasher.Write([]byte(paste))
+	sha := base64.URLEncoding.EncodeToString(hasher.Sum(nil))
+	return sha
+}
+
+func (s *Sqlike) SavePaste(ctx context.Context, title string, data string, expiry time.Duration, userKey string) (*store.Response, error) {
+	var id, hash, delkey string
+
+	// Escape user input,
+	data = html.EscapeString(data)
+	title = html.EscapeString(title)
+	userKey = html.EscapeString(userKey)
+
+	// Hash paste data and query database to see if paste exists
+	sha := shaPaste(data)
+
+	err := s.handle.QueryRow("select id, title, hash, data, delkey from "+
+		s.config.DBTable+" where hash="+
+		s.config.DBPlaceHolder[0], sha).Scan(&id,
+		&title, &hash, &data, &delkey)
+	switch {
+	case err == sql.ErrNoRows:
+	case err != nil:
+		return nil, err
+	default:
+		return &store.Response{
+			Status: "Paste data already exists ...",
+			Id:     id,
+			Title:  title,
+			Sha1:   hash,
+			Size:   len(data)}, nil
+	}
+
+	// Generate id,
+	id = idgen.MustGenerate()
+
+	expiretime := time.Now().Add(expiry)
+	// Set the generated id as title if not given,
+	if title == "" {
+		title = id
+	}
+
+	delKey := uniuri.NewLen(40)
+
+	// This is needed since mysql/postgres uses different placeholders,
+	var dbQuery string
+	for i := 0; i < 7; i++ {
+		dbQuery += s.config.DBPlaceHolder[i] + ","
+	}
+	dbQuery = dbQuery[:len(dbQuery)-1]
+
+	stmt, err := s.handle.Prepare("INSERT INTO " + s.config.DBTable + " (id,title,hash,data,delkey,expiry,userid)values(" + dbQuery + ")")
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = stmt.Exec(id, title, sha, data, delKey, expiretime, userKey)
+	if err != nil {
+		return nil, err
+	}
+	stmt.Close()
+	if err != nil {
+		return nil, err
+	}
+	return &store.Response{
+		Status: "Successfully saved paste.",
+		Id:     id,
+		Title:  title,
+		Sha1:   hash,
+		Size:   len(data),
+		DelKey: delKey}, nil
+}
+
+func (s *Sqlike) GetUserPastes(ctx context.Context, userKey string) (*store.Pastes, error) {
+	pst := &store.Pastes{}
+	rows, err := s.handle.Query("select id, title, delkey, data from "+
+		s.config.DBTable+" where userid="+
+		s.config.DBPlaceHolder[0], userKey)
+	switch {
+	case err == sql.ErrNoRows:
+	case err != nil:
+		return nil, err
+	default:
+		defer rows.Close()
+		for rows.Next() {
+			var id, title, delKey, data string
+			rows.Scan(&id, &title, &delKey, &data)
+			res := store.Response{
+				Id:     id,
+				Title:  title,
+				Size:   len(data),
+				DelKey: delKey}
+			pst.Response = append(pst.Response, res)
+		}
+	}
+	return pst, nil
+}
+func (s *Sqlike) GetUserKey(ctx context.Context, email string) (string, error) {
+	var user_key string
+	err := s.handle.QueryRowContext(ctx, "select key from "+s.config.DBAccountsTable+
+		" where email="+s.config.DBPlaceHolder[0], email).
+		Scan(&user_key)
+	if err != nil {
+		return "", err
+	}
+	return user_key, nil
+}
+
+func (s *Sqlike) GetPaste(ctx context.Context, pasteId string) (*store.Response, error) {
+	var title, paste string
+	var expiry int64
+	err := s.handle.QueryRowContext(ctx, "select title, data, expiry from "+
+		s.config.DBTable+" where id="+s.config.DBPlaceHolder[0],
+		pasteId).Scan(&title, &paste, &expiry)
+
+	switch {
+	case err == sql.ErrNoRows:
+		return &store.Response{Status: "Requested paste doesn't exist."}, nil
+	case err != nil:
+		return nil, err
+	}
+	expiretime := time.Unix(expiry, 0)
+	if expiry == 0 {
+		expiretime = time.Time{}
+	}
+	// Check if paste is overdue,
+	ok := time.Now().After(expiretime)
+	if err != nil || !ok {
+		return &store.Response{Status: "Requested paste doesn't exist."}, nil
+	}
+
+	// Unescape the saved data,
+	paste = html.UnescapeString(paste)
+	title = html.UnescapeString(title)
+
+	expiryS := "Never"
+	if expiry != 0 {
+		expiryS = time.Unix(expiry, 0).Format("2006-01-02 15:04:05")
+	}
+
+	r := &store.Response{
+		Status: "Success",
+		Id:     pasteId,
+		Title:  title,
+		Paste:  paste,
+		Size:   len(paste),
+		Expiry: expiryS}
+
+	return r, nil
+}
+
+func (s *Sqlike) ForceDelPaste(ctx context.Context, pasteId string) error {
+	stmt, err := s.handle.PrepareContext(ctx, "delete from pastebin where id="+
+		s.config.DBPlaceHolder[0])
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+	// Execute it,
+	_, err = stmt.ExecContext(ctx, pasteId)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+func (s *Sqlike) RegisterUser(ctx context.Context, email string, hashpass []byte) error {
+	var dbQuery string
+	for i := 0; i < 3; i++ {
+		dbQuery += s.config.DBPlaceHolder[i] + ","
+	}
+	dbQuery = dbQuery[:len(dbQuery)-1]
+	stmt, err := s.handle.PrepareContext(ctx, "INSERT into "+s.config.DBAccountsTable+"(email, password, key) values("+dbQuery+")")
+	defer stmt.Close()
+	if err != nil {
+		return err
+	}
+	key := idgen.MustGenerate()
+	_, err = stmt.ExecContext(ctx, email, hashpass, key)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+func (s *Sqlike) DelPaste(ctx context.Context, pasteId, delKey string) error {
+	stmt, err := s.handle.PrepareContext(ctx, "delete from pastebin where delkey="+
+		s.config.DBPlaceHolder[0]+" and id="+
+		s.config.DBPlaceHolder[1])
+	if err != nil {
+		return err
+	}
+	defer stmt.Close()
+	res, err := stmt.ExecContext(ctx, delKey, pasteId)
+	_, err = res.RowsAffected()
+	if err == sql.ErrNoRows {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *Sqlike) HasAccount(ctx context.Context, email string) ([]byte, error) {
+	var hashedPassword []byte
+	err := s.handle.QueryRowContext(ctx, "select password from "+s.config.DBAccountsTable+
+		" where email="+s.config.DBPlaceHolder[0], email).
+		Scan(&hashedPassword)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return hashedPassword, nil
+}

lib/store/store.go

@@ -0,0 +1,39 @@
+package store
+
+import (
+	"context"
+	"time"
+)
+
+// A request to the store will be this json struct.
+type Response struct {
+	DelKey string `json:"delkey"` // The id to use when delete a paste
+	Expiry string `json:"expiry"` // The date when post expires
+	Extra  string `json:"extra"`  // Extra output from the highlight-wrapper
+	Id     string `json:"id"`     // The id of the paste
+	Lang   string `json:"lang"`   // Specified language
+	Paste  string `json:"paste"`  // The eactual paste data
+	Sha1   string `json:"sha1"`   // The sha1 of the paste
+	Size   int    `json:"size"`   // The length of the paste
+	Status string `json:"status"` // A custom status message
+	Style  string `json:"style"`  // Specified style
+	Title  string `json:"title"`  // The title of the paste
+}
+
+type Pastes struct {
+	Response []Response
+}
+
+type Store interface {
+	GetUserKey(ctx context.Context, email string) (string, error)
+	GetUserPastes(ctx context.Context, userKey string) (*Pastes, error)
+	GetPaste(ctx context.Context, pasteId string) (*Response, error)
+
+	SavePaste(ctx context.Context, title string, data string, expiry time.Duration, userKey string) (*Response, error)
+
+	ForceDelPaste(ctx context.Context, pasteId string) error
+	DelPaste(ctx context.Context, pasteId, delKey string) error
+
+	HasAccount(ctx context.Context, email string) ([]byte, error)
+	RegisterUser(ctx context.Context, email string, hashpass []byte) error
+}

lib/styler/styler.go

@@ -0,0 +1,218 @@
+package styler
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"unicode/utf8"
+)
+
+type Highlighter string
+
+const (
+	HIGHLIGHTER_NONE   Highlighter = "none"
+	HIGHLIGHTER_PYTHON Highlighter = "python"
+	HIGHLIGHTER_GO     Highlighter = "go"
+)
+
+func (h Highlighter) Cmd() string {
+	switch h {
+	case HIGHLIGHTER_PYTHON:
+		return ".highlighers/highlighter-wrapper.py"
+	case HIGHLIGHTER_GO:
+		return ".highlighers/highligher.gobin"
+	case HIGHLIGHTER_NONE:
+		fallthrough
+	default:
+		return ""
+	}
+}
+
+type Styler struct {
+	listOfLangsFirst map[string]string
+	listOfLangsLast  map[string]string
+	listOfStyles     map[string]string
+
+	config StylerConfig
+}
+
+func (s *Styler) Legacy() [3]map[string]string {
+	return [3]map[string]string{
+		s.listOfLangsFirst,
+		s.listOfLangsLast,
+		s.listOfStyles,
+	}
+}
+
+type StylerConfig struct {
+	Highlighter Highlighter `json:"highlighter"` // The name of the highlighter.
+}
+
+func New(config ...StylerConfig) *Styler {
+	s := &Styler{
+		listOfLangsFirst: make(map[string]string),
+		listOfLangsLast:  make(map[string]string),
+		listOfStyles:     make(map[string]string),
+	}
+	// default settings
+	s.config.Highlighter = "none"
+	if len(config) > 0 {
+		s.config = config[0]
+	}
+	return s
+}
+func isBad(s string) bool {
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if ('a' <= b && b <= 'z') ||
+			('A' <= b && b <= 'Z') ||
+			('0' <= b && b <= '9') ||
+			b == ' ' {
+			continue
+		} else {
+			return false
+		}
+	}
+	return true
+}
+
+func sanitize(s string) string {
+	if !utf8.ValidString(s) {
+		return s
+	}
+	if len(s) < 30 {
+		return s
+	}
+	if !isBad(s) {
+		return s
+	}
+	return ""
+}
+
+func (s *Styler) Highlight(paste string, lang string, style string) (string, string, string, string, error) {
+	var supported_lang, supported_styles bool
+	lang = sanitize(lang)
+	style = sanitize(style)
+	lang, supported_lang = s.listOfLangsFirst[lang]
+	style, supported_styles = s.listOfStyles[style]
+	lang = sanitize(lang)
+	style = sanitize(style)
+
+	if lang == "" {
+		lang = "autodetect"
+	}
+
+	if !supported_lang && lang != "autodetect" {
+		lang = "text"
+	}
+
+	// Same with the styles,
+	if !supported_styles {
+		style = "autodetect"
+	}
+	switch s.config.Highlighter {
+	case HIGHLIGHTER_PYTHON:
+		if _, err := os.Stat(s.config.Highlighter.Cmd()); os.IsNotExist(err) {
+			return "", "", "", "", err
+		}
+		cmd := exec.Command(s.config.Highlighter.Cmd(), lang, style)
+		cmd.Stdin = strings.NewReader(paste)
+
+		var stdout bytes.Buffer
+		cmd.Stdout = &stdout
+
+		var stderr bytes.Buffer
+		cmd.Stderr = &stderr
+		err := cmd.Run()
+		if err != nil {
+			return "", "", "", "", err
+		}
+		return stdout.String(), stderr.String(), lang, style, nil
+	case "none":
+		fallthrough
+	default:
+		return paste, "", lang, style, nil
+	}
+}
+
+func (s *Styler) loadSupportedStyles() {
+	switch s.config.Highlighter {
+	case HIGHLIGHTER_PYTHON:
+		arg := "getstyles"
+		out, err := exec.Command(s.config.Highlighter.Cmd(), arg).Output()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// Loop lexers and add them to respectively map,
+		for _, line := range strings.Split(string(out), "\n") {
+			if line == "" {
+				continue
+			}
+			s.listOfStyles[line] = strings.Title(line)
+		}
+	case "none":
+		fallthrough
+	default:
+		return
+	}
+}
+
+func (st *Styler) loadSupportedLangs() error {
+	switch st.config.Highlighter {
+	case HIGHLIGHTER_PYTHON:
+		var prioLexers map[string]string
+
+		// Initialize maps,
+		prioLexers = make(map[string]string)
+
+		// Get prioritized lexers and put them in a separate map,
+		file, err := os.Open("static/prio-lexers")
+		if err != nil {
+			return err
+		}
+
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			prioLexers[scanner.Text()] = "1"
+		}
+
+		if err := scanner.Err(); err != nil {
+			log.Fatal(err)
+		}
+		file.Close()
+
+		arg := "getlexers"
+		out, err := exec.Command(st.config.Highlighter.Cmd(), arg).Output()
+		if err != nil {
+			return fmt.Errorf("%w: %s", err, string(out))
+		}
+
+		// Loop lexers and add them to respectively map,
+		for _, line := range strings.Split(string(out), "\n") {
+			if line == "" {
+				continue
+			}
+
+			s := strings.Split(line, ";")
+			if len(s) != 2 {
+				os.Exit(1)
+			}
+			s[0] = strings.Title(s[0])
+			if prioLexers[s[0]] == "1" {
+				st.listOfLangsFirst[s[0]] = s[1]
+			} else {
+				st.listOfLangsLast[s[0]] = s[1]
+			}
+		}
+		return nil
+	case "none":
+		fallthrough
+	default:
+		return nil
+	}
+}