471 lines
14 KiB
Go
471 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/julienschmidt/httprouter"
|
|
)
|
|
|
|
const (
|
|
AssociatedDomainSuffix = "adlin2020.p0m.fr"
|
|
DelegatedDomainSuffix = "srs.p0m.fr"
|
|
)
|
|
|
|
func init() {
|
|
router.GET("/api/adomains/", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.GetAssociatedDomains(), nil
|
|
}))
|
|
router.POST("/api/adomains/", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return true, student.AddAssociatedDomains()
|
|
}))
|
|
router.GET("/api/adomains/:dn", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.GetAssociatedDomain(ps.ByName("dn"))
|
|
}))
|
|
|
|
router.GET("/api/ddomains/", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return []string{student.MyDelegatedDomain()}, nil
|
|
}))
|
|
router.GET("/api/ddomains/:dn/", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.getRRDelegatedDomain(ps.ByName("dn"), "")
|
|
}))
|
|
router.GET("/api/ddomains/:dn/NS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.getRRDelegatedDomain(ps.ByName("dn"), "NS")
|
|
}))
|
|
router.POST("/api/ddomains/:dn/NS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.AddNSDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.Values[0])
|
|
}))
|
|
router.PATCH("/api/ddomains/:dn/NS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.UpdateNSDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.ValuesFrom[0], ue.Values[0])
|
|
}))
|
|
router.DELETE("/api/ddomains/:dn/NS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.DeleteRRDelegatedDomain(ps.ByName("dn"), "NS", ue.Values...)
|
|
}))
|
|
router.GET("/api/ddomains/:dn/GLUE", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.getRRDelegatedDomain(ps.ByName("dn"), "AAAA")
|
|
}))
|
|
router.POST("/api/ddomains/:dn/AAAA", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.AddGLUEDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.Values[0])
|
|
}))
|
|
router.PATCH("/api/ddomains/:dn/AAAA", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.UpdateGLUEDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.ValuesFrom[0], ue.Values[0])
|
|
}))
|
|
router.POST("/api/ddomains/:dn/GLUE", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.UpdateGLUEDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.ValuesFrom[0], ue.Values[0])
|
|
}))
|
|
router.DELETE("/api/ddomains/:dn/AAAA", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.DeleteRRDelegatedDomain(ps.ByName("dn"), "AAAA", ue.Values...)
|
|
}))
|
|
router.GET("/api/ddomains/:dn/DS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
return student.getRRDelegatedDomain(ps.ByName("dn"), "DS")
|
|
}))
|
|
router.POST("/api/ddomains/:dn/DS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.AddDSDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.Values)
|
|
}))
|
|
router.PATCH("/api/ddomains/:dn/DS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.UpdateDSDelegatedDomain(ps.ByName("dn"), ue.TTL, ue.ValuesFrom, ue.Values)
|
|
}))
|
|
router.DELETE("/api/ddomains/:dn/DS", apiAuthHandler(func (student Student, ps httprouter.Params, body []byte) (interface{}, error) {
|
|
var ue Entry
|
|
if err := json.Unmarshal(body, &ue); err != nil {
|
|
return nil, err
|
|
}
|
|
return true, student.DeleteRRDelegatedDomain(ps.ByName("dn"), "DS", ue.Values...)
|
|
}))
|
|
}
|
|
|
|
type Entry struct {
|
|
Domain string `json:"domain"`
|
|
TTL uint64 `json:"ttl"`
|
|
RR string `json:"rr"`
|
|
ValuesFrom []string `json:"valuesfrom,omitempty"`
|
|
Values []string `json:"values"`
|
|
}
|
|
|
|
func runKnotc(args ...string) (out []byte, err error) {
|
|
cmd := exec.Command("knotc", args...)
|
|
cmd.Env = append(os.Environ(),
|
|
"LD_PRELOAD=/usr/lib/gcc/armv5tel-softfloat-linux-gnueabi/8.2.0/libgcc_s.so.1",
|
|
)
|
|
|
|
return cmd.CombinedOutput()
|
|
}
|
|
|
|
func parseKnotZoneRead(args ...string) (rr []Entry, err error) {
|
|
var out []byte
|
|
args = append([]string{"zone-read"}, args...)
|
|
out, err = runKnotc(args...)
|
|
|
|
for _, line := range strings.Split(string(out), "\n") {
|
|
cols := strings.Fields(line)
|
|
if len(cols) >= 5 {
|
|
var ttl uint64
|
|
ttl, err = strconv.ParseUint(cols[2], 10, 64)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
rr = append(rr, Entry{cols[1], ttl, cols[3], nil, cols[4:]})
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) myAssociatedDomain() (string) {
|
|
return fmt.Sprintf("%s.%s.", strings.Trim(strings.Replace(student.Login, "_", "-", -1), "-_"), AssociatedDomainSuffix)
|
|
}
|
|
|
|
func (student Student) GetAssociatedDomains() (ds []string) {
|
|
studentDomain := student.myAssociatedDomain()
|
|
|
|
if _, err := parseKnotZoneRead(AssociatedDomainSuffix, studentDomain); err == nil {
|
|
ds = append(ds, studentDomain)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) GetAssociatedDomain(dn string) (rrs []Entry, err error) {
|
|
domains := student.GetAssociatedDomains()
|
|
found := false
|
|
for _, d := range domains {
|
|
if d == dn {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
err = errors.New(fmt.Sprintf("Unable to find domain %q.", dn))
|
|
}
|
|
|
|
if entries, errr := parseKnotZoneRead(AssociatedDomainSuffix, dn); err != nil {
|
|
return nil, errr
|
|
} else {
|
|
for _, e := range entries {
|
|
if e.RR != "RRSIG" && e.RR != "NSEC" && e.RR != "NSEC3" {
|
|
rrs = append(rrs, e)
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) AddAssociatedDomains() (err error) {
|
|
for _, d := range []string{student.myAssociatedDomain()} {
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", AssociatedDomainSuffix},
|
|
[]string{"zone-set", AssociatedDomainSuffix, d, "900", "A", "82.64.31.248"},
|
|
[]string{"zone-set", AssociatedDomainSuffix, d, "900", "AAAA", studentIP(student.Id) + "1"},
|
|
[]string{"zone-commit", AssociatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", AssociatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
|
|
func (student Student) MyDelegatedDomain() (string) {
|
|
return fmt.Sprintf("%s.%s.", strings.Trim(strings.Replace(student.Login, "_", "-", -1), "-_"), DelegatedDomainSuffix)
|
|
}
|
|
|
|
func (student Student) getRRDelegatedDomain(dn string, rr string) (rrs []Entry, err error) {
|
|
domains := []string{student.MyDelegatedDomain()}
|
|
found := false
|
|
for _, d := range domains {
|
|
if d == dn {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
err = errors.New(fmt.Sprintf("Unable to find domain %q.", dn))
|
|
}
|
|
|
|
if entries, errr := parseKnotZoneRead(DelegatedDomainSuffix); err != nil {
|
|
return nil, errr
|
|
} else {
|
|
for _, e := range entries {
|
|
if e.RR == rr && strings.HasSuffix(strings.TrimSuffix(e.Domain, "."), strings.TrimSuffix(dn, ".")) {
|
|
rrs = append(rrs, e)
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) AddNSDelegatedDomain(dn string, ttl uint64, ns string) (err error) {
|
|
for _, d := range []string{student.MyDelegatedDomain()} {
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-set", DelegatedDomainSuffix, d, fmt.Sprintf("%d", ttl), "NS", ns},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) UpdateNSDelegatedDomain(dn string, ttl uint64, oldns string, ns string) (err error) {
|
|
for _, d := range []string{student.MyDelegatedDomain()} {
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-unset", DelegatedDomainSuffix, d, "NS", oldns},
|
|
[]string{"zone-set", DelegatedDomainSuffix, d, fmt.Sprintf("%d", ttl), "NS", ns},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
|
|
func (student Student) AddGLUEDelegatedDomain(dn string, ttl uint64, aaaa string) (err error) {
|
|
domains := []string{student.MyDelegatedDomain()}
|
|
found := false
|
|
for _, d := range domains {
|
|
if strings.HasSuffix(dn, d) {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
err = errors.New(fmt.Sprintf("Unable to find domain %q in your whitelist.", dn))
|
|
return
|
|
}
|
|
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-set", DelegatedDomainSuffix, dn, fmt.Sprintf("%d", ttl), "AAAA", aaaa},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) UpdateGLUEDelegatedDomain(dn string, ttl uint64, oldaaaa string, aaaa string) (err error) {
|
|
domains := []string{student.MyDelegatedDomain()}
|
|
found := false
|
|
for _, d := range domains {
|
|
if strings.HasSuffix(dn, d) {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
err = errors.New(fmt.Sprintf("Unable to find domain %q in your whitelist.", dn))
|
|
return
|
|
}
|
|
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-unset", DelegatedDomainSuffix, student.MyDelegatedDomain(), "AAAA", oldaaaa},
|
|
[]string{"zone-unset", DelegatedDomainSuffix, dn, "AAAA", oldaaaa},
|
|
[]string{"zone-set", DelegatedDomainSuffix, dn, fmt.Sprintf("%d", ttl), "AAAA", aaaa},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
|
|
func (student Student) AddDSDelegatedDomain(dn string, ttl uint64, dnskey []string) (err error) {
|
|
if len(dnskey) != 4 {
|
|
return errors.New("Wrong number of value for this record")
|
|
}
|
|
|
|
dshash := sha256.New()
|
|
dshash.Write([]byte("nemunai.re"))
|
|
|
|
var flag uint64
|
|
if flag, err = strconv.ParseUint(dnskey[1], 10, 16); err != nil {
|
|
return
|
|
}
|
|
binary.Write(dshash, binary.BigEndian, flag)
|
|
|
|
var proto uint8 = 3
|
|
dshash.Write([]byte{proto})
|
|
|
|
var alg uint64
|
|
if alg, err = strconv.ParseUint(dnskey[2], 10, 8); err != nil {
|
|
return
|
|
}
|
|
dshash.Write([]byte{uint8(alg)})
|
|
|
|
var pubkey []byte
|
|
if pubkey, err = base64.StdEncoding.DecodeString(strings.Replace(dnskey[3], " ", "", -1)); err != nil {
|
|
return
|
|
}
|
|
dshash.Write(pubkey)
|
|
|
|
for _, d := range []string{student.MyDelegatedDomain()} {
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-set", DelegatedDomainSuffix, d, fmt.Sprintf("%d", ttl), "DS", dnskey[0], dnskey[2], hex.EncodeToString(dshash.Sum(nil))},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (student Student) UpdateDSDelegatedDomain(dn string, ttl uint64, oldds []string, ds []string) (err error) {
|
|
for _, d := range []string{student.MyDelegatedDomain()} {
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
[]string{"zone-unset", DelegatedDomainSuffix, d, "DS", strings.Join(oldds, " ")},
|
|
[]string{"zone-set", DelegatedDomainSuffix, d, fmt.Sprintf("%d", ttl), "DS", strings.Join(ds, " ")},
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil && cmd[0] != "zone-unset" {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
|
|
func (student Student) DeleteRRDelegatedDomain(dn string, rr string, values ...string) (err error) {
|
|
domains := []string{student.MyDelegatedDomain()}
|
|
found := false
|
|
for _, d := range domains {
|
|
if strings.HasSuffix(dn, d) {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
err = errors.New(fmt.Sprintf("Unable to find domain %q in your whitelist.", dn))
|
|
return
|
|
}
|
|
|
|
zu := []string{"zone-unset", DelegatedDomainSuffix, dn, rr}
|
|
zu = append(zu, values...)
|
|
|
|
for _, cmd := range [][]string{
|
|
[]string{"zone-begin", DelegatedDomainSuffix},
|
|
zu,
|
|
[]string{"zone-commit", DelegatedDomainSuffix},
|
|
} {
|
|
var out []byte
|
|
out, err = runKnotc(cmd...)
|
|
if err != nil {
|
|
log.Printf("An error occurs on command '%s': %s", strings.Join(cmd, " "), err.Error())
|
|
err = errors.New(string(out))
|
|
runKnotc("zone-abort", DelegatedDomainSuffix)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|