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

1
core/api/endpoints.go
View File

@@ -8,4 +8,5 @@ const (
GetLoginInterface = "/get-login-interface"
Login = "/login"
RenewAttributes = "/renew-attributes"
RandomSvgInterface = "/random-svg-interface"
)

46
core/model/nkode_handler.go
View File

@@ -28,6 +28,8 @@ func (h *NKodeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.LoginHandler(w, r)
case api.RenewAttributes:
h.RenewAttributesHandler(w, r)
case api.RandomSvgInterface:
h.RandomSvgInterfaceHandler(w, r)
default:
w.WriteHeader(http.StatusNotFound)
_, err := w.Write([]byte("404 not found"))
@@ -77,6 +79,7 @@ func (h *NKodeHandler) GenerateSignupInterfaceHandler(w http.ResponseWriter, r *
methodNotAllowed(w)
return
}
log.Print("signup interface")
var signupPost GenerateSignupInterfacePost
err := decodeJson(w, r, &signupPost)
@@ -95,7 +98,7 @@ func (h *NKodeHandler) GenerateSignupInterfaceHandler(w http.ResponseWriter, r *
log.Println(err)
return
}
resp, err := h.Api.GenerateSignupInterface(signupPost.Username, signupPost.CustomerId, kp)
resp, err := h.Api.GenerateSignupInterface(signupPost.Username, CustomerId(signupPost.CustomerId), kp)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
@@ -130,7 +133,7 @@ func (h *NKodeHandler) SetNKodeHandler(w http.ResponseWriter, r *http.Request) {
log.Println(err)
return
}
confirmInterface, err := h.Api.SetNKode(setNKodePost.CustomerId, setNKodePost.SessionId, setNKodePost.KeySelection)
confirmInterface, err := h.Api.SetNKode(CustomerId(setNKodePost.CustomerId), SessionId(setNKodePost.SessionId), setNKodePost.KeySelection)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
@@ -168,7 +171,7 @@ func (h *NKodeHandler) ConfirmNKodeHandler(w http.ResponseWriter, r *http.Reques
log.Println(err)
return
}
err = h.Api.ConfirmNKode(confirmNKodePost.CustomerId, confirmNKodePost.SessionId, confirmNKodePost.KeySelection)
err = h.Api.ConfirmNKode(CustomerId(confirmNKodePost.CustomerId), SessionId(confirmNKodePost.SessionId), confirmNKodePost.KeySelection)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
@@ -191,15 +194,14 @@ func (h *NKodeHandler) GetLoginInterfaceHandler(w http.ResponseWriter, r *http.R
log.Println(err)
return
}
loginInterface, err := h.Api.GetLoginInterface(loginInterfacePost.Username, loginInterfacePost.CustomerId)
loginInterface, err := h.Api.GetLoginInterface(loginInterfacePost.Username, CustomerId(loginInterfacePost.CustomerId))
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
return
}
respBody := GetLoginInterfaceResp{UserInterface: loginInterface}
respBytes, err := json.Marshal(respBody)
respBytes, err := json.Marshal(loginInterface)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
@@ -228,7 +230,7 @@ func (h *NKodeHandler) LoginHandler(w http.ResponseWriter, r *http.Request) {
log.Println(err)
return
}
err = h.Api.Login(loginPost.CustomerId, loginPost.Username, loginPost.KeySelection)
err = h.Api.Login(CustomerId(loginPost.CustomerId), loginPost.Username, loginPost.KeySelection)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
@@ -252,7 +254,35 @@ func (h *NKodeHandler) RenewAttributesHandler(w http.ResponseWriter, r *http.Req
return
}
err = h.Api.RenewAttributes(renewAttributesPost.CustomerId)
err = h.Api.RenewAttributes(CustomerId(renewAttributesPost.CustomerId))
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
return
}
w.WriteHeader(http.StatusOK)
}
func (h *NKodeHandler) RandomSvgInterfaceHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
methodNotAllowed(w)
}
svgs, err := h.Api.RandomSvgInterface()
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
return
}
respBody := RandomSvgInterfaceResp{Svgs: svgs}
respBytes, err := json.Marshal(respBody)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)
return
}
_, err = w.Write(respBytes)
if err != nil {
internalServerErrorHandler(w)
log.Println(err)

41
core/model/type.go
View File

@@ -8,42 +8,46 @@ type SetNKodeResp struct {
UserInterface []int `json:"user_interface"`
}
type RandomSvgInterfaceResp struct {
Svgs []string `json:"svgs"`
}
type NewCustomerPost struct {
NKodePolicy NKodePolicy `json:"nkode_policy"`
}
type GenerateSignupInterfacePost struct {
CustomerId CustomerId `json:"customer_id"`
AttrsPerKey int `json:"attrs_per_key"`
NumbOfKeys int `json:"numb_of_keys"`
Username Username `json:"username"`
CustomerId uuid.UUID `json:"customer_id"`
AttrsPerKey int `json:"attrs_per_key"`
NumbOfKeys int `json:"numb_of_keys"`
Username Username `json:"username"`
}
type SetNKodePost struct {
CustomerId CustomerId `json:"customer_id"`
CustomerId uuid.UUID `json:"customer_id"`
KeySelection KeySelection `json:"key_selection"`
SessionId SessionId `json:"session_id"`
SessionId uuid.UUID `json:"session_id"`
}
type ConfirmNKodePost struct {
CustomerId CustomerId `json:"customer_id"`
CustomerId uuid.UUID `json:"customer_id"`
KeySelection KeySelection `json:"key_selection"`
SessionId SessionId `json:"session_id"`
SessionId uuid.UUID `json:"session_id"`
}
type GetLoginInterfacePost struct {
Username Username `json:"username"`
CustomerId CustomerId `json:"customer_id"`
Username Username `json:"username"`
CustomerId uuid.UUID `json:"customer_id"`
}
type LoginPost struct {
CustomerId CustomerId `json:"customer_id"`
CustomerId uuid.UUID `json:"customer_id"`
Username Username `json:"username"`
KeySelection KeySelection `json:"key_selection"`
}
type RenewAttributesPost struct {
CustomerId CustomerId `json:"customer_id"`
CustomerId uuid.UUID `json:"customer_id"`
}
type CreateNewCustomerResp struct {
@@ -51,12 +55,14 @@ type CreateNewCustomerResp struct {
}
type GenerateSignupInterfaceResp struct {
SessionId SessionId `json:"session_id"`
UserInterface IdxInterface `json:"user_interface"`
SessionId SessionId `json:"session_id"`
UserIdxInterface IdxInterface `json:"user_interface"`
SvgInterface []string `json:"svg_interface"`
}
type GetLoginInterfaceResp struct {
UserInterface IdxInterface `json:"user_interface"`
UserIdxInterface IdxInterface `json:"user_interface"`
SvgInterface []string `json:"svg_interface"`
}
type KeySelection []int
@@ -66,15 +72,18 @@ type UserId uuid.UUID
type Username string
type IdxInterface []int
type SvgIdInterface []int
type NKodeAPIInterface interface {
CreateNewCustomer(NKodePolicy, *CustomerId) (*CustomerId, error)
GenerateSignupInterface(Username, CustomerId, KeypadDimension) (*GenerateSignupInterfaceResp, error)
SetNKode(CustomerId, SessionId, KeySelection) (IdxInterface, error)
ConfirmNKode(CustomerId, SessionId, KeySelection) error
GetLoginInterface(Username, CustomerId) (IdxInterface, error)
GetLoginInterface(Username, CustomerId) (*GetLoginInterfaceResp, error)
Login(CustomerId, Username, KeySelection) error
RenewAttributes(CustomerId) error
RandomSvgInterface() ([]string, error)
GetSvgStringInterface(idInterface SvgIdInterface) ([]string, error)
}
type EncipheredNKode struct {

12
core/model/user.go
View File

@@ -10,29 +10,29 @@ type User struct {
Username Username
EncipheredPasscode EncipheredNKode
Kp KeypadDimension
UserKeys UserCipherKeys
CipherKeys UserCipherKeys
Interface UserInterface
Renew bool
}
func (u *User) DecipherMask(setVals []uint64, passcodeLen int) ([]uint64, error) {
return u.UserKeys.DecipherMask(u.EncipheredPasscode.Mask, setVals, passcodeLen)
return u.CipherKeys.DecipherMask(u.EncipheredPasscode.Mask, setVals, passcodeLen)
}
func (u *User) RenewKeys(setXor []uint64, attrXor []uint64) error {
u.Renew = true
var err error
u.UserKeys.SetKey, err = util.XorLists(setXor[:u.Kp.AttrsPerKey], u.UserKeys.SetKey)
u.CipherKeys.SetKey, err = util.XorLists(setXor[:u.Kp.AttrsPerKey], u.CipherKeys.SetKey)
if err != nil {
panic(err)
}
u.UserKeys.AlphaKey, err = util.XorLists(attrXor[:u.Kp.TotalAttrs()], u.UserKeys.AlphaKey)
u.CipherKeys.AlphaKey, err = util.XorLists(attrXor[:u.Kp.TotalAttrs()], u.CipherKeys.AlphaKey)
return err
}
func (u *User) RefreshPasscode(passcodeAttrIdx []int, customerAttributes CustomerAttributes) error {
setVals, err := customerAttributes.SetValsForKp(u.Kp)
newKeys, err := NewUserCipherKeys(&u.Kp, setVals, u.UserKeys.MaxNKodeLen)
newKeys, err := NewUserCipherKeys(&u.Kp, setVals, u.CipherKeys.MaxNKodeLen)
if err != nil {
return err
}
@@ -42,7 +42,7 @@ func (u *User) RefreshPasscode(passcodeAttrIdx []int, customerAttributes Custome
return err
}
u.UserKeys = *newKeys
u.CipherKeys = *newKeys
u.EncipheredPasscode = *encipheredPasscode
u.Renew = false
return nil

5
core/model/user_interface.go
View File

@@ -9,13 +9,16 @@ import (
type UserInterface struct {
IdxInterface IdxInterface
SvgId SvgIdInterface
Kp *KeypadDimension
}
func NewUserInterface(kp *KeypadDimension) (*UserInterface, error) {
func NewUserInterface(kp *KeypadDimension, svgId SvgIdInterface) (*UserInterface, error) {
idxInterface := util.IdentityArray(kp.TotalAttrs())
userInterface := UserInterface{
IdxInterface: idxInterface,
SvgId: svgId,
Kp: kp,
}
err := userInterface.RandomShuffle()

10
core/model/user_test.go
View File

@@ -59,7 +59,8 @@ func TestUserInterface_RandomShuffle(t *testing.T) {
AttrsPerKey: 10,
NumbOfKeys: 8,
}
userInterface, err := NewUserInterface(&kp)
mockSvgInterface := make(SvgIdInterface, kp.TotalAttrs())
userInterface, err := NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
userInterfaceCopy := make([]int, len(userInterface.IdxInterface))
copy(userInterfaceCopy, userInterface.IdxInterface)
@@ -81,8 +82,8 @@ func TestUserInterface_DisperseInterface(t *testing.T) {
for idx := 0; idx < 10000; idx++ {
kp := KeypadDimension{AttrsPerKey: 7, NumbOfKeys: 10}
userInterface, err := NewUserInterface(&kp)
mockSvgInterface := make(SvgIdInterface, kp.TotalAttrs())
userInterface, err := NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
preDispersion, err := userInterface.AttributeAdjacencyGraph()
assert.NoError(t, err)
@@ -100,7 +101,8 @@ func TestUserInterface_DisperseInterface(t *testing.T) {
func TestUserInterface_PartialInterfaceShuffle(t *testing.T) {
kp := KeypadDimension{AttrsPerKey: 7, NumbOfKeys: 10}
userInterface, err := NewUserInterface(&kp)
mockSvgInterface := make(SvgIdInterface, kp.TotalAttrs())
userInterface, err := NewUserInterface(&kp, mockSvgInterface)
assert.NoError(t, err)
preShuffle := userInterface.IdxInterface
err = userInterface.PartialInterfaceShuffle()

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
}

58
core/svg-icon/db_interface.go Normal file
View File

@@ -0,0 +1,58 @@
package svg_icon
import (
"database/sql"
"go-nkode/util"
)
type SvgIcon struct {
Id int
Svg string
}
type SvgIconDb struct {
path string
}
func (d *SvgIconDb) GetSvgsById(ids []int) ([]string, error) {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return nil, err
}
defer db.Close()
selectId := "SELECT svg FROM svg_icon where id = ?"
svgs := make([]string, len(ids))
for idx, id := range ids {
rows, err := db.Query(selectId, id)
if err != nil {
return nil, err
}
err = rows.Scan(&svgs[idx])
if err != nil {
return nil, err
}
}
return svgs, nil
}
func (d *SvgIconDb) GetRandomIds(count int) ([]int, error) {
db, err := sql.Open("sqlite3", d.path)
if err != nil {
return nil, err
}
defer db.Close()
rows, err := db.Query("SELECT COUNT(*) FROM svg_icon;")
if err != nil {
return nil, err
}
var tableLen int
err = rows.Scan(&tableLen)
if err != nil {
return nil, err
}
perm, err := util.RandomPermutation(tableLen)
if err != nil {
return nil, err
}
return perm[:count], nil
}