dkelly/go-nkode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement svg interface in login and signup

Browse Source
This commit is contained in:
Donovan
2024-09-13 15:18:36 -05:00
parent 8ba7ae206f
commit 3013e74bc5
32 changed files with 515 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
core/nkode/common.go
View File

@@ -7,7 +7,7 @@ import (
py "go-nkode/py-builtin"
)
var KeyIndexOutOfRange error = errors.New("one or more keys is out of range")
var KeyIndexOutOfRange = errors.New("one or more keys is out of range")
func ValidKeyEntry(user m.User, customer m.Customer, selectedKeys []int) ([]int, error) {
validKeys := py.All[int](selectedKeys, func(idx int) bool {
@@ -55,7 +55,7 @@ func ValidKeyEntry(user m.User, customer m.Customer, selectedKeys []int) ([]int,
if err != nil {
panic(err)
}
err = user.UserKeys.ValidPassword(user.EncipheredPasscode.Code, presumedAttrIdxVals, attrVals)
err = user.CipherKeys.ValidPassword(user.EncipheredPasscode.Code, presumedAttrIdxVals, attrVals)
if err != nil {
return nil, err
}
@@ -80,7 +80,7 @@ func NewUser(customer m.Customer, username m.Username, passcodeIdx []int, ui m.U
Id: m.UserId(uuid.New()),
Username: username,
EncipheredPasscode: *encipheredNKode,
UserKeys: *newKeys,
CipherKeys: *newKeys,
Interface: ui,
Kp: kp,
CustomerId: customer.Id,

10
core/nkode/customer_test.go
View File

@@ -23,11 +23,12 @@ func testCustomerValidKeyEntry(t *testing.T) {
nkodePolicy := model.NewDefaultNKodePolicy()
customer, err := model.NewCustomer(nkodePolicy)
assert.NoError(t, err)
newUserInterface, err := model.NewUserInterface(&kp)
mockSvgInterface := make(model.SvgIdInterface, kp.TotalAttrs())
userInterface, err := model.NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
username := model.Username("testing123")
passcodeIdx := []int{0, 1, 2, 3}
user, err := NewUser(*customer, username, passcodeIdx, *newUserInterface, kp)
user, err := NewUser(*customer, username, passcodeIdx, *userInterface, kp)
assert.NoError(t, err)
userLoginInterface, err := user.GetLoginInterface()
assert.NoError(t, err)
@@ -46,11 +47,12 @@ func testCustomerIsValidNKode(t *testing.T) {
nkodePolicy := model.NewDefaultNKodePolicy()
customer, err := model.NewCustomer(nkodePolicy)
assert.NoError(t, err)
newUserInterface, err := model.NewUserInterface(&kp)
mockSvgInterface := make(model.SvgIdInterface, kp.TotalAttrs())
userInterface, err := model.NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
username := model.Username("testing123")
passcodeIdx := []int{0, 1, 2, 3}
user, err := NewUser(*customer, username, passcodeIdx, *newUserInterface, kp)
user, err := NewUser(*customer, username, passcodeIdx, *userInterface, kp)
assert.NoError(t, err)
err = customer.IsValidNKode(user.Kp, passcodeIdx)
assert.NoError(t, err)

3
core/nkode/db_accessor.go
View File

@@ -12,4 +12,7 @@ type DbAccessor interface {
UpdateUserInterface(model.UserId, model.UserInterface) error
Renew(model.CustomerId) error
RefreshUser(model.User, []int, model.CustomerAttributes) error
RandomSvgInterface(model.KeypadDimension) ([]string, error)
RandomSvgIdxInterface(model.KeypadDimension) (model.SvgIdInterface, error)
GetSvgStringInterface(model.SvgIdInterface) ([]string, error)
}

12
core/nkode/in_memory_db.go
View File

@@ -105,6 +105,18 @@ func (db *InMemoryDb) RefreshUser(user m.User, passocode []int, customerAttr m.C
return nil
}
func (db *InMemoryDb) RandomSvgInterface(kp m.KeypadDimension) ([]string, error) {
return nil, errors.ErrUnsupported
}
func (db *InMemoryDb) RandomSvgIdxInterface(kp m.KeypadDimension) (m.SvgIdInterface, error) {
return nil, errors.ErrUnsupported
}
func (db InMemoryDb) GetSvgStringInterface(idxs m.SvgIdInterface) ([]string, error) {
return nil, errors.ErrUnsupported
}
func userIdKey(customerId m.CustomerId, username m.Username) string {
key := fmt.Sprintf("%s:%s", customerId, username)
return key

37
core/nkode/nkode_api.go
View File

@@ -35,14 +35,23 @@ func (n *NKodeAPI) CreateNewCustomer(nkodePolicy m.NKodePolicy, id *m.CustomerId
}
func (n *NKodeAPI) GenerateSignupInterface(username m.Username, customerId m.CustomerId, kp m.KeypadDimension) (*m.GenerateSignupInterfaceResp, error) {
signupSession, err := NewSignupSession(username, kp, customerId)
svgIdxInterface, err := n.Db.RandomSvgIdxInterface(kp)
if err != nil {
return nil, err
}
signupSession, err := NewSignupSession(username, kp, customerId, svgIdxInterface)
if err != nil {
return nil, err
}
n.SignupSessions[signupSession.Id] = *signupSession
svgInterface, err := n.Db.GetSvgStringInterface(signupSession.LoginUserInterface.SvgId)
if err != nil {
return nil, err
}
resp := m.GenerateSignupInterfaceResp{
UserInterface: signupSession.SetIdxInterface,
SessionId: signupSession.Id,
UserIdxInterface: signupSession.SetIdxInterface,
SvgInterface: svgInterface,
SessionId: signupSession.Id,
}
return &resp, nil
}
@@ -86,12 +95,12 @@ func (n *NKodeAPI) ConfirmNKode(customerId m.CustomerId, sessionId m.SessionId,
if err != nil {
return err
}
delete(n.SignupSessions, session.Id)
err = n.Db.WriteNewUser(*user)
delete(n.SignupSessions, session.Id)
return err
}
func (n *NKodeAPI) GetLoginInterface(username m.Username, customerId m.CustomerId) (m.IdxInterface, error) {
func (n *NKodeAPI) GetLoginInterface(username m.Username, customerId m.CustomerId) (*m.GetLoginInterfaceResp, error) {
user, err := n.Db.GetUser(username, customerId)
if err != nil {
return nil, err
@@ -104,7 +113,15 @@ func (n *NKodeAPI) GetLoginInterface(username m.Username, customerId m.CustomerI
if err != nil {
return nil, err
}
return user.Interface.IdxInterface, nil
svgInterface, err := n.Db.GetSvgStringInterface(user.Interface.SvgId)
if err != nil {
return nil, err
}
resp := m.GetLoginInterfaceResp{
UserIdxInterface: user.Interface.IdxInterface,
SvgInterface: svgInterface,
}
return &resp, nil
}
func (n *NKodeAPI) Login(customerId m.CustomerId, username m.Username, keySelection m.KeySelection) error {
@@ -132,3 +149,11 @@ func (n *NKodeAPI) Login(customerId m.CustomerId, username m.Username, keySelect
func (n *NKodeAPI) RenewAttributes(customerId m.CustomerId) error {
return n.Db.Renew(customerId)
}
func (n *NKodeAPI) RandomSvgInterface() ([]string, error) {
return n.Db.RandomSvgInterface(m.KeypadMax)
}
func (n *NKodeAPI) GetSvgStringInterface(svgId m.SvgIdInterface) ([]string, error) {
return n.Db.GetSvgStringInterface(svgId)
}

33
core/nkode/nkode_api_test.go
View File

@@ -3,7 +3,7 @@ package nkode
import (
"github.com/stretchr/testify/assert"
m "go-nkode/core/model"
"os"
"go-nkode/util"
"testing"
)
@@ -11,22 +11,25 @@ func TestNKodeAPI(t *testing.T) {
//db1 := NewInMemoryDb()
//1testNKodeAPI(t, &db1)
dbFile := "test.db"
db2, err := NewSqliteDB(dbFile)
assert.NoError(t, err)
dbFile := "../../test.db"
// sql_driver.MakeTables(dbFile)
db2 := NewSqliteDB(dbFile)
defer db2.CloseDb()
testNKodeAPI(t, db2)
if _, err := os.Stat(dbFile); err == nil {
err = os.Remove(dbFile)
assert.NoError(t, err)
} else {
assert.NoError(t, err)
}
// if _, err := os.Stat(dbFile); err == nil {
// err = os.Remove(dbFile)
// assert.NoError(t, err)
// } else {
// assert.NoError(t, err)
// }
}
func testNKodeAPI(t *testing.T, db DbAccessor) {
for idx := 0; idx < 10; idx++ {
username := m.Username("test_username")
for idx := 0; idx < 1; idx++ {
username := m.Username("test_username" + util.GenerateRandomString(12))
passcodeLen := 4
nkodePolicy := m.NewDefaultNKodePolicy()
keypadSize := m.KeypadDimension{AttrsPerKey: 10, NumbOfKeys: 8}
@@ -35,7 +38,7 @@ func testNKodeAPI(t *testing.T, db DbAccessor) {
assert.NoError(t, err)
signupResponse, err := nkodeApi.GenerateSignupInterface(username, *customerId, keypadSize)
assert.NoError(t, err)
setInterface := signupResponse.UserInterface
setInterface := signupResponse.UserIdxInterface
sessionId := signupResponse.SessionId
keypadSize = m.KeypadDimension{AttrsPerKey: 8, NumbOfKeys: 8}
userPasscode := setInterface[:passcodeLen]
@@ -50,7 +53,7 @@ func testNKodeAPI(t *testing.T, db DbAccessor) {
keypadSize = m.KeypadDimension{AttrsPerKey: 10, NumbOfKeys: 8}
loginInterface, err := nkodeApi.GetLoginInterface(username, *customerId)
assert.NoError(t, err)
loginKeySelection, err := m.SelectKeyByAttrIdx(loginInterface, userPasscode, keypadSize)
loginKeySelection, err := m.SelectKeyByAttrIdx(loginInterface.UserIdxInterface, userPasscode, keypadSize)
assert.NoError(t, err)
err = nkodeApi.Login(*customerId, username, loginKeySelection)
assert.NoError(t, err)
@@ -60,7 +63,7 @@ func testNKodeAPI(t *testing.T, db DbAccessor) {
loginInterface, err = nkodeApi.GetLoginInterface(username, *customerId)
assert.NoError(t, err)
loginKeySelection, err = m.SelectKeyByAttrIdx(loginInterface, userPasscode, keypadSize)
loginKeySelection, err = m.SelectKeyByAttrIdx(loginInterface.UserIdxInterface, userPasscode, keypadSize)
assert.NoError(t, err)
err = nkodeApi.Login(*customerId, username, loginKeySelection)
assert.NoError(t, err)

243
core/nkode/sqlite_db.go
View File

@@ -12,101 +12,70 @@ import (
)
type SqliteDB struct {
path string
db *sql.DB
}
func NewSqliteDB(path string) (*SqliteDB, error) {
sqldb := SqliteDB{path: path}
err := sqldb.NewTables()
func NewSqliteDB(path string) *SqliteDB {
db, err := sql.Open("sqlite3", path)
if err != nil {
log.Fatal("database didn't open ", err)
}
sqldb := SqliteDB{db: db}
return &sqldb, err
return &sqldb
}
func (d *SqliteDB) NewTables() error {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
log.Fatal(err)
func (d *SqliteDB) CloseDb() {
if err := d.db.Close(); err != nil {
// If db.Close() returns an error, panic
panic(fmt.Sprintf("Failed to close the database: %v", err))
}
defer db.Close()
createTables := `
PRAGMA foreign_keys = ON;
CREATE TABLE IF NOT EXISTS customer (
id TEXT NOT NULL PRIMARY KEY,
max_nkode_len INTEGER NOT NULL,
min_nkode_len INTEGER NOT NULL,
distinct_sets INTEGER NOT NULL,
distinct_attributes INTEGER NOT NULL,
lock_out INTEGER NOT NULL,
expiration INTEGER NOT NULL,
attribute_values BLOB NOT NULL,
set_values BLOB NOT NULL
);
CREATE TABLE IF NOT EXISTS user (
id TEXT NOT NULL PRIMARY KEY,
username TEXT NOT NULL,
renew INT NOT NULL,
customer_id TEXT NOT NULL,
-- Enciphered Passcode
code TEXT NOT NULL,
mask TEXT NOT NULL,
-- Keypad Dimensions
attributes_per_key INT NOT NULL,
number_of_keys INT NOT NULL,
-- User Keys
alpha_key BLOB NOT NULL,
set_key BLOB NOT NULL,
pass_key BLOB NOT NULL,
mask_key BLOB NOT NULL,
salt BLOB NOT NULL,
max_nkode_len INT NOT NULL,
-- User Interface
idx_interface BLOB NOT NULL,
FOREIGN KEY (customer_id) REFERENCES customers(id),
UNIQUE(customer_id, username)
);
`
_, err = db.Exec(createTables)
if err != nil {
return err
}
return nil
}
func (d *SqliteDB) WriteNewCustomer(c m.Customer) error {
db, err := sql.Open("sqlite3", d.path)
tx, err := d.db.Begin()
if err != nil {
log.Fatal(err)
return err
}
defer db.Close()
defer func() {
if err != nil {
err = tx.Rollback()
if err != nil {
log.Fatal(fmt.Sprintf("Write new customer won't roll back %+v", err))
}
}
}()
insertCustomer := `
INSERT INTO customer (id, max_nkode_len, min_nkode_len, distinct_sets, distinct_attributes, lock_out, expiration, attribute_values, set_values)
VALUES (?,?,?,?,?,?,?,?,?)
`
_, err = db.Exec(insertCustomer, uuid.UUID(c.Id), c.NKodePolicy.MaxNkodeLen, c.NKodePolicy.MinNkodeLen, c.NKodePolicy.DistinctSets, c.NKodePolicy.DistinctAttributes, c.NKodePolicy.LockOut, c.NKodePolicy.Expiration, c.Attributes.AttrBytes(), c.Attributes.SetBytes())
return err
_, err = tx.Exec(insertCustomer, uuid.UUID(c.Id), c.NKodePolicy.MaxNkodeLen, c.NKodePolicy.MinNkodeLen, c.NKodePolicy.DistinctSets, c.NKodePolicy.DistinctAttributes, c.NKodePolicy.LockOut, c.NKodePolicy.Expiration, c.Attributes.AttrBytes(), c.Attributes.SetBytes())
if err != nil {
return err
}
err = tx.Commit()
if err != nil {
return err
}
return nil
}
func (d *SqliteDB) WriteNewUser(u m.User) error {
db, err := sql.Open("sqlite3", d.path)
tx, err := d.db.Begin()
if err != nil {
log.Fatal(err)
return err
}
defer db.Close()
defer func() {
if err != nil {
err = tx.Rollback()
if err != nil {
log.Fatal(fmt.Sprintf("Write new user won't roll back %+v", err))
}
}
}()
insertUser := `
INSERT INTO user (id, username, renew, customer_id, code, mask, attributes_per_key, number_of_keys, alpha_key, set_key, pass_key, mask_key, salt, max_nkode_len, idx_interface)
VALUES (?,?, ?,?,?,?,?,?,?,?,?,?,?,?,?)
INSERT INTO user (id, username, renew, customer_id, code, mask, attributes_per_key, number_of_keys, alpha_key, set_key, pass_key, mask_key, salt, max_nkode_len, idx_interface, svg_id_interface)
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
`
var renew int
if u.Renew {
@@ -114,19 +83,21 @@ VALUES (?,?, ?,?,?,?,?,?,?,?,?,?,?,?,?)
} else {
renew = 0
}
_, err = db.Exec(insertUser, uuid.UUID(u.Id), u.Username, renew, uuid.UUID(u.CustomerId), u.EncipheredPasscode.Code, u.EncipheredPasscode.Mask, u.Kp.AttrsPerKey, u.Kp.NumbOfKeys, util.Uint64ArrToByteArr(u.UserKeys.AlphaKey), util.Uint64ArrToByteArr(u.UserKeys.SetKey), util.Uint64ArrToByteArr(u.UserKeys.PassKey), util.Uint64ArrToByteArr(u.UserKeys.MaskKey), u.UserKeys.Salt, u.UserKeys.MaxNKodeLen, util.IntArrToByteArr(u.Interface.IdxInterface))
_, err = tx.Exec(insertUser, uuid.UUID(u.Id), u.Username, renew, uuid.UUID(u.CustomerId), u.EncipheredPasscode.Code, u.EncipheredPasscode.Mask, u.Kp.AttrsPerKey, u.Kp.NumbOfKeys, util.Uint64ArrToByteArr(u.CipherKeys.AlphaKey), util.Uint64ArrToByteArr(u.CipherKeys.SetKey), util.Uint64ArrToByteArr(u.CipherKeys.PassKey), util.Uint64ArrToByteArr(u.CipherKeys.MaskKey), u.CipherKeys.Salt, u.CipherKeys.MaxNKodeLen, util.IntArrToByteArr(u.Interface.IdxInterface), util.IntArrToByteArr(u.Interface.SvgId))
return err
if err != nil {
return err
}
err = tx.Commit()
if err != nil {
return err
}
return nil
}
func (d *SqliteDB) GetCustomer(id m.CustomerId) (*m.Customer, error) {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return nil, err
}
defer db.Close()
selectCustomer := `SELECT max_nkode_len, min_nkode_len, distinct_sets, distinct_attributes, lock_out, expiration, attribute_values, set_values FROM customer WHERE id = ?`
rows, err := db.Query(selectCustomer, uuid.UUID(id))
rows, err := d.db.Query(selectCustomer, uuid.UUID(id))
if !rows.Next() {
return nil, errors.New(fmt.Sprintf("no new row for customer %s with err %s", id, rows.Err()))
@@ -165,17 +136,11 @@ func (d *SqliteDB) GetCustomer(id m.CustomerId) (*m.Customer, error) {
}
func (d *SqliteDB) GetUser(username m.Username, customerId m.CustomerId) (*m.User, error) {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return nil, err
}
defer db.Close()
userSelect := `
SELECT id, renew, code, mask, attributes_per_key, number_of_keys, alpha_key, set_key, pass_key, mask_key, salt, max_nkode_len, idx_interface FROM user
SELECT id, renew, code, mask, attributes_per_key, number_of_keys, alpha_key, set_key, pass_key, mask_key, salt, max_nkode_len, idx_interface, svg_id_interface FROM user
WHERE user.username = ? AND user.customer_id = ?
`
rows, err := db.Query(userSelect, string(username), uuid.UUID(customerId).String())
rows, err := d.db.Query(userSelect, string(username), uuid.UUID(customerId).String())
if !rows.Next() {
return nil, errors.New(fmt.Sprintf("no new rows for user %s of customer %s", string(username), uuid.UUID(customerId).String()))
}
@@ -192,8 +157,9 @@ WHERE user.username = ? AND user.customer_id = ?
var salt []byte
var maxNKodeLen int
var idxInterface []byte
var svgIdInterface []byte
err = rows.Scan(&id, &renewVal, &code, &mask, &attrsPerKey, &numbOfKeys, &alphaKey, &setKey, &passKey, &maskKey, &salt, &maxNKodeLen, &idxInterface)
err = rows.Scan(&id, &renewVal, &code, &mask, &attrsPerKey, &numbOfKeys, &alphaKey, &setKey, &passKey, &maskKey, &salt, &maxNKodeLen, &idxInterface, &svgIdInterface)
if rows.Next() {
return nil, errors.New(fmt.Sprintf("too many rows for user %s of customer %s", username, customerId))
}
@@ -221,7 +187,7 @@ WHERE user.username = ? AND user.customer_id = ?
AttrsPerKey: attrsPerKey,
NumbOfKeys: numbOfKeys,
},
UserKeys: m.UserCipherKeys{
CipherKeys: m.UserCipherKeys{
AlphaKey: util.ByteArrToUint64Arr(alphaKey),
SetKey: util.ByteArrToUint64Arr(setKey),
PassKey: util.ByteArrToUint64Arr(passKey),
@@ -232,26 +198,22 @@ WHERE user.username = ? AND user.customer_id = ?
},
Interface: m.UserInterface{
IdxInterface: util.ByteArrToIntArr(idxInterface),
SvgId: util.ByteArrToIntArr(svgIdInterface),
Kp: nil,
},
Renew: renew,
}
user.Interface.Kp = &user.Kp
user.UserKeys.Kp = &user.Kp
user.CipherKeys.Kp = &user.Kp
return &user, nil
}
func (d *SqliteDB) UpdateUserInterface(id m.UserId, ui m.UserInterface) error {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return err
}
defer db.Close()
updateUserInterface := `
UPDATE user SET idx_interface = ? WHERE id = ?
`
_, err = db.Exec(updateUserInterface, util.IntArrToByteArr(ui.IdxInterface), uuid.UUID(id).String())
_, err := d.db.Exec(updateUserInterface, util.IntArrToByteArr(ui.IdxInterface), uuid.UUID(id).String())
return err
}
@@ -263,23 +225,17 @@ func (d *SqliteDB) Renew(id m.CustomerId) error {
}
setXor, attrXor := customer.RenewKeys()
renewArgs := []any{util.Uint64ArrToByteArr(customer.Attributes.AttrVals), util.Uint64ArrToByteArr(customer.Attributes.SetVals), uuid.UUID(customer.Id).String()}
// TODO: replace with tx
renewExec := `
BEGIN TRANSACTION;
UPDATE customer SET attribute_values = ?, set_values = ? WHERE id = ?;
`
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return err
}
defer db.Close()
userQuery := `
SELECT id, alpha_key, set_key, attributes_per_key, number_of_keys FROM user WHERE customer_id = ?
`
rows, err := db.Query(userQuery, uuid.UUID(id).String())
rows, err := d.db.Query(userQuery, uuid.UUID(id).String())
for rows.Next() {
var userId string
var alphaBytes []byte
@@ -299,7 +255,7 @@ SELECT id, alpha_key, set_key, attributes_per_key, number_of_keys FROM user WHER
AttrsPerKey: attrsPerKey,
NumbOfKeys: numbOfKeys,
},
UserKeys: m.UserCipherKeys{
CipherKeys: m.UserCipherKeys{
AlphaKey: util.ByteArrToUint64Arr(alphaBytes),
SetKey: util.ByteArrToUint64Arr(setBytes),
},
@@ -311,29 +267,82 @@ SELECT id, alpha_key, set_key, attributes_per_key, number_of_keys FROM user WHER
return err
}
renewExec += "\nUPDATE user SET alpha_key = ?, set_key = ?, renew = ? WHERE id = ?;"
renewArgs = append(renewArgs, util.Uint64ArrToByteArr(user.UserKeys.AlphaKey), util.Uint64ArrToByteArr(user.UserKeys.SetKey), 1, userId)
renewArgs = append(renewArgs, util.Uint64ArrToByteArr(user.CipherKeys.AlphaKey), util.Uint64ArrToByteArr(user.CipherKeys.SetKey), 1, userId)
}
renewExec += `
COMMIT;
`
_, err = db.Exec(renewExec, renewArgs...)
_, err = d.db.Exec(renewExec, renewArgs...)
return err
}
func (d *SqliteDB) RefreshUser(user m.User, passcodeIdx []int, customerAttr m.CustomerAttributes) error {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return err
}
defer db.Close()
err = user.RefreshPasscode(passcodeIdx, customerAttr)
err := user.RefreshPasscode(passcodeIdx, customerAttr)
if err != nil {
return err
}
updateUser := `
UPDATE user SET renew = ?, code = ?, mask = ?, alpha_key = ?, set_key = ?, pass_key = ?, mask_key = ?, salt = ? WHERE id = ?;
`
_, err = db.Exec(updateUser, 0, user.EncipheredPasscode.Code, user.EncipheredPasscode.Mask, util.Uint64ArrToByteArr(user.UserKeys.AlphaKey), util.Uint64ArrToByteArr(user.UserKeys.SetKey), util.Uint64ArrToByteArr(user.UserKeys.PassKey), util.Uint64ArrToByteArr(user.UserKeys.MaskKey), user.UserKeys.Salt, uuid.UUID(user.Id).String())
_, err = d.db.Exec(updateUser, 0, user.EncipheredPasscode.Code, user.EncipheredPasscode.Mask, util.Uint64ArrToByteArr(user.CipherKeys.AlphaKey), util.Uint64ArrToByteArr(user.CipherKeys.SetKey), util.Uint64ArrToByteArr(user.CipherKeys.PassKey), util.Uint64ArrToByteArr(user.CipherKeys.MaskKey), user.CipherKeys.Salt, uuid.UUID(user.Id).String())
return err
}
func (d *SqliteDB) RandomSvgInterface(kp m.KeypadDimension) ([]string, error) {
ids, err := d.getRandomIds(kp.TotalAttrs())
if err != nil {
return nil, err
}
return d.getSvgsById(ids)
}
func (d *SqliteDB) RandomSvgIdxInterface(kp m.KeypadDimension) (m.SvgIdInterface, error) {
return d.getRandomIds(kp.TotalAttrs())
}
func (d *SqliteDB) GetSvgStringInterface(idxs m.SvgIdInterface) ([]string, error) {
return d.getSvgsById(idxs)
}
func (d *SqliteDB) getSvgsById(ids []int) ([]string, error) {
selectId := "SELECT svg FROM svg_icon where id = ?"
svgs := make([]string, len(ids))
for idx, id := range ids {
rows, err := d.db.Query(selectId, id)
if err != nil {
return nil, err
}
if !rows.Next() {
return nil, errors.New(fmt.Sprintf("id not found: %d", id))
}
err = rows.Scan(&svgs[idx])
if err != nil {
return nil, err
}
}
return svgs, nil
}
func (d *SqliteDB) getRandomIds(count int) ([]int, error) {
rows, err := d.db.Query("SELECT COUNT(*) as count FROM svg_icon;")
if err != nil {
return nil, err
}
var tableLen int
if !rows.Next() {
return nil, errors.New("empty svg_icon table")
}
err = rows.Scan(&tableLen)
if err != nil {
return nil, err
}
perm, err := util.RandomPermutation(tableLen)
for idx := range perm {
perm[idx] += 1
}
if err != nil {
return nil, err
}
return perm[:count], nil
}

36
core/nkode/sqlite_db_test.go
View File

@@ -3,14 +3,26 @@ package nkode
import (
"github.com/stretchr/testify/assert"
m "go-nkode/core/model"
"os"
"testing"
)
func TestNewSqliteDB(t *testing.T) {
dbFile := "test.db"
db, err := NewSqliteDB(dbFile)
assert.NoError(t, err)
dbFile := "../../test.db"
// sql_driver.MakeTables(dbFile)
db := NewSqliteDB(dbFile)
defer db.CloseDb()
testSignupLoginRenew(t, db)
testSqliteDBRandomSvgInterface(t, db)
// if _, err := os.Stat(dbFile); err == nil {
// err = os.Remove(dbFile)
// assert.NoError(t, err)
// } else {
// assert.NoError(t, err)
// }
}
func testSignupLoginRenew(t *testing.T, db DbAccessor) {
nkode_policy := m.NewDefaultNKodePolicy()
customerOrig, err := m.NewCustomer(nkode_policy)
assert.NoError(t, err)
@@ -22,7 +34,8 @@ func TestNewSqliteDB(t *testing.T) {
username := m.Username("test_user")
kp := m.KeypadDefault
passcodeIdx := []int{0, 1, 2, 3}
ui, err := m.NewUserInterface(&kp)
mockSvgInterface := make(m.SvgIdInterface, kp.TotalAttrs())
ui, err := m.NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
userOrig, err := NewUser(*customer, username, passcodeIdx, *ui, kp)
assert.NoError(t, err)
@@ -35,10 +48,11 @@ func TestNewSqliteDB(t *testing.T) {
err = db.Renew(customer.Id)
assert.NoError(t, err)
if _, err := os.Stat(dbFile); err == nil {
err = os.Remove(dbFile)
assert.NoError(t, err)
} else {
assert.NoError(t, err)
}
}
func testSqliteDBRandomSvgInterface(t *testing.T, db DbAccessor) {
kp := m.KeypadMax
svgs, err := db.RandomSvgInterface(kp)
assert.NoError(t, err)
assert.Len(t, svgs, kp.TotalAttrs())
}

4
core/nkode/user_signup_session.go
View File

@@ -22,8 +22,8 @@ type UserSignSession struct {
Expire int
}
func NewSignupSession(username m.Username, kp m.KeypadDimension, customerId m.CustomerId) (*UserSignSession, error) {
loginInterface, err := m.NewUserInterface(&kp)
func NewSignupSession(username m.Username, kp m.KeypadDimension, customerId m.CustomerId, svgInterface m.SvgIdInterface) (*UserSignSession, error) {
loginInterface, err := m.NewUserInterface(&kp, svgInterface)
if err != nil {
return nil, err
}