aisk/browsercookies

package browsercookies

import (
    "database/sql"
    "errors"
    "io"
    "io/ioutil"
    "net/http"
    "net/http/cookiejar"
    "net/url"
    "os"
    "path/filepath"
    "runtime"
    "time"

    "github.com/go-ini/ini"
    _ "github.com/mattn/go-sqlite3"
    "github.com/mitchellh/go-homedir"
    "golang.org/x/net/publicsuffix"
)

// FireFox is the cookie jar which loads all your cookies in FireFox.
type FireFox struct {
    http.CookieJar
}

func (ff *FireFox) parseProfile(profile string) (string, error) {
    cfg, err := ini.Load(profile)
    if err != nil {
        return "", err
    }
    // TODO: return first profile when no default default profile set.
    for _, section := range cfg.Sections() {
        if section.Key("Default").String() != "1" {
            continue
        }
        path := section.Key("Path").String()
        if section.Key("IsRelative").String() == "1" {
            path = filepath.Join(filepath.Dir(profile), path)
        }
        return path, nil
    }

    return "", errors.New("No default Firefox profile found")
}

func (ff *FireFox) findDefaultProfile() (string, error) {
    homedir, err := homedir.Dir()
    if err != nil {
        return "", err
    }
    switch runtime.GOOS {
    case "darwin":
        return filepath.Join(homedir, filepath.FromSlash("Library/Application Support/Firefox/profiles.ini")), nil
    case "linux":
        return filepath.Join(homedir, filepath.FromSlash(".mozilla/firefox/profiles.ini")), nil
    case "win32":
        return filepath.Join(os.Getenv("APPDATA"), filepath.FromSlash("Mozilla/Firefox/profiles.ini")), nil
    }
    return "", errors.New("Unsupported operating system: " + runtime.GOOS)
}

func (ff *FireFox) findCookieFiles() (string, error) {
    profile, err := ff.findDefaultProfile()
    if err != nil {
        return "", nil
    }
    profile, err = ff.parseProfile(profile)
    if err != nil {
        return "", nil
    }
    return filepath.Join(profile, "cookies.sqlite"), nil
}

func (ff *FireFox) getCookiesFromFile(file string) ([]*http.Cookie, error) {
    tempfile, err := ioutil.TempFile("", "go-webcookies")
    if err != nil {
        return nil, err
    }
    defer os.Remove(tempfile.Name())
    origin, err := os.Open(file)
    if err != nil {
        return nil, err
    }
    if _, err := io.Copy(tempfile, origin); err != nil {
        return nil, err
    }
    tempfile.Close()

    db, err := sql.Open("sqlite3", tempfile.Name())
    if err != nil {
        return nil, err
    }
    defer db.Close()

    rows, err := db.Query("SELECT host, path, isSecure, expiry, name, value FROM moz_cookies")
    if err != nil {
        return nil, err
    }
    cookies := []*http.Cookie{}
    for rows.Next() {
        var host, path, name, value string
        var secure, expiry int
        if err := rows.Scan(&host, &path, &secure, &expiry, &name, &value); err != nil {
            return cookies, err
        }
        cookie := &http.Cookie{
            Name:    name,
            Value:   value,
            Path:    path,
            Domain:  host,
            Expires: time.Unix(int64(expiry), 0),
            Secure:  secure == 1,
        }
        cookies = append(cookies, cookie)
    }
    return cookies, nil
}

func (ff *FireFox) getCookies() ([]*http.Cookie, error) {
    file, err := ff.findCookieFiles()
    if err != nil {
        return nil, err
    }
    return ff.getCookiesFromFile(file)
}

// LoadFireFox will load all your cookies from FireFox.
func LoadFireFox() (*FireFox, error) {
    jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
    if err != nil {
        return nil, err
    }
    ff := &FireFox{jar}
    cookies, err := ff.getCookies()
    if err != nil {
        return nil, err
    }
    for _, cookie := range cookies {
        scheme := "http://"
        if cookie.Secure {
            scheme = "https://"
        }
        u, err := url.Parse(scheme + cookie.Domain + cookie.Path)
        if err != nil {
            return nil, err
        }
        ff.SetCookies(u, []*http.Cookie{cookie})
    }
    return ff, nil
}