Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 3 additions & 1 deletion .github/workflows/release.yml
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ on:
branches: ["main", "master"]

permissions:
contents: write
contents: read

jobs:
# ==========================================================================
Expand Down Expand Up @@ -177,6 +177,8 @@ jobs:
# ==========================================================================
publish-release:
name: Publish GitHub Release (6 Executables)
permissions:
contents: write
needs: build-matrix
if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
runs-on: ubuntu-latest
Expand Down
35 changes: 26 additions & 9 deletions internal/fuse/mount.go
Original file line number Diff line number Diff line change
Expand Up @@ -161,31 +161,43 @@ func (f *VaultFuseFS) Open(path string, flags int) (int, uint64) {
}

func (f *VaultFuseFS) Read(path string, buff []byte, ofst int64, fh uint64) int {
if ofst < 0 {
return -fuse.EINVAL
}

f.mu.Lock()
h, ok := f.handles[fh]
f.mu.Unlock()
if !ok {
f.mu.Unlock()
return -fuse.EBADF
}

if h.dirty {
if ofst >= int64(len(h.buf)) {
f.mu.Unlock()
return 0
}
return copy(buff, h.buf[ofst:])
n := copy(buff, h.buf[int(ofst):])
f.mu.Unlock()
return n
}
seeker := h.seeker
f.mu.Unlock()

if h.seeker == nil {
if seeker == nil {
return -fuse.EIO
}
n, err := h.seeker.ReadAt(buff, ofst)
n, err := seeker.ReadAt(buff, ofst)
if err != nil && err != io.EOF {
return -fuse.EIO
}
return n
}

func (f *VaultFuseFS) Write(path string, buff []byte, ofst int64, fh uint64) int {
if ofst < 0 || uint64(ofst) > uint64(^uint(0)>>1)-uint64(len(buff)) {
return -fuse.EINVAL
}

f.mu.Lock()
h, ok := f.handles[fh]
if !ok {
Expand All @@ -199,9 +211,11 @@ func (f *VaultFuseFS) Write(path string, buff []byte, ofst int64, fh uint64) int
h.seeker = nil
}
existing, err := f.vault.ReadFile(path)
if err == nil {
h.buf = existing
if err != nil {
f.mu.Unlock()
return -fuse.EIO
}
h.buf = existing
h.dirty = true
}

Expand All @@ -211,15 +225,18 @@ func (f *VaultFuseFS) Write(path string, buff []byte, ofst int64, fh uint64) int
copy(newBuf, h.buf)
h.buf = newBuf
}
copy(h.buf[ofst:], buff)
copy(h.buf[int(ofst):], buff)
f.mu.Unlock()
return len(buff)
}

func (f *VaultFuseFS) Flush(path string, fh uint64) int {
// Keep the handle locked while persisting its buffer: a concurrent Write
// must not race with the snapshot or be lost when dirty is cleared.
f.mu.Lock()
defer f.mu.Unlock()

h, ok := f.handles[fh]
f.mu.Unlock()
if !ok {
return 0
}
Expand Down
12 changes: 10 additions & 2 deletions internal/vault/ecc_rs.go
Original file line number Diff line number Diff line change
Expand Up @@ -141,7 +141,10 @@ func VerifyAndHealWithECC(targetPath string) (healed bool, damagedShards int, er
eccPath := targetPath + ".ecc"
eccRaw, err := os.ReadFile(eccPath)
if err != nil {
return false, 0, nil // Sidecar non presente: continua normalmente
if os.IsNotExist(err) {
return false, 0, nil // Sidecar assente: nessun controllo ECC disponibile.
}
return false, 0, err
}

const fixedHdr = 8 + 12 + (rsTotalShards * 32)
Expand All @@ -162,7 +165,12 @@ func VerifyAndHealWithECC(targetPath string) (healed bool, damagedShards int, er
offset += 32
}

rawData, _ := os.ReadFile(targetPath)
rawData, readErr := os.ReadFile(targetPath)
if readErr != nil && !os.IsNotExist(readErr) {
// Non confondere un errore di permessi/I/O con un file cancellato:
// altrimenti la procedura potrebbe ricostruire e sovrascrivere dati.
return false, damagedShards, readErr
}
shards := make([][]byte, rsTotalShards)
validShard := make([]bool, rsTotalShards)

Expand Down
15 changes: 11 additions & 4 deletions internal/vault/seeker.go
Original file line number Diff line number Diff line change
Expand Up @@ -86,18 +86,25 @@ func (s *VaultReadSeeker) Seek(offset int64, whence int) (int64, error) {
s.mu.Lock()
defer s.mu.Unlock()

var newPos int64
var base int64
switch whence {
case io.SeekStart:
newPos = offset
base = 0
case io.SeekCurrent:
newPos = s.pos + offset
base = s.pos
case io.SeekEnd:
newPos = s.entry.OriginalSize + offset
base = s.entry.OriginalSize
default:
return 0, errors.New("whence non valido in Seek")
}

// Evita overflow signed quando si sommano offset non attendibili provenienti
// da chiamanti FUSE, parser o viewer.
if (offset > 0 && base > int64(^uint64(0)>>1)-offset) ||
(offset < 0 && base < (-int64(^uint64(0)>>1)-1)-offset) {
return 0, errors.New("offset fuori intervallo in Seek")
}
newPos := base + offset
if newPos < 0 {
return 0, errors.New("seek a posizione negativa non consentito")
}
Expand Down
11 changes: 10 additions & 1 deletion internal/vault/vault.go
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@ import (
"bufio"
"bytes"
"crypto/rand"
"crypto/subtle"
"encoding/hex"
"encoding/json"
"errors"
Expand Down Expand Up @@ -229,9 +230,17 @@ func (v *SecureVault) ChangePassword(oldPassword, newPassword string) error {
v.mu.Lock()
defer v.mu.Unlock()

if _, err := v.unwrapDEK(oldPassword, v.salt); err != nil {
verifiedDEK, err := v.unwrapDEK(oldPassword, v.salt)
if err != nil {
return errors.New("la password attuale inserita non è corretta")
}
matchesCurrentKey := subtle.ConstantTimeCompare(verifiedDEK, v.dek) == 1
for i := range verifiedDEK {
verifiedDEK[i] = 0
}
if !matchesCurrentKey {
return errors.New("il vault.key non corrisponde alla chiave del Vault attualmente aperto")
}

newSalt := make([]byte, SaltSize)
if _, err := io.ReadFull(rand.Reader, newSalt); err != nil {
Expand Down
14 changes: 11 additions & 3 deletions secureusb-rs/src/vault/ecc_rs.rs
Original file line number Diff line number Diff line change
Expand Up @@ -114,8 +114,10 @@ pub fn write_ecc_sidecar(target_path: &Path) -> io::Result<()> {
/// fino a 4 shard danneggiati da bit-rot su 12 prima della decifratura Poly1305.
pub fn verify_and_heal_with_ecc(target_path: &Path) -> io::Result<(bool, usize)> {
let ecc_path = Path::new(&format!("{}.ecc", target_path.display())).to_path_buf();
let Ok(ecc_raw) = fs::read(&ecc_path) else {
return Ok((false, 0));
let ecc_raw = match fs::read(&ecc_path) {
Ok(data) => data,
Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok((false, 0)),
Err(err) => return Err(err),
};

let fixed_hdr = 8 + 12 + (RS_TOTAL_SHARDS * 32);
Expand All @@ -136,7 +138,13 @@ pub fn verify_and_heal_with_ecc(target_path: &Path) -> io::Result<(bool, usize)>
off += 32;
}

let raw_data = fs::read(target_path).unwrap_or_default();
let raw_data = match fs::read(target_path) {
Ok(data) => data,
// Un file mancante può essere ricostruito dai quattro shard di parità;
// gli altri errori devono invece interrompere la riparazione.
Err(err) if err.kind() == io::ErrorKind::NotFound => Vec::new(),
Err(err) => return Err(err),
};
let mut shards = vec![vec![0u8; shard_size]; RS_TOTAL_SHARDS];
let mut valid = [false; RS_TOTAL_SHARDS];
let mut damaged_count = 0usize;
Expand Down
89 changes: 66 additions & 23 deletions secureusb-rs/src/vault/seeker.rs
Original file line number Diff line number Diff line change
Expand Up @@ -146,18 +146,18 @@ impl VaultReadSeeker {

impl Seek for VaultReadSeeker {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
let new_pos: i64 = match pos {
SeekFrom::Start(o) => o as i64,
SeekFrom::Current(d) => (self.pos as i64) + d,
SeekFrom::End(d) => (self.entry.original_size as i64) + d,
};
if new_pos < 0 {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"Seek negativo non consentito",
));
let new_pos = match pos {
SeekFrom::Start(offset) => Some(offset),
SeekFrom::Current(delta) => self.pos.checked_add_signed(delta),
SeekFrom::End(delta) => self.entry.original_size.checked_add_signed(delta),
}
self.pos = new_pos as u64;
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::InvalidInput,
"Posizione di seek fuori dall'intervallo u64",
)
})?;
self.pos = new_pos;
Ok(self.pos)
}
}
Expand Down Expand Up @@ -239,30 +239,69 @@ fn handle_http_range_client(
let mut range_start: u64 = 0;
let mut range_end: u64 = total_size.saturating_sub(1);
let mut is_partial = false;
let is_head = parts[0] == "HEAD";

if parts[0] != "GET" && !is_head {
stream.write_all(b"HTTP/1.1 405 Method Not Allowed\r\nAllow: GET, HEAD\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}

for line in lines {
if line.to_ascii_lowercase().starts_with("range:") {
if let Some( idx) = line.find("bytes=") {
let spec = line[idx + 6..].trim();
if let Some((s, e)) = spec.split_once('-') {
if let Ok(st) = s.parse::<u64>() {
range_start = st;
is_partial = true;
if let Some((name, value)) = line.split_once(':') {
if name.eq_ignore_ascii_case("range") {
let Some(spec) = value.trim().strip_prefix("bytes=") else {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
};
// Multi-range e suffix-range non sono supportati: rifiutali invece
// di restituire una risposta 206 incoerente.
if spec.contains(',') {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}
let Some((start, end)) = spec.split_once('-') else {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
};
if start.is_empty() {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}
range_start = match start.parse::<u64>() {
Ok(value) => value,
Err(_) => {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}
if let Ok(en) = e.parse::<u64>() {
range_end = en.min(total_size.saturating_sub(1));
};
range_end = if end.is_empty() {
total_size.saturating_sub(1)
} else {
match end.parse::<u64>() {
Ok(value) => value.min(total_size.saturating_sub(1)),
Err(_) => {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}
}
}
};
is_partial = true;
}
}
}

if total_size == 0 {
let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n");
stream.write_all(b"HTTP/1.1 200 OK\r\nAccept-Ranges: bytes\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}
if range_start >= total_size || range_start > range_end {
stream.write_all(b"HTTP/1.1 416 Range Not Satisfiable\r\nContent-Range: bytes */")?;
stream.write_all(total_size.to_string().as_bytes())?;
stream.write_all(b"\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")?;
return Ok(());
}

let content_len = range_end.saturating_sub(range_start) + 1;
let content_len = range_end - range_start + 1;
if is_partial {
let header = format!(
"HTTP/1.1 206 Partial Content\r\nAccept-Ranges: bytes\r\nContent-Range: bytes {range_start}-{range_end}/{total_size}\r\nContent-Length: {content_len}\r\nConnection: close\r\n\r\n"
Expand All @@ -275,6 +314,10 @@ fn handle_http_range_client(
stream.write_all(header.as_bytes())?;
}

if is_head {
return Ok(());
}

seeker.seek(SeekFrom::Start(range_start))?;
let mut remaining = content_len;
let mut buf = vec![0u8; 64 * 1024];
Expand Down
Loading