Account for 16 vs 32 bit integers in folder upload

[rbdr/mobius] / hotline / account.go

diff --git a/hotline/account.go b/hotline/account.go
index 2c400aceafb56e28c6746f4f582d8347f69ddeab..39ea9740275c1771fa3892b1d4429661f4de0b8e 100644 (file)
--- a/hotline/account.go
+++ b/hotline/account.go
@@ -2,38 +2,71 @@ package hotline
 
 import (
        "encoding/binary"
 
 import (
        "encoding/binary"

+       "fmt"

        "golang.org/x/crypto/bcrypt"
        "golang.org/x/crypto/bcrypt"

+       "io"
+       "slices"

 )
 
 const GuestAccount = "guest" // default account used when no login is provided for a connection
 
 type Account struct {
 )
 
 const GuestAccount = "guest" // default account used when no login is provided for a connection
 
 type Account struct {

-       Login    string  `yaml:"Login"`
-       Name     string  `yaml:"Name"`
-       Password string  `yaml:"Password"`
-       Access   *[]byte `yaml:"Access"` // 8 byte bitmap
+       Login    string       `yaml:"Login"`
+       Name     string       `yaml:"Name"`
+       Password string       `yaml:"Password"`
+       Access   AccessBitmap `yaml:"Access"`
+       FileRoot string       `yaml:"FileRoot"`
+
+       readOffset int // Internal offset to track read progress
+}
+
+func NewAccount(login, name, password string, access AccessBitmap) *Account {
+       return &Account{
+               Login:    login,
+               Name:     name,
+               Password: HashAndSalt([]byte(password)),
+               Access:   access,
+       }

 }
 
 // Read implements io.Reader interface for Account
 }
 
 // Read implements io.Reader interface for Account

-func (a *Account) Read(p []byte) (n int, err error) {
+func (a *Account) Read(p []byte) (int, error) {

        fields := []Field{
        fields := []Field{

-               NewField(fieldUserName, []byte(a.Name)),
-               NewField(fieldUserLogin, negateString([]byte(a.Login))),
-               NewField(fieldUserAccess, *a.Access),
+               NewField(FieldUserName, []byte(a.Name)),
+               NewField(FieldUserLogin, EncodeString([]byte(a.Login))),
+               NewField(FieldUserAccess, a.Access[:]),

        }
 
        if bcrypt.CompareHashAndPassword([]byte(a.Password), []byte("")) != nil {
        }
 
        if bcrypt.CompareHashAndPassword([]byte(a.Password), []byte("")) != nil {

-               fields = append(fields, NewField(fieldUserPassword, []byte("x")))
+               fields = append(fields, NewField(FieldUserPassword, []byte("x")))

        }
 
        fieldCount := make([]byte, 2)
        binary.BigEndian.PutUint16(fieldCount, uint16(len(fields)))
 
        }
 
        fieldCount := make([]byte, 2)
        binary.BigEndian.PutUint16(fieldCount, uint16(len(fields)))
 

-       p = append(p, fieldCount...)
-
+       var fieldBytes []byte

        for _, field := range fields {
        for _, field := range fields {

-               p = append(p, field.Payload()...)
+               b, err := io.ReadAll(&field)
+               if err != nil {
+                       return 0, fmt.Errorf("error reading field: %w", err)
+               }
+               fieldBytes = append(fieldBytes, b...)

        }
 
        }
 

-       return len(p), nil
+       buf := slices.Concat(fieldCount, fieldBytes)
+       if a.readOffset >= len(buf) {
+               return 0, io.EOF // All bytes have been read
+       }
+
+       n := copy(p, buf[a.readOffset:])
+       a.readOffset += n
+
+       return n, nil
+}
+
+// HashAndSalt generates a password hash from a users obfuscated plaintext password
+func HashAndSalt(pwd []byte) string {
+       hash, _ := bcrypt.GenerateFromPassword(pwd, bcrypt.MinCost)
+
+       return string(hash)

 }
 }